batoolset-gui 0.2.0__tar.gz

batoolset_gui-0.2.0/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2024, baigouy
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

batoolset_gui-0.2.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: batoolset-gui
+Version: 0.2.0
+Summary: Qt/GUI layer for batoolset (drawings, figure, luts, widgets)
+Home-page: https://github.com/baigouy/BAtoolset-gui
+Author: Benoit Aigouy
+Author-email: benoit.aigouy@gmail.com
+License: BSD
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7, <3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: batoolset>=0.2.0
+Requires-Dist: PyQt6
+Requires-Dist: QtPy>=2.1.0
+Requires-Dist: qtawesome
+Requires-Dist: pyqt6-plugins
+Requires-Dist: matplotlib>=3.5.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# batoolset-gui
+
+The Qt/GUI layer of [batoolset](https://github.com/baigouy/BAtoolset): vector
+shapes and images for figures (`batoolset.drawings`), figure layout
+(`batoolset.figure`), LUTs with an editor and inverted LUTs (`batoolset.luts`),
+painting widgets and dialogs (`batoolset.GUI`, `batoolset.dialogs`,
+`batoolset.pyqts`, `batoolset.uis`) and object serialization
+(`batoolset.serializations`).
+
+It installs into the same `batoolset` package as the core library, which needs
+no Qt. Since 0.2.0 these modules are no longer part of `batoolset` itself.
+
+```bash
+pip install batoolset-gui
+```
+
+This installs `batoolset` (0.2.0 or later), PyQt6 and QtPy. It is used by
+[PyFigures](https://github.com/baigouy/PyFigures).
+
+## Licence
+
+BSD 2-Clause, see [LICENSE](LICENSE).

batoolset_gui-0.2.0/README.md

@@ -0,0 +1,22 @@
+# batoolset-gui
+
+The Qt/GUI layer of [batoolset](https://github.com/baigouy/BAtoolset): vector
+shapes and images for figures (`batoolset.drawings`), figure layout
+(`batoolset.figure`), LUTs with an editor and inverted LUTs (`batoolset.luts`),
+painting widgets and dialogs (`batoolset.GUI`, `batoolset.dialogs`,
+`batoolset.pyqts`, `batoolset.uis`) and object serialization
+(`batoolset.serializations`).
+
+It installs into the same `batoolset` package as the core library, which needs
+no Qt. Since 0.2.0 these modules are no longer part of `batoolset` itself.
+
+```bash
+pip install batoolset-gui
+```
+
+This installs `batoolset` (0.2.0 or later), PyQt6 and QtPy. It is used by
+[PyFigures](https://github.com/baigouy/PyFigures).
+
+## Licence
+
+BSD 2-Clause, see [LICENSE](LICENSE).

batoolset_gui-0.2.0/batoolset/GUI/customdialog.py

@@ -0,0 +1,136 @@
+from qtpy import QtWidgets, QtCore
+from qtpy.QtWidgets import (QDialog, QVBoxLayout, QLabel, QPushButton, QApplication, QWidget,QFrame)
+from qtpy.QtCore import Qt,Signal
+
+from batoolset.pyqts.tools import disable_wheel_for_combo_and_spin
+
+
+# from batoolset.pyqts.tools import disable_wheel_for_widget_and_children
+
+
+class CustomDialog(QDialog):
+    option_selected = Signal(str)
+    accepting_keywords = ["yes", "ok", "done", "validate", "y"]
+    rejecting_keywords = ["no", "cancel", "quit", "abandon", "reject", "stop", "n", "q"]
+
+    def __init__(self, title="Custom Dialog", message="Do you want to proceed?", main_widget=None, parent=None, options=None, add_separator=True, auto_adjust=False, reset_style_sheet=True):
+        super().__init__(parent)
+
+        if reset_style_sheet:
+            # self.setStyleSheet("") # make sure to reset style sheet # this doesn't work
+            self.setStyleSheet("background-color: none;") # make sure to reset style sheet
+            # main_widget.setStyleSheet("")
+            main_widget.setStyleSheet("background-color: none;")
+
+        # self.setStyleSheet("background-color: lightblue;")
+
+        # Set the object name for the widget
+        # self.setObjectName("VectorialDrawPane2")
+
+        # Set the background color
+        # if background is not None:
+        # self.setStyleSheet("") # prevent it from getting the style sheet of the parent
+
+        # Set the window flags to stay on top
+        self.setWindowFlags(self.windowFlags() | Qt.WindowStaysOnTopHint)
+
+        self.setWindowTitle(title)
+
+        self.main_widget = main_widget
+
+        layout = QVBoxLayout()
+        if main_widget:
+            # main_widget.setStyleSheet("") # also reset style sheet of content
+            layout.addWidget(main_widget)
+
+        # Add a separator
+        separator = QFrame()
+        separator.setFrameShape(QFrame.HLine)
+        separator.setFrameShadow(QFrame.Sunken)
+        layout.addWidget(separator)
+
+        if message:
+            label = QLabel(message)
+            layout.addWidget(label)
+
+        if options is None:
+            options = ["Yes", "No"]
+
+        if isinstance(options, str):
+            options=[options]
+
+        for option in options:
+            button = QPushButton(option)
+            button.setFocusPolicy(Qt.NoFocus)# prevent auto selection from buttons
+            layout.addWidget(button)
+            button.clicked.connect(lambda _, opt=option: self.handle_option_clicked(opt))
+
+        self.setLayout(layout)
+
+        # disable_wheel_for_widget_and_children(self)
+
+        # disable_wheel_for_combo_and_spin(self.main_widget)
+        # disable_wheel_for_combo_and_spin(self.main_widget)
+
+        if not auto_adjust:
+            try:
+                try:
+                    # Get the screen where the application is currently displayed
+                    screen = self.screen()
+                    if screen is not None:
+                        screen_geometry = screen.geometry()
+                    else:
+                        # If the application is not displayed on any screen, use the primary screen
+                        screen_geometry = QtWidgets.QApplication.primaryScreen().geometry()
+                except:
+                    try:
+                        from qtpy.QtGui import QGuiApplication
+                        screen_geometry = QGuiApplication.primaryScreen().geometry()
+                    except:
+                        pass  # no big deal if all fails...
+                # Set width and height to 75% of the screen size
+                width = int(screen_geometry.width() * 0.85)
+                height = int(screen_geometry.height() * 0.85)
+                self.resize(width, height)
+            except:
+                pass  # no big deal if it fails...
+        else:
+            # force the window to assume the smallest minimum size can be very useful when min size is set
+            self.adjustSize()
+
+    def handle_option_clicked(self, option):
+        self.selected_option = option
+        if option.lower() in CustomDialog.accepting_keywords:
+            self.accept()  # Close the dialog with QDialog.Accepted status
+        elif option.lower() in CustomDialog.rejecting_keywords:
+            self.reject()  # Close the dialog with QDialog.Rejected status
+        else:
+            self.accept()  # Close the dialog with QDialog.Accepted status
+
+    # def exec_(self):
+    #     result = super().exec_()
+    #     if result == QDialog.Accepted:
+    #         return self.selected_option
+    #     else:
+    #         return None
+
+    def get_selected_answer(self):
+        return self.selected_option
+
+if __name__ == "__main__":
+    import sys
+    app = QApplication(sys.argv)
+
+    options = ["Option 1", "Option 2", "Option 3", "No"] # None
+    options = "Done"
+    message = "Do you want to proceed?" # "Do you want to proceed?" # None
+    auto_adjust = True # force the window to take minimal size if used (calls adjustsize)
+    custom_dialog = CustomDialog(title="Custom Dialog", message=message , main_widget=QWidget(), options=options, auto_adjust=auto_adjust)
+    custom_dialog.option_selected.connect(lambda option: print(f"Selected option: {option}"))
+    selected_option = custom_dialog.exec_()
+    print(selected_option)
+    if selected_option:
+        print(f"Selected option: {selected_option}")
+        print(custom_dialog.selected_option)
+    else:
+        print("Dialog was closed without selecting an option.")

batoolset_gui-0.2.0/batoolset/GUI/exception_handler.py

@@ -0,0 +1,74 @@
+"""Qt-safe global exception handler.
+
+Under PyQt6, an unhandled Python exception that propagates out of a slot, timer
+callback or event handler makes Qt call ``qFatal()``/``abort()``. On Windows that
+surfaces as a hard crash with exit code ``0xC0000409``
+(STATUS_STACK_BUFFER_OVERRUN) — the whole application dies with no message and no
+traceback, so it looks like a native stack overflow even though it is just a
+Python exception (e.g. a UnicodeEncodeError while autosaving).
+
+The important detail: PyQt only calls ``qFatal()`` when the *default*
+``sys.excepthook`` is installed. Installing a non-default hook both suppresses the
+abort (the app keeps running) and lets us log the error and warn the user.
+"""
+import sys
+import traceback
+
+from batoolset.tools.logger import TA_logger
+
+logger = TA_logger()
+
+_original_excepthook = sys.excepthook
+_reporting = False  # guard against re-entrancy while a dialog is being shown
+
+
+def _show_dialog(short, details):
+    """Best-effort warning dialog; never let the reporter itself raise."""
+    try:
+        from qtpy.QtWidgets import QApplication, QMessageBox
+        if QApplication.instance() is None:
+            return
+        box = QMessageBox()
+        box.setIcon(QMessageBox.Warning)
+        box.setWindowTitle('An error occurred')
+        box.setText(short)
+        box.setInformativeText(
+            'The application will keep running, but the last action may not have '
+            'completed. Details are in the log.')
+        box.setDetailedText(details)
+        box.setStandardButtons(QMessageBox.Ok)
+        box.exec_()
+    except Exception:
+        pass
+
+
+def global_excepthook(exctype, value, tb):
+    """Log the exception and warn the user instead of aborting the process."""
+    # keep Ctrl+C / normal interpreter-exit behaviour
+    if issubclass(exctype, (KeyboardInterrupt, SystemExit)):
+        _original_excepthook(exctype, value, tb)
+        return
+
+    details = ''.join(traceback.format_exception(exctype, value, tb))
+    try:
+        logger.error('Unhandled exception (suppressed to keep the app alive):\n' + details)
+    except Exception:
+        sys.stderr.write(details)
+
+    global _reporting
+    if _reporting:
+        # already showing a dialog (or we faulted while reporting) — don't stack them
+        return
+    _reporting = True
+    try:
+        _show_dialog(f'{exctype.__name__}: {value}', details)
+    finally:
+        _reporting = False
+
+
+def install_global_exception_handler():
+    """Install the Qt-safe global exception hook. Idempotent."""
+    if getattr(sys, '_batoolset_excepthook_installed', False):
+        return
+    sys.excepthook = global_excepthook
+    sys._batoolset_excepthook_installed = True