batoolset-gui 0.2.0__py3-none-any.whl

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/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