1.add signal to auto switch docker/dialog; 2.keep one instance; 3.add keyboard shortcut;

zerobikappa · zerobikappa · commit e1717910d054 · 2023-08-17T03:18:52.000+08:00
diff --git a/plugindevtools/PluginDevTools/PluginDevToolsDialog.py b/plugindevtools/PluginDevTools/PluginDevToolsDialog.py
@@ -0,0 +1,20 @@
+from krita import *
+from PyQt5.QtWidgets import QDialog, QHBoxLayout
+from .PluginDevToolsWidget import *
+
+class PluginDevToolsDialog(QDialog):
+    signal_closed = pyqtSignal()
+    def __init__(self, parent=None):
+        super().__init__(parent) 
+        self.__layout = QHBoxLayout()
+        self.setLayout(self.__layout)
+        self.setWindowTitle('Plugin Developer Tools')
+        # Can keep a standalone window after setParent with qwin
+        self.setWindowFlag(Qt.WindowType.Window, True)
+
+
+    def closeEvent(self, event: QtGui.QCloseEvent):
+        self.signal_closed.emit()
+        return super().closeEvent(event)
+
+
diff --git a/plugindevtools/PluginDevTools/PluginDevToolsDocker.py b/plugindevtools/PluginDevTools/PluginDevToolsDocker.py
@@ -5,12 +5,31 @@
 DOCKER_TITLE = 'Plugin Developer Tools'
 
 class PluginDevToolsDocker(DockWidget):
+    signal_leaveFloating = pyqtSignal()
+    signal_manualOpenDocker = pyqtSignal()
     def __init__(self):
         super().__init__()
         self.setWindowTitle(DOCKER_TITLE)
-        self.mainWidget = PluginDevToolsWidget()
-        self.setWidget(self.mainWidget)
 
     def canvasChanged(self, canvas):
         pass
         
+    def showEvent(self, event: QtGui.QShowEvent) -> None:
+        print('PluginDevToolsDocker showEvent')
+        print('    sender= ', self.sender())
+        if isinstance(self.sender(), QAction):
+            self.signal_manualOpenDocker.emit()
+            return super().showEvent(event)
+        # Failed to catch mousePressEvent/mouseReleaseEvent when moving docker
+        # Failed to catch clicked/toggled/pressed/released signal when click the docker float button 
+        # Use showEvent instead
+        if (QGuiApplication.mouseButtons() & Qt.MouseButton.LeftButton):
+            # Do not switch immediately when dragging the docker to move
+            return super().showEvent(event)
+
+        # LeftButton is released and the docker is not docked
+        if self.isFloating():
+            self.signal_leaveFloating.emit()
+        return super().showEvent(event)
+
+
diff --git a/plugindevtools/PluginDevTools/PluginDevToolsExtension.py b/plugindevtools/PluginDevTools/PluginDevToolsExtension.py
@@ -1,29 +1,64 @@
 from krita import *
-from PyQt5.QtWidgets import QDialog, QHBoxLayout
-from .PluginDevToolsWidget import *
 
-class PluginDevToolsExtension(Extension):
-    def __init__(self, parent):
-        super().__init__(parent) 
+## TODO: Planed to add some functions in future.
+
+#class PluginDevToolsExtension(Extension):
+#    def __init__(self, parent):
+#        super().__init__(parent) 
+#
+#    # Krita.instance() exists, so do any setup work
+#    def setup(self):
+#        pass
+#
+#    # called after setup(self)
+#    def createActions(self, window):
+#        pass
 
 
+# This is a test extension
+import inspect
+class PluginDevToolsTestExtension(Extension):
+    def __init__(self, parent):
+        super().__init__(parent)
+
     def setup(self):
         pass
 
-    def initialize(self):
-        self.dialog = QDialog()
+    def createActions(self, window: Window):
+        action = window.createAction('PluginDevTools', 'PluginDevTools', 'tools/scripts/PluginDevTools')
+        self.menu = QMenu('PluginDevTools', window.qwindow())
+        action.setMenu(self.menu)
+        # Add some fixed Action here:
+        #action = window.createAction('actionID', 'actionDisplayName', 'tools/scripts/PluginDevTools')
+        #self.menu.addAction(action)
+        #action.triggered.connect(someConnectObject)
+
 
-        self.dialogLayout = QHBoxLayout()
-        self.dialog.setLayout(self.dialogLayout)
+    def dynamicAddEntry(self, *args):
+        # Only for debug
+        # How to use in console:
+        #debugentry = next((w for w in Krita.instance().extensions() if str(type(w)).__contains__('PluginDevToolsDebugEntry')), None)
+        #print(vars(debugentry))
+        # then use debugentry.yourVariable to access yourVariable
+        frame = inspect.currentframe()
+        frame = inspect.getouterframes(frame)[1]
+        string = inspect.getframeinfo(frame[0]).code_context
+        if string is not None:
+            string = string[0].strip()
+        else:
+            return
 
-        self.dialogLayoutContent = PluginDevToolsWidget()
-        self.dialogLayout.addWidget(self.dialogLayoutContent)
+        args_name = string[string.find('(') + 1:-1].replace(' ', '').split(',')
+    
+        for name, value in zip(args_name, args):
+            setattr(self, name, value)
 
-        self.dialog.setWindowTitle('Plugin Developer Tools')
-        self.dialog.show()
+    def dynamicCreateAction(self, connectObject, window: Window, id_text: str, displayName: str = str(), addToMenu=False) ->QAction:
+        action = window.createAction(id_text, displayName)
+        action.triggered.connect(connectObject)
+        if addToMenu:
+            self.menu.addAction(action)
 
-    def createActions(self, window):
-        action = window.createAction("pluginDevTools", "Plugin Developer Tools", "tools/scripts")
-        action.triggered.connect(self.initialize)
+        return action
 
 
diff --git a/plugindevtools/PluginDevTools/PluginDevToolsStatusManager.py b/plugindevtools/PluginDevTools/PluginDevToolsStatusManager.py
@@ -0,0 +1,88 @@
+from krita import *
+from PyQt5.QtCore import *
+from .PluginDevToolsWidget import *
+from .PluginDevToolsDocker import *
+from .PluginDevToolsDialog import *
+
+
+class PluginDevToolsStatusManager():
+    # shared with all instances
+    mutex = QMutex()
+
+    def __init__(self, name=str()):
+        self.__objectname = name
+        self.docker: PluginDevToolsDocker
+        self.dialog: PluginDevToolsDialog
+        self.centralwidget: PluginDevToolsWidget
+
+
+    def objectName(self):
+        # Only for debug
+        return self.__objectname
+
+
+    def setDocker(self, docker: PluginDevToolsDocker):
+        self.docker = docker
+
+
+    def setDialog(self, dialog: PluginDevToolsDialog):
+        self.dialog = dialog
+
+
+    def setCentralWidget(self, centralwidget: PluginDevToolsWidget):
+        self.centralwidget = centralwidget
+
+
+    def setFirstAfterStart(self):
+        # Initialize the first status after start Krita
+        if self.docker.isFloating():
+            self.applyDialogMode('initiallize')
+        elif self.docker.isVisible():
+            self.applyDockerMode('initiallize')
+        else:
+            self.applyHideMode('initiallize')
+
+
+    def applyHideMode(self, senderName=str()):
+        if type(self).mutex.tryLock() == False:
+            #print('skipped applyHideMode')
+            #print('    mutex.tryLock()= ', False)
+            #print('    sender= ', senderName)
+            #print('')
+            return
+        self.docker.setFloating(False)
+        self.docker.setWidget(self.centralwidget)
+        self.docker.close()
+        self.dialog.close()
+        type(self).mutex.unlock()
+
+
+    def applyDockerMode(self, senderName=str()):
+        if type(self).mutex.tryLock() == False:
+            #print('skipped applyDockerMode')
+            #print('    mutex.tryLock()= ', False)
+            #print('    sender= ', senderName)
+            #print('')
+            return
+        self.docker.setFloating(False)
+        self.docker.setWidget(self.centralwidget)
+        self.docker.show()
+        self.dialog.close()
+        type(self).mutex.unlock()
+
+
+    def applyDialogMode(self, senderName=str()):
+        if type(self).mutex.tryLock() == False:
+            #print('skipped applyDialogMode')
+            #print('    mutex.tryLock()= ', False)
+            #print('    sender= ', senderName)
+            #print('')
+            return
+        self.docker.setFloating(False)
+        self.docker.close()
+        self.dialog.layout().addWidget(self.centralwidget)
+        self.dialog.show()
+        self.dialog.activateWindow()
+        type(self).mutex.unlock()
+
+
diff --git a/plugindevtools/PluginDevTools/__init__.py b/plugindevtools/PluginDevTools/__init__.py
@@ -1,15 +1,95 @@
 from krita import *
 from .PluginDevToolsExtension import * 
 from .PluginDevToolsDocker import * 
+from .PluginDevToolsWidget import *
+from .PluginDevToolsDialog import *
+from .PluginDevToolsStatusManager import *
 
 
 app = Krita.instance()
 
-# Add to extension list
-extension = PluginDevToolsExtension(parent=app) #instantiate your class
-app.addExtension(extension)
+## TODO: Planed to add some functions in future.
+## Add to extension list
+#extension = PluginDevToolsExtension(parent=app) #instantiate your class
+#app.addExtension(extension)
+
+testExtension = PluginDevToolsTestExtension(parent=app)
+app.addExtension(testExtension)
 
 # Add to docker list
 DOCKER_ID = 'pluginDevToolsDocker'
 dock_widget_factory = DockWidgetFactory(DOCKER_ID, DockWidgetFactoryBase.DockBottom, PluginDevToolsDocker)
 app.addDockWidgetFactory(dock_widget_factory)
+
+statusManager = PluginDevToolsStatusManager('statusManager')
+
+def retrieveDocker(docker_id: str)->PluginDevToolsDocker:
+    # Only retrieve docker instance after the main window was completely created
+    try:
+        Krita.instance().activeWindow().qwindow()
+    except:
+        print('main window not created at this moment')
+        return PluginDevToolsDocker()
+
+    for d in app.dockers():
+        if d.objectName() == docker_id:
+            if isinstance(d, PluginDevToolsDocker):
+                return d
+    print("cannot find docker: {docker_id}")
+    exit(1)
+
+
+def setup():
+    global statusManager
+
+    qwin = Krita.instance().activeWindow().qwindow()
+
+
+    docker = retrieveDocker(DOCKER_ID)
+    statusManager.setDocker(docker)
+    
+    # Prepare a standalone window
+    dialog = PluginDevToolsDialog()
+    statusManager.setDialog(dialog)
+    
+    # Prepare content widget. This widget will be added into docker or dialog. Only keep one instance.
+    centralwidget = PluginDevToolsWidget()
+    statusManager.setCentralWidget(centralwidget)
+    
+    # Set dialog's parent to qwindow, when close qwindow, dialog will be closed as well
+    statusManager.dialog.setParent(qwin)
+    # Reset windowflag to keep as a standalone window
+    # Should always reset windowflag after setParent
+    statusManager.dialog.setWindowFlag(Qt.WindowType.Window, True)
+
+    statusManager.setFirstAfterStart()
+
+    # Status route: modeAllHide <--> modeDocker <--> modeDialog
+    statusManager.dialog.signal_closed.connect(lambda : statusManager.applyDockerMode('dialog.signal_closed'))
+    statusManager.docker.signal_leaveFloating.connect(lambda : statusManager.applyDialogMode('docker.signal_leaveFloating'))
+    statusManager.docker.signal_manualOpenDocker.connect(lambda : statusManager.applyDockerMode('docker.signal_manualOpenDocker'))
+
+
+    # Only for debug
+    testExtension.dynamicAddEntry(DOCKER_ID, dock_widget_factory, centralwidget, dialog, docker, statusManager)
+
+    # Dynamically load some object into actions menu
+    testExtension.dynamicCreateAction(statusManager.applyDockerMode, Krita.instance().activeWindow(), 'PluginDevToolsActionOpenAsDocker', 'Open as Docker', True)
+    testExtension.dynamicCreateAction(statusManager.applyDialogMode, Krita.instance().activeWindow(), 'PluginDevToolsActionOpenAsDialog', 'Open as Dialog', True)
+    def toggleOnAndOff():
+        if statusManager.docker.isVisible():
+            statusManager.applyHideMode()
+        else:
+            statusManager.applyDockerMode()
+    testExtension.dynamicCreateAction(toggleOnAndOff, Krita.instance().activeWindow(), 'PluginDevToolsToggleOnOff', 'Toggle On or Off')
+
+
+
+# Some settings require Krita.instance().activeWindow().qwindow() as parameter
+# Wait Krita.instance().activeWindow().qwindow() completely created then set the widgets
+appNotifier = Krita.instance().notifier()
+appNotifier.setActive(True)
+appNotifier.windowCreated.connect(setup)
+#appNotifier.applicationClosing.connect(statusManager.saveLastBeforeExit)
+
+
diff --git a/plugindevtools/actions/PluginDevTools.action b/plugindevtools/actions/PluginDevTools.action
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ActionCollection version="2" name="Scripts">
+    <Actions category="Scripts">
+        <text>PluginDevTools</text>
+
+        <Action name="PluginDevToolsToggleOnOff">
+        <icon></icon>
+        <text>Toggle On or Off</text>
+        <whatsThis></whatsThis>
+        <toolTip></toolTip>
+        <iconText></iconText>
+        <activationFlags>10000</activationFlags>
+        <activationConditions>0</activationConditions>
+        <shortcut>f12</shortcut>
+        <isCheckable>false</isCheckable>
+        <statusTip></statusTip>
+        </Action>
+    </Actions>
+</ActionCollection>
+
+<!-----
+    user guide:
+        https://docs.krita.org/en/user_manual/python_scripting/krita_python_plugin_howto.html
+    save this file in below location:
+        Windows: C:\Users\%USERNAME%\AppData\Roaming\krita\actions\
+        Linux: $HOME/.local/share/krita/actions/
+----->
