michis-python-sammlung 0.0.1__tar.gz

michis_python_sammlung-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

michis_python_sammlung-0.0.1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: michis_python_sammlung
+Version: 0.0.1
+Summary: Collection of mostly QT related stuff
+Author-email: Michael Mischko <mischkom@web.de>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mischkomichael/Michis_python_sammlung
+Project-URL: Issues, https://github.com/mischkomichael/Michis_python_sammlung/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

michis_python_sammlung-0.0.1/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "michis_python_sammlung"
+version = "0.0.1"
+authors = [
+  { name="Michael Mischko", email="mischkom@web.de" },
+]
+description = "Collection of mostly QT related stuff"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/mischkomichael/Michis_python_sammlung"
+Issues = "https://github.com/mischkomichael/Michis_python_sammlung/issues"

michis_python_sammlung-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

michis_python_sammlung-0.0.1/src/michis_python_sammlung/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ["..."]
+__version__ = "1.0.1"

michis_python_sammlung-0.0.1/src/michis_python_sammlung/pyqt/clickable_label.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+from PyQt6.QtCore import Qt, QSize, pyqtSignal, Qt, QPoint, QTimer, QRect
+from PyQt6.QtWidgets import QLabel, QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLayout, QSizePolicy, QStackedLayout
+from PyQt6.QtGui import QPixmap, QResizeEvent, QColorConstants, QPainter, QRegion, QCursor, QMouseEvent, QColor, QBitmap, QTransform
+
+from numbers import Number
+from typing import Callable
+
+from PyQt6.QtGui import QImage
+from michis_python_sammlung.pyqt.image_paths import Image_paths
+
+def create_alpha_mask(image: QImage | QPixmap) -> QBitmap:
+    # Ensure the image has an alpha channel
+    if isinstance(image, QPixmap):
+        image = image.toImage()
+    image_with_alpha = image.convertToFormat(QImage.Format.Format_ARGB32)
+    mask_image = image_with_alpha.createAlphaMask()
+    return QBitmap.fromImage(mask_image)
+
+class Clickable_label(QLabel):
+
+    sg_clicked = pyqtSignal(QMouseEvent)
+
+    def __init__(
+        self,
+        pixmap: str | QPixmap,
+        pixmap_hover: str | QPixmap,
+        on_click_action: Callable = lambda: ...,
+        cursor: QPixmap | Qt.CursorShape = Qt.CursorShape.ArrowCursor,
+        scaled: float = None,
+        heuristic_mask: bool = True,
+        parent: QWidget = None
+    ):
+        super().__init__(parent)
+        self.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self._scaled = scaled
+        self.configure_pixmaps(pixmap, pixmap_hover, scaled=scaled)
+        self._hovering = False
+        #somehow, the sizes are too small for the mask to not clip from the top and bottom ... 
+        self.setMinimumSize(self._pixmap_hover.size())
+        cursor = QCursor(cursor) if isinstance(cursor, QPixmap) else cursor
+        self.setCursor(cursor)
+        self._on_click_action: Callable = on_click_action
+        self._heuristic_mask = heuristic_mask
+        self._mask_initialized = True
+        # ### lazy mask evaluation to make sure Clickable_labels can be instantiated even without properly initialized paintDevice
+        #self.set_mask(heuristic_mask=heuristic_mask)
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, True)
+        self.setAutoFillBackground(False)
+
+    def sizeHint(self):
+        return self._pixmap_hover.size()
+
+    def showEvent(self, a0):
+        if not self._mask_initialized:
+            QTimer.singleShot(0, lambda: self._lazy_mask_init(self._heuristic_mask))
+        return super().showEvent(a0)
+    
+    def _lazy_mask_init(self, heuristic_mask: bool) -> None:
+        self.set_mask(heuristic_mask=heuristic_mask)
+        self._mask_initialized
+
+    def replace_widget(
+        self,
+        widget_to_replace: QWidget,
+        delete_old: bool = True
+    ) -> Clickable_label | tuple[Clickable_label]:
+        """
+        Replace an existing QWidget with self. Return self if delete_old is True or a tuple (self, replaced_widget) if not.
+        """
+        layouts_to_search: list[QLayout] = widget_to_replace.parent().findChildren(QVBoxLayout) + widget_to_replace.parent().findChildren(QHBoxLayout)
+        found_layout: None | QHBoxLayout | QVBoxLayout = None
+        for layout in layouts_to_search:
+            for index in range(layout.count()):
+                if widget_to_replace is layout.itemAt(index).widget():
+                    found_layout = layout
+                    break
+        if found_layout is None:
+            raise Exception("clickable_label.replace_widget_in_layout: widget has no layout !")
+        else:
+            found_layout.replaceWidget(widget_to_replace, self)
+            if delete_old:
+                widget_to_replace.deleteLater()
+                return self
+            else:
+                return (self, widget_to_replace)
+    
+    def resizeEvent(self, a0: QResizeEvent):
+        super().resizeEvent(a0)
+        self.set_mask(a0.size(), self._heuristic_mask)
+
+    def enterEvent(self, event):
+        self._hovering = True
+        self.setPixmap(self._pixmap_hover)
+        super().enterEvent(event)
+
+    def leaveEvent(self, a0):
+        self._hovering = False
+        self.setPixmap(self._pixmap)
+        super().leaveEvent(a0)
+
+    def mouseReleaseEvent(self, ev):
+        self._on_click_action()
+        self.sg_clicked.emit(ev)
+        return super().mouseReleaseEvent(ev)
+
+    def set_mask(self, new_size: QSize | None = None, heuristic_mask: bool=True) -> None:
+        new_size = new_size if new_size is not None else self._pixmap_hover.size()
+        empty_mask = QPixmap(new_size)
+        empty_mask.fill(QColorConstants.Transparent)
+        painter = QPainter(empty_mask)
+        center_anker_x = (new_size.width()-self._pixmap_hover.size().width())//2
+        center_anker_y = (new_size.height()-self._pixmap_hover.size().height())//2
+        painter.drawPixmap(center_anker_x, center_anker_y, self._pixmap_hover)
+        painter.end()
+        if not heuristic_mask:
+            self._mask = create_alpha_mask(empty_mask)
+        else:
+            self._mask = empty_mask.createHeuristicMask(clipTight=False)
+        self.setMask(self._mask)
+        # self.setMask(empty_mask.createMaskFromColor(QColorConstants.Transparent, Qt.MaskMode.MaskInColor))
+
+    def replace_on_click_action(self, new_action: Callable) -> None:
+        if not isinstance(new_action, Callable):
+            raise ValueError(f"utility.custom_widgets.clickable_label.Cliclable_label.replace_on_click_action:\
+                             Action must be of type 'Callable', is {type(new_action)} instead.")
+        self._on_click_action = new_action
+
+    def configure_pixmaps(self,
+        pixmap: str | QPixmap,
+        pixmap_hover: str | QPixmap,
+        scaled: float = None
+    ) -> None:
+        self._pixmap = QPixmap(pixmap) if isinstance(pixmap,str) else pixmap
+        self._pixmap_hover = QPixmap(pixmap_hover) if isinstance(pixmap_hover,str) else pixmap_hover
+        if self._pixmap.isNull() or self._pixmap_hover.isNull():
+            raise ValueError(f"Failed instantiating pixmap from path: {pixmap} / {pixmap_hover}")
+        if isinstance(scaled, Number):
+            self._scaled = scaled
+            self._pixmap = self._pixmap.scaled(self._pixmap.size()*self._scaled,transformMode=Qt.TransformationMode.SmoothTransformation)
+            self._pixmap_hover = self._pixmap_hover.scaled(self._pixmap_hover.size()*self._scaled,transformMode=Qt.TransformationMode.SmoothTransformation)
+        elif scaled is None:
+            self.setScaledContents(False)
+        self.setPixmap(self._pixmap)
+
+    def scale_pixmap(self, scaled: Number) -> None:
+        self._scaled = scaled
+        self._pixmap = self._pixmap.scaled(self.size()*self._scaled,transformMode=Qt.TransformationMode.SmoothTransformation)
+        self._pixmap_hover = self._pixmap_hover.scaled(self.size()*self._scaled,transformMode=Qt.TransformationMode.SmoothTransformation)
+
+    def reset(self) -> None:
+        self.setPixmap(self._pixmap)
+        self._hovering = False
+
+class Togglable_clickable_label(QWidget):
+
+    def __init__(
+        self,
+        untoggled_label: Clickable_label,
+        toggled_label: Clickable_label,
+        toggle_on_click: bool = True,
+        parent=None,
+        allow_expansion=True
+    ):
+        super().__init__(parent=parent)
+        if not (isinstance(untoggled_label, Clickable_label) or isinstance(toggled_label, Clickable_label)):
+            raise ValueError(f"label_1 and label_2 need to be of type Clickable_label not {type(untoggled_label), type(toggled_label)}")
+        self.untoggled_label = untoggled_label
+        self.toggled_label = toggled_label
+        size_1 = self.untoggled_label._pixmap_hover
+        size_2 = self.toggled_label._pixmap_hover
+        if allow_expansion:
+            self.setMinimumSize(QSize(size_1.width() if size_1.width() > size_2.width() else size_2.width(),
+                                    size_1.height() if size_1.height() > size_2.height() else size_2.height()))
+        else:
+            self.setFixedSize(QSize(size_1.width() if size_1.width() > size_2.width() else size_2.width(),
+                                                size_1.height() if size_1.height() > size_2.height() else size_2.height()))            
+        self._layout = QVBoxLayout(self)
+        self._layout.setContentsMargins(0,0,0,0)
+        self._layout.addWidget(untoggled_label)
+        self._layout.addWidget(toggled_label)
+        self.toggled = False
+        self.toggle(toggle=self.toggled)
+        if toggle_on_click:
+            print("TOGGLING")
+            self.untoggled_label.sg_clicked.connect(self.toggle)
+            self.toggled_label.sg_clicked.connect(self.toggle)
+
+    def toggle(self, mouse_event: QMouseEvent=None, toggle=None) -> None:
+        self.toggled = not self.toggled if toggle is None else toggle
+        if self.toggled:
+            self.untoggled_label.setVisible(False)
+            self.toggled_label.setVisible(True)
+        else:
+            self.toggled_label.setVisible(False)
+            self.untoggled_label.setVisible(True)
+
+    def replace_on_click_actions(self, action_1: Callable, action_2: Callable) -> None:
+        self.untoggled_label.replace_on_click_action(action_1)
+        self.toggled_label.replace_on_click_action(action_2)
+        
+def main():
+    import sys
+    app = QApplication(sys.argv)
+    label = Clickable_label(Image_paths.cogwheel, Image_paths.cogwheel_hover, heuristic_mask=False)
+    label.show()
+    sys.exit(app.exec())
+if __name__ == "__main__":
+    main()

michis_python_sammlung-0.0.1/src/michis_python_sammlung/pyqt/expandable_widget.py

@@ -0,0 +1,494 @@
+from PyQt6.QtCore import Qt, pyqtSignal, QPropertyAnimation, pyqtProperty, QSize, QPoint, QTimer, QCoreApplication, QEvent
+from PyQt6.QtWidgets import QWidget, QApplication, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QListWidget, QSizePolicy, QSpacerItem, QLayout
+from PyQt6.QtGui import QTransform, QPixmap, QPainter, QPen
+import PyQt6.sip as sip
+
+from pyqt_util import clear_layout
+from clickable_label import Clickable_label, Togglable_clickable_label, Image_paths
+
+import faulthandler
+faulthandler.enable()
+
+class Expandable_widget(QWidget):
+
+    ANIMATION_DURATION = 150
+    sg_animation_finished = pyqtSignal()
+    sg_animation_started = pyqtSignal()
+
+    _horizontal_directions = ("left", "right")
+    _vertical_directions = ("up", "down")
+    _possible_directions = _horizontal_directions + _vertical_directions
+
+    def __init__(self,
+        direction: str = "left",
+        animate_button: bool = False,
+        parent=None
+    ):
+        super().__init__(parent=parent)
+        if not direction in self._possible_directions:
+            raise ValueError(f"Invalid directional argument: {direction}. Valid arguments are: {self._possible_directions} !")
+        self.direction = direction
+        self._content_widget = QWidget(parent=self)
+        self.animation = None
+        self._expanded = False
+        self._animate_button = animate_button
+        self._widget_position_at_animation_start = None
+        self.toggle_button = self._create_toggle_button()
+        self.header_widget = self._create_header_widget()
+        # self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        self._setup()
+    
+    @property
+    def expanded(self) -> bool:
+        return self._expanded
+    
+    @property
+    def content_widget(self) -> QWidget:
+        return self._content_widget
+
+    def set_content_widget(self, widget: QWidget) -> None:
+        layout = self.layout()
+        if self.content_widget is not None:
+            removed_widget = layout.replaceWidget(self.content_widget, widget).widget()
+            removed_widget.setParent(None)
+            removed_widget.deleteLater()
+        else:
+            layout.addWidget(widget)
+        self._content_widget = widget
+        self._setup_animation()
+        self._execute_toggle()
+
+    def _create_toggle_button(self) -> Togglable_clickable_label:
+        untoggled_pixmap, untoggled_hover_pixmap, toggled_pixmap, toggled_hover_pixmap = self._create_button_pixmaps()
+        expand_button = Clickable_label(untoggled_pixmap, untoggled_hover_pixmap, lambda: self.toggle(True, True), scaled=0.6)
+        shrink_button = Clickable_label(toggled_pixmap, toggled_hover_pixmap, lambda: self.toggle(False, True), scaled=0.6)
+        toggle_button = Togglable_clickable_label(expand_button, shrink_button)
+        return toggle_button
+    
+    def _rotate_pixmaps(self,
+        base_pixmap: QPixmap,
+        base_hover_pixmap: QPixmap,
+        rotation_start: QTransform,
+        rotation_end: QTransform
+    ) -> tuple[QPixmap]:
+        untoggled_pixmap = base_pixmap.transformed(rotation_start)
+        untoggled_hover_pixmap = base_hover_pixmap.transformed(rotation_start)
+        toggled_pixmap = base_pixmap.transformed(rotation_end)
+        toggled_hover_pixmap = base_hover_pixmap.transformed(rotation_end)
+        return untoggled_pixmap, untoggled_hover_pixmap, toggled_pixmap, toggled_hover_pixmap       
+    
+    def _create_rotated_pixmaps_left(self,
+        base_pixmap: QPixmap,
+        base_hover_pixmap: QPixmap
+    ) -> tuple[QPixmap]:
+        if self._animate_button:
+            rotation_start = QTransform().rotate(180)
+            rotation_end = QTransform().rotate(0)
+        else:
+            rotation_start = QTransform().rotate(90)
+            rotation_end = QTransform().rotate(180)
+        return self._rotate_pixmaps(base_pixmap, base_hover_pixmap, rotation_start, rotation_end)
+    
+    def _create_rotated_pixmaps_right(self,
+        base_pixmap: QPixmap,
+        base_hover_pixmap: QPixmap
+    ) -> tuple[QPixmap]:
+        if self._animate_button:
+            rotation_start = QTransform().rotate(0)
+            rotation_end = QTransform().rotate(180)
+        else:
+            rotation_start = QTransform().rotate(90)
+            rotation_end = QTransform().rotate(0)
+        return self._rotate_pixmaps(base_pixmap, base_hover_pixmap, rotation_start, rotation_end)
+    
+    def _create_rotated_pixmaps_up(self,
+        base_pixmap: QPixmap,
+        base_hover_pixmap: QPixmap
+    ) -> tuple[QPixmap]:
+        if self._animate_button:
+            rotation_start = QTransform().rotate(270)
+            rotation_end = QTransform().rotate(90)
+        else:
+            rotation_start = QTransform().rotate(0)
+            rotation_end = QTransform().rotate(270)
+        return self._rotate_pixmaps(base_pixmap, base_hover_pixmap, rotation_start, rotation_end)
+    
+    def _create_rotated_pixmaps_down(self,
+        base_pixmap: QPixmap,
+        base_hover_pixmap: QPixmap
+    ) -> tuple[QPixmap]:
+        if self._animate_button:
+            rotation_start = QTransform().rotate(90)
+            rotation_end = QTransform().rotate(270)
+        else:
+            rotation_start = QTransform().rotate(0)
+            rotation_end = QTransform().rotate(90)
+        return self._rotate_pixmaps(base_pixmap, base_hover_pixmap, rotation_start, rotation_end)
+
+    def _create_button_pixmaps(self) -> tuple[QPixmap]:
+        base_pixmap = QPixmap(Image_paths.play_right)
+        base_hover_pixmap = QPixmap(Image_paths.play_right_hover)
+        match self.direction:
+            case "left":
+                return self._create_rotated_pixmaps_left(base_pixmap, base_hover_pixmap)
+            case "right":
+                return self._create_rotated_pixmaps_right(base_pixmap, base_hover_pixmap)
+            case "up":
+                return self._create_rotated_pixmaps_up(base_pixmap, base_hover_pixmap)
+            case "down":
+                return self._create_rotated_pixmaps_down(base_pixmap, base_hover_pixmap)
+
+    def _setup_animation(self) -> None:
+        if self.animation is not None:
+            self.animation.setParent(None)
+            self.animation.deleteLater()
+        if self.direction in self._vertical_directions:
+            self.animation = QPropertyAnimation(self, b"_content_maximum_height")
+        else:
+            self.animation = QPropertyAnimation(self, b"_content_maximum_width")
+        self.animation.setDuration(self.ANIMATION_DURATION)
+        self.animation.finished.connect(self.sg_animation_finished)
+        self.animation.valueChanged.connect(self._animation_value_changed)
+
+    @pyqtProperty(int)
+    def _content_maximum_width(self) -> int:
+        return self.content_widget.maximumWidth()
+    
+    def _set_outer_width_anchor_right(self, outer_w: int):
+        g = self.geometry()
+        right = g.x() + g.width()
+        g.setWidth(outer_w)
+        g.moveLeft(right)
+        self.setGeometry(g)
+
+    def _set_outer_height_achor_bottom(self, outer_h: int) -> None:
+        g = self.geometry()
+        bottom = g.y() + g.bottom()
+        g.setHeight(outer_h)
+        g.moveTop(bottom)
+        self.setGeometry(g)
+    
+    @_content_maximum_width.setter
+    def _content_maximum_width(self, new_width: int) -> None:
+        self.content_widget.setMaximumWidth(new_width)
+
+        # Outer width = header + content (+ margins if any)
+        header_w = self.header_widget.sizeHint().width()   # or actual header widget
+        outer_w = header_w + new_width
+
+        if self.direction == "left":
+            self._set_outer_width_anchor_right(outer_w)
+        else:
+            self.resize(outer_w, self.height())  # natural right-grow      
+        
+    @pyqtProperty(int)
+    def _content_maximum_height(self) -> int:
+        return self.content_widget.maximumHeight()
+
+    @_content_maximum_height.setter
+    def _content_maximum_height(self, new_height: int) -> None:
+        self.content_widget.setMaximumHeight(new_height)
+
+        header_h = self.header_widget.sizeHint().height()
+        outer_h = header_h + new_height
+
+        if self.direction == "up":
+            self._set_outer_height_achor_bottom(outer_h)
+        else:
+            self.resize(self.width(), outer_h)     
+
+    def _create_header_widget(self) -> QWidget:
+        widget = QWidget(parent=self)
+        horizontal_layout = QHBoxLayout()
+        horizontal_layout.addWidget(self.toggle_button)
+        horizontal_layout.setContentsMargins(0,0,0,0)
+        horizontal_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
+        widget.setLayout(horizontal_layout)
+        return widget
+
+    def _setup(self) -> None:
+        self._setup_widget()
+        self._setup_layout()
+        self._setup_animation()
+
+    def _setup_widget(self) -> None:
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, True)
+        self.setWindowFlags(Qt.WindowType.Widget)
+        self.setWindowFlags(Qt.WindowType.FramelessWindowHint)
+
+    def _execute_toggle(self, animated=False):
+        if animated:
+            if self.direction in self._vertical_directions:
+                start = self.content_widget.maximumHeight()
+                end = max(0,self.content_widget.sizeHint().height()) if self._expanded else 0
+            else:
+                start = self.content_widget.maximumWidth()
+                end = max(0,self.content_widget.sizeHint().width()) if self._expanded else 0             
+            self.animation.stop()
+            self.animation.setStartValue(start)
+            if self._expanded:
+                self._widget_position_at_animation_start = self.pos()
+            self.animation.setEndValue(end)
+            self.sg_animation_started.emit()
+            self.animation.start()
+        else:
+            if self.direction in self._vertical_directions:
+                height = 0 if not self._expanded else max(0,self.content_widget.sizeHint().height())
+                self.content_widget.setMaximumHeight(height)
+            else:
+                width = max(0,self.content_widget.sizeHint().width()) if self._expanded else 0 
+                self.content_widget.setMaximumWidth(width)
+
+    def toggle(self,
+        expand: bool,
+        animated: bool = False,
+        button_toggle: bool | None = None
+    ) -> None:
+        self._expanded = expand
+        self._execute_toggle(animated)
+        if button_toggle is not None:
+            self.toggle_button.toggle(button_toggle)
+    
+    def _animation_value_changed(self, new_max_heigt: QSize) -> None: ...
+        # self.layout().activate()
+        # self.adjustSize()
+    
+    def _create_layout_left(self) -> QLayout:
+        layout = QHBoxLayout()
+        layout.setAlignment(Qt.AlignmentFlag.AlignRight)
+        if self._animate_button:
+            layout.addWidget(self.header_widget)
+            layout.addWidget(self.content_widget)
+        else:
+            layout.addWidget(self.content_widget)
+            layout.addWidget(self.header_widget)
+        return layout
+
+    def _create_layout_right(self) -> QLayout:
+        layout = QHBoxLayout()
+        layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
+        if self._animate_button:
+            layout.addWidget(self.content_widget)
+            layout.addWidget(self.header_widget)
+        else:
+            layout.addWidget(self.header_widget)
+            layout.addWidget(self.content_widget)
+        return layout
+        
+    def _create_layout_up(self) -> QLayout:
+        layout = QVBoxLayout()
+        layout.setAlignment(Qt.AlignmentFlag.AlignBottom)
+        if self._animate_button:
+            layout.addWidget(self.header_widget)
+            layout.addWidget(self.content_widget)
+        else:
+            layout.addWidget(self.content_widget)
+            layout.addWidget(self.header_widget)
+        return layout
+
+    def _create_layout_down(self) -> QLayout:
+        layout = QVBoxLayout()
+        layout.setAlignment(Qt.AlignmentFlag.AlignTop)
+        if self._animate_button:
+            layout.addWidget(self.content_widget)
+            layout.addWidget(self.header_widget)
+        else:
+            layout.addWidget(self.header_widget)
+            layout.addWidget(self.content_widget)
+        return layout
+
+    def _setup_layout(self) -> None:
+        match self.direction:
+            case "left":
+                layout = self._create_layout_left()
+            case "right":
+                layout = self._create_layout_right()
+            case "up":
+                layout = self._create_layout_up()
+            case "down":
+                layout = self._create_layout_down()
+        layout.setSpacing(0)
+        layout.setContentsMargins(0,0,0,0)
+        self.setLayout(layout)
+        self._execute_toggle()
+
+
+class Spoiler_content_widget(QWidget):
+
+    def __init__(self,
+        tree_disabled_widgets: list[QHBoxLayout],
+        parent=None
+    ):
+        super().__init__(parent=parent)
+        self._tree_disabled_widgets = tree_disabled_widgets
+        self._content_offset = 0
+        self._line_offset = 0
+        self._tree_rendering_enabled = True
+        self._setup()
+
+    def _setup(self) -> None:
+        vertical_layout = QVBoxLayout()
+        vertical_layout.setContentsMargins(0,0,0,0)
+        self.setLayout(vertical_layout)
+
+    def set_content_offset(self, offset: int) -> None:
+        self._content_offset = offset
+        self.update()
+
+    def enable_tree_rendering(self, enable: bool) -> None:
+        self._tree_rendering_enabled = enable
+        self.update()
+    
+    def set_line_offset(self, offset: int) -> None:
+        self._line_offset = offset
+        self.update()
+
+    def paintEvent(self, event):
+        if self._tree_rendering_enabled:
+            pen = QPen(Qt.GlobalColor.black, 2)
+            painter = QPainter(self)
+            painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+            painter.setPen(pen)
+            line_start = QPoint(self._line_offset,0)
+            # get all child widgets inside the layout
+            for i in range(self.layout().count()):
+                l = self.layout().itemAt(i).layout()
+                if not l or l in self._tree_disabled_widgets:
+                    continue
+
+                # get widget geometry relative to container
+                rect = l.geometry()
+                center_y = rect.top() + rect.height() // 2
+
+                # draw arrow from margin → widget
+                arrow_end_x = line_start.x()+ max(self._content_offset-self._line_offset,0)
+                painter.drawLine(line_start.x(), line_start.y(), line_start.x(), center_y)
+                painter.drawLine(line_start.x(), center_y, arrow_end_x, center_y)
+        else:
+            super().paintEvent(event)
+
+class Spoiler_widget(Expandable_widget):
+
+    _content_widget: Spoiler_content_widget
+
+    def __init__(self,
+        tree_rendering: bool = True,
+        parent=None
+    ):
+        super().__init__(direction="down", parent=parent)
+        self.sg_animation_started.connect(lambda: setattr(self, "_animation_going", True))
+        self.sg_animation_finished.connect(lambda: setattr(self, "_animation_going", False))
+        self._layout_widget_mapping: dict[QWidget, QHBoxLayout] = {}
+        self._tree_disabled_content: list[QHBoxLayout] = []
+        self._animation_going = False
+        self._content_offset = 0
+
+        content_widget = Spoiler_content_widget(self._tree_disabled_content)
+        content_widget.set_line_offset(self.toggle_button.sizeHint().width()//2)
+        self.set_content_widget(content_widget)
+        self.enable_tree_rendering(tree_rendering)
+
+    def set_content_margins(self, left, top, right, bottom) -> None:
+        self.content_widget.layout().setContentsMargins(left, top, right, bottom)
+        self.update()
+
+    def enable_tree_rendering(self, enable: bool) -> None:
+        self._content_widget.enable_tree_rendering(enable)
+        self.set_content_offset(self.toggle_button.sizeHint().width()//2)
+        self.update()
+
+    def set_content_offset(self, offset: int) -> None:
+        self._content_offset = offset
+        self._content_widget.set_content_offset(offset)
+        self.update()
+
+    def __iter__(self):
+        return iter(self._layout_widget_mapping.keys())
+    
+    def count(self) -> int:
+        return len(self._layout_widget_mapping)
+
+    def add_header_widget(self,
+        widget: QWidget
+    ) ->  None:
+        self.header_widget.layout().addWidget(widget)
+
+    def _schedule_geo_update(self):
+        if not self._expanded:
+            return
+        QTimer.singleShot(0, self._run_geo_update)
+
+    def _run_geo_update(self) -> None:
+        if self._animation_going:
+            return
+        self._update_content_geometries()        
+
+    def eventFilter(self, obj, event):
+        if event.type() in (QEvent.Type.LayoutRequest, QEvent.Type.Resize):
+            self._schedule_geo_update()
+        return super().eventFilter(obj, event)
+
+    def add_widget(self,
+        widget: QWidget,
+        at_index: int | None = None,
+        disable_tree: bool = False
+    ) -> None:
+        layout = QHBoxLayout()
+        # layout.insertItem(0, QSpacerItem(self.toggle_button.sizeHint().width()+15 , 0))
+        spacer = QSpacerItem(self._content_offset , 0)
+        layout.insertItem(0, spacer)
+        layout.addWidget(widget)
+        widget.installEventFilter(self)
+        if at_index is None:
+            self.content_widget.layout().addLayout(layout)
+        else:
+            self.content_widget.layout().insertLayout(at_index, layout)
+        if self._expanded:
+            QTimer.singleShot(0, self._update_content_geometries)
+        self._layout_widget_mapping[widget] = layout
+        if disable_tree:
+            self._tree_disabled_content.append(layout)
+
+    def remove_widget(self,
+        widget:  QWidget
+    ) -> QWidget:
+        layout = self._layout_widget_mapping[widget]
+        del self._layout_widget_mapping[widget]
+        clear_layout(layout)
+        layout.setParent(None)
+        layout.deleteLater()
+        if layout in self._tree_disabled_content:
+            self._tree_disabled_content.remove(layout)
+
+    def _update_content_geometries(self) -> None:
+        #self.content_widget.updateGeometry()
+        # self.content_widget.adjustSize()
+        self.content_widget.setMaximumHeight(self.content_widget.sizeHint().height())
+        self.update()
+
+    # def sizeHint(self):
+    #     header_h = self.header_widget.size().height()
+    #     content_h = self.content_widget.maximumHeight()
+    #     return QSize(
+    #         max(self.header_widget.sizeHint().width(), self.content_widget.sizeHint().width()),
+    #         header_h + content_h
+    #     )
+
+def main():
+    import sys
+    app = QApplication(sys.argv)
+    spoiler = Expandable_widget(direction="down", animate_button=False)
+    spoiler_2 = Spoiler_widget()
+    spoiler_2.add_widget(QLabel("JOOO"))
+    # spoiler = Spoiler_widget()
+    # spoiler.add_header_widget(QLabel("I bims 1 spoiler !"))
+    # for i in range(5):
+    #     spoiler.add_content_widget(QLabel(f"Label_{i}"))
+    spoiler.set_content_widget(QLabel("I bims 1 Label"))
+    spoiler.show()
+    #spoiler_2.show()
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    main()
+

michis_python_sammlung-0.0.1/src/michis_python_sammlung/pyqt/image_paths.py

@@ -0,0 +1,130 @@
+import os
+
+class Image_paths:
+    __relative_source_path__ = os.path.join(os.path.dirname(__file__), "icons\\")
+    _green_plus_mask = __relative_source_path__+"green_plus_mask.png"
+    apply = __relative_source_path__+"apply_button.png"
+    apply_hover = __relative_source_path__+"apply_button_hover.png"
+    decline: str = __relative_source_path__+"cancel_button.png"
+    decline_hover: str = __relative_source_path__+"cancel_button_hover.png"
+    green_lamp: str = __relative_source_path__+"enabled_sending.png"
+    green_lamp_hover: str = __relative_source_path__+"endabled_sending_hover.png"
+    red_lamp: str = __relative_source_path__+"disabled_sending.png"
+    red_lamp_hover: str = __relative_source_path__+"disabled_sending_hover.png"
+    grey_lamp: str = __relative_source_path__+"enabled_notSending.png"
+    grey_lamp_hover: str = __relative_source_path__+"disabled_notSending.png"
+    yellow_lamp: str = __relative_source_path__+"connectionPending.png"
+    settings: str = __relative_source_path__+"settings.png"
+    load = __relative_source_path__+"load_button.png"
+    load_test = __relative_source_path__+"load_button_test.png"
+    load_hover = __relative_source_path__+"load_button_hover.png"
+    save = __relative_source_path__+"save_button.png"
+    save_hover = __relative_source_path__+"save_button_hover.png"
+    menu = __relative_source_path__+"menu.png"
+    menu_hover = __relative_source_path__+"menu_hover.png"
+    power_off = __relative_source_path__+"power_off.png"
+    power_off_small = __relative_source_path__+"power_off_small.png"
+    power_off_hover = __relative_source_path__+"power_off_hover.png"
+    power_off_small_hover = __relative_source_path__+"power_off_small_hover.png"
+    power_on_small = __relative_source_path__+"power_on_small.png"
+    power_on_hover = __relative_source_path__+"power_on_hover.png"
+    power_on_small_hover = __relative_source_path__+"power_on_small_hover.png"
+    power_on = __relative_source_path__+"power_on.png"
+    power_on_hover = __relative_source_path__+"power_on_hover.png"
+    plug_settings = __relative_source_path__+"plug_settings.png"
+    plug_settings_hover = __relative_source_path__+"plug_settings_hover.png"  
+    drag_cursor = __relative_source_path__+"drag_series_device_ui_cursor.png"
+    cogwheel = __relative_source_path__+"cogwheel.png"
+    cogwheel_hover = __relative_source_path__+"cogwheel_hover.png"
+    BAR = __relative_source_path__+"dark_sun.png"
+    new_node = __relative_source_path__+"new_node_icon.png"
+    new_node_hover = __relative_source_path__+"new_node_icon_hover.png"
+    new_action_hover = __relative_source_path__+"new_action_hover.png"
+    new_node_plus = __relative_source_path__+"new_node_icon_plus.png"
+    new_node_plus_hover = __relative_source_path__+"new_node_icon_plus_hover.png"
+    trash = __relative_source_path__+"trash_icon.png"
+    trash_hover = __relative_source_path__+"trash_icon_hover.png"
+    m_button = __relative_source_path__+"m_button.png"
+    m_button_hover = __relative_source_path__+"m_button_hover.png"
+    blue_plus = __relative_source_path__+"blue_plus.png"
+    blue_plus_hover = __relative_source_path__+"blue_plus_hover.png"
+    green_plus = __relative_source_path__+"green_plus.png"
+    green_plus_hover = __relative_source_path__+"green_plus_hover.png"
+    red_plus = __relative_source_path__+"red_plus.png"
+    red_plus_hover = __relative_source_path__+"red_plus_hover.png"
+    blue_minus = __relative_source_path__+"blue_minus.png"
+    blue_minus_hover = __relative_source_path__+"blue_minus_hover.png"
+    green_minus = __relative_source_path__+"green_minus.png"
+    green_minus_hover = __relative_source_path__+"green_minus_hover.png"
+    red_minus = __relative_source_path__+"red_minus.png"
+    red_minus_hover = __relative_source_path__+"red_minus_hover.png"
+    question_mark = __relative_source_path__+"question_mark.png"
+    question_mark_hover = __relative_source_path__+"question_mark_hover.png"
+    eye_open = __relative_source_path__+"eye_open.png"
+    eye_open_hover = __relative_source_path__+"eye_open_hover.png"
+    eye_filled_open = __relative_source_path__+"filled_eye_open.png"
+    eye_filled_open_hover = __relative_source_path__+"filled_eye_open_hover.png"
+    eye_filled_crossed = __relative_source_path__+"filled_eye_crossed.png"
+    eye_filled_crossed_hover = __relative_source_path__+"filled_eye_crossed_hover.png"
+    color_wheel = __relative_source_path__+"color_wheel.png"
+    color_wheel_hover = __relative_source_path__+"color_wheel_hover.png"
+    m_button = __relative_source_path__+"m_button.png"
+    m_button_hover = __relative_source_path__+"m_button_hover.png"
+    blue_plus = __relative_source_path__+"blue_plus.png"
+    blue_plus_hover = __relative_source_path__+"blue_plus_hover.png"
+    question_mark = __relative_source_path__+"question_mark.png"
+    question_mark_hover = __relative_source_path__+"question_mark_hover.png"
+    eye_open = __relative_source_path__+"eye_open.png"
+    eye_open_hover = __relative_source_path__+"eye_open_hover.png"
+    eye_filled_open = __relative_source_path__+"filled_eye_open.png"
+    eye_filled_open_hover = __relative_source_path__+"filled_eye_open_hover.png"
+    eye_filled_crossed = __relative_source_path__+"filled_eye_crossed.png"
+    eye_filled_crossed_hover = __relative_source_path__+"filled_eye_crossed_hover.png"
+    color_wheel = __relative_source_path__+"color_wheel.png"
+    color_wheel_hover = __relative_source_path__+"color_wheel_hover.png"
+    thickness = __relative_source_path__+"thickness_icon.png"
+    thickness_hover = __relative_source_path__+"thickness_icon_hover.png"
+    left_sided_thickness_arrow = __relative_source_path__+"left_sided_thickness_arrow_icon.png"
+    right_sided_thickness_arrow = __relative_source_path__+"right_sided_thickness_arrow_icon.png"
+    circle_icon = __relative_source_path__+"circle_icon.png"
+    circle_icon_hover = __relative_source_path__+"circle_icon_hover.png"
+    line_icon = __relative_source_path__+"line_icon.png"
+    line_icon_hover = __relative_source_path__+"line_icon_hover.png"
+    crosshair_icon = __relative_source_path__+"crosshair_icon.png"
+    crosshair_icon_hover = __relative_source_path__+"crosshair_icon_hover.png"
+    align_center_icon = __relative_source_path__+"align_center_icon.png"
+    align_center_icon_hover = __relative_source_path__+"align_center_icon_hover.png"
+    inner_area = __relative_source_path__+"inner_background_2.png"
+    outer_ring = __relative_source_path__+"outer_ring_3.png"
+    house_icon = __relative_source_path__+"house_icon.png"
+    house_icon_hover = __relative_source_path__+"house_icon_hover.png"
+    play_icon = __relative_source_path__+"play.png"
+    play_icon_hover = __relative_source_path__+"play_hover.png"
+    pause_icon = __relative_source_path__+"pause.png"
+    pause_icon_hover = __relative_source_path__+"pause_hover.png"
+    stop_icon = __relative_source_path__+"stop.png"
+    stop_icon_hover = __relative_source_path__+"stop_hover.png"
+    stop_icon_2 = __relative_source_path__+"stop_icon.png"
+    stop_icon_2_hover = __relative_source_path__+"stop_icon_hover.png"
+    lcd_background = __relative_source_path__+"lcd_background.png"
+    magnifying_glass = __relative_source_path__+"magnifying_glass.png"
+    magnifying_glass_hover = __relative_source_path__+"magnifying_glass_hover.png"
+    play_right = __relative_source_path__+"play_right.png"
+    play_right_hover = __relative_source_path__+"play_right_hover.png"
+    play_left = __relative_source_path__+"play_left.png"
+    play_left_hover = __relative_source_path__+"play_left_hover.png"
+    starwars_stop = __relative_source_path__+"starwars_stop.png"
+    stop_3 = __relative_source_path__+"stop_3.png"
+    stop_3_hover = __relative_source_path__+"stop_3_hover.png"
+    arrows_outwards = __relative_source_path__+"arrows_outwards_icon.png"
+    arrows_outwards_hover = __relative_source_path__+"arrows_outwards_hover_icon.png"
+    green_circular_arrow = __relative_source_path__+"green_circular_arrow.png"
+    green_circular_arrow_hover = __relative_source_path__+"green_circular_arrow_hover.png"
+    grey_grid = __relative_source_path__+"grey_grid.png"
+    grey_grid_hover = __relative_source_path__+"grey_grid_hover.png"
+    green_grid = __relative_source_path__+"green_grid.png"
+    green_grid_hover = __relative_source_path__+"green_grid_hover.png"
+    eye_colorful = __relative_source_path__+"eye_colorful.png"
+    eye_colorful_hover = __relative_source_path__+"eye_colorful_hover.png"
+    eye_crossed = __relative_source_path__+"eye_crossed.png"
+    eye_crossed_hover = __relative_source_path__+"eye_crossed_hover.png"

michis_python_sammlung-0.0.1/src/michis_python_sammlung/pyqt/pyqt_util.py

@@ -0,0 +1,97 @@
+from PyQt6.QtWidgets import QWidget, QGraphicsOpacityEffect, QLayout, QMainWindow
+from PyQt6.QtGui import QPainter, QColor, QColorConstants, QPen, QGuiApplication
+from PyQt6.QtCore import QRect, pyqtBoundSignal
+from contextlib import contextmanager
+from typing import Generator, TypeVar
+
+def set_font_size(widget: QWidget, font_size: int) -> None:
+    font = widget.font()
+    font.setPointSize(font_size)
+    widget.setFont(font)
+
+def center_window(win: QMainWindow):
+    screen = QGuiApplication.primaryScreen()
+    geo = screen.availableGeometry()
+    win_geo = win.frameGeometry()
+    win_geo.moveCenter(geo.center())
+    win.move(win_geo.topLeft())
+
+def disconnect_all(signal: pyqtBoundSignal) -> None:
+    signals = True
+    while(signals):
+        try:
+            signal.disconnect()
+        except TypeError:
+            signals = False
+
+def retain_size_when_hidden(widget: QWidget, retain_size: bool) -> None:
+    """
+    Determines whether a widget still occupies space when its visibility is set to False.
+
+    Args:
+        widget (QWidget): A QWidget.
+        retain_size (bool): Do you want the widget to occupy space when being invisibe ?.
+
+    Returns:
+        None
+    """
+    policy = widget.sizePolicy()
+    policy.setRetainSizeWhenHidden(retain_size)
+    widget.setSizePolicy(policy)
+
+TWidget = TypeVar("TWidget", bound=QWidget)
+
+@contextmanager
+def inactive_signaling(
+    widget: TWidget,
+) -> Generator[TWidget, None, None]:
+    try:
+        widget.blockSignals(True)
+        yield widget
+    finally:
+        widget.blockSignals(False)
+
+def set_widget_opacity(
+    widget: QWidget, 
+    value: float
+) -> None:
+    """value between 0.0 (fully transparent) and 1.0 (fully opaque)."""
+    effect = widget.graphicsEffect()
+    if not isinstance(effect, QGraphicsOpacityEffect):
+        effect = QGraphicsOpacityEffect(widget)
+        widget.setGraphicsEffect(effect)
+    effect.setOpacity(value)
+
+def widget_in_layout(widget, layout: QLayout) -> bool:
+    """Check if a widget is in the given layout."""
+    for i in range(layout.count()):  # Iterate through the layout's items
+        item = layout.itemAt(i)
+        if item.widget() == widget:  # Check if the widget matches
+            return True
+    return False
+
+def add_rect_paint_to_widget(widget: QWidget, thickness: int = 2, color: QColor = QColorConstants.Red) -> None:
+    """
+    This does not have the expected effect on Clickable_labels or any other widget with custom masking.
+    """
+    paintEvent = widget.paintEvent
+    def paintRect(event):
+        painter = QPainter(widget)
+        pen = QPen()
+        pen.setWidth(thickness)
+        pen.setColor(color)
+        inset = int(pen.widthF() / 2.0)
+        painter.setPen(pen)
+        painter.drawRect(widget.rect().adjusted(inset, inset, -inset, -inset))
+        paintEvent(event)
+    widget.paintEvent = paintRect
+
+def clear_layout(layout: QLayout) -> None:
+    while layout.count() > 0:
+        item = layout.takeAt(0)
+        if item.widget():
+            item.widget().deleteLater()
+        elif item.layout():
+            clear_layout(item.layout())
+
+    

michis_python_sammlung-0.0.1/src/michis_python_sammlung.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: michis_python_sammlung
+Version: 0.0.1
+Summary: Collection of mostly QT related stuff
+Author-email: Michael Mischko <mischkom@web.de>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mischkomichael/Michis_python_sammlung
+Project-URL: Issues, https://github.com/mischkomichael/Michis_python_sammlung/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

michis_python_sammlung-0.0.1/src/michis_python_sammlung.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/michis_python_sammlung/__init__.py
+src/michis_python_sammlung.egg-info/PKG-INFO
+src/michis_python_sammlung.egg-info/SOURCES.txt
+src/michis_python_sammlung.egg-info/dependency_links.txt
+src/michis_python_sammlung.egg-info/top_level.txt
+src/michis_python_sammlung/pyqt/__init__.py
+src/michis_python_sammlung/pyqt/clickable_label.py
+src/michis_python_sammlung/pyqt/expandable_widget.py
+src/michis_python_sammlung/pyqt/image_paths.py
+src/michis_python_sammlung/pyqt/pyqt_util.py
+src/michis_python_sammlung/pyqt/icons/__init__.py

michis_python_sammlung-0.0.1/src/michis_python_sammlung.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

michis_python_sammlung-0.0.1/src/michis_python_sammlung.egg-info/top_level.txt

@@ -0,0 +1 @@
+michis_python_sammlung