Merge pull request #3928 from BigRoy/fusion_event_system_thread

openpype/hosts/fusion/api/lib.py

@@ -3,8 +3,6 @@
 import re
 import contextlib
 
-from Qt import QtGui
-
 from openpype.lib import Logger
 from openpype.client import (
     get_asset_by_name,
@@ -92,7 +90,7 @@ def set_asset_resolution():
     })
 
 
-def validate_comp_prefs(comp=None):
+def validate_comp_prefs(comp=None, force_repair=False):
     """Validate current comp defaults with asset settings.
 
     Validates fps, resolutionWidth, resolutionHeight, aspectRatio.
@@ -135,21 +133,22 @@ def validate_comp_prefs(comp=None):
         asset_value = asset_data[key]
         comp_value = comp_frame_format_prefs.get(comp_key)
         if asset_value != comp_value:
-            # todo: Actually show dialog to user instead of just logging
-            log.warning(
-                "Comp {pref} {value} does not match asset "
-                "'{asset_name}' {pref} {asset_value}".format(
-                    pref=label,
-                    value=comp_value,
-                    asset_name=asset_doc["name"],
-                    asset_value=asset_value)
-            )
-
             invalid_msg = "{} {} should be {}".format(label,
                                                       comp_value,
                                                       asset_value)
             invalid.append(invalid_msg)
 
+            if not force_repair:
+                # Do not log warning if we force repair anyway
+                log.warning(
+                    "Comp {pref} {value} does not match asset "
+                    "'{asset_name}' {pref} {asset_value}".format(
+                        pref=label,
+                        value=comp_value,
+                        asset_name=asset_doc["name"],
+                        asset_value=asset_value)
+                )
+
     if invalid:
 
         def _on_repair():
@@ -160,6 +159,11 @@ def _on_repair():
                 attributes[comp_key_full] = value
             comp.SetPrefs(attributes)
 
+        if force_repair:
+            log.info("Applying default Comp preferences..")
+            _on_repair()
+            return
+
         from . import menu
         from openpype.widgets import popup
         from openpype.style import load_stylesheet

openpype/hosts/fusion/api/menu.py

@@ -16,6 +16,7 @@
 from openpype.pipeline import legacy_io
 from openpype.resources import get_openpype_icon_filepath
 
+from .pipeline import FusionEventHandler
 from .pulse import FusionPulse
 
 self = sys.modules[__name__]
@@ -119,6 +120,10 @@ def __init__(self, *args, **kwargs):
         self._pulse = FusionPulse(parent=self)
         self._pulse.start()
 
+        # Detect Fusion events as OpenPype events
+        self._event_handler = FusionEventHandler(parent=self)
+        self._event_handler.start()
+
     def on_task_changed(self):
         # Update current context label
         label = legacy_io.Session["AVALON_ASSET"]

openpype/hosts/fusion/api/pipeline.py

@@ -2,13 +2,16 @@
 Basic avalon integration
 """
 import os
+import sys
 import logging
 
 import pyblish.api
+from Qt import QtCore
 
 from openpype.lib import (
     Logger,
-    register_event_callback
+    register_event_callback,
+    emit_event
 )
 from openpype.pipeline import (
     register_loader_plugin_path,
@@ -39,12 +42,13 @@
 INVENTORY_PATH = os.path.join(PLUGINS_DIR, "inventory")
 
 
-class CompLogHandler(logging.Handler):
+class FusionLogHandler(logging.Handler):
+    # Keep a reference to fusion's Print function (Remote Object)
+    _print = getattr(sys.modules["__main__"], "fusion").Print
+
     def emit(self, record):
         entry = self.format(record)
-        comp = get_current_comp()
-        if comp:
-            comp.Print(entry)
+        self._print(entry)
 
 
 def install():
@@ -67,7 +71,7 @@ def install():
     # Attach default logging handler that prints to active comp
     logger = logging.getLogger()
     formatter = logging.Formatter(fmt="%(message)s\n")
-    handler = CompLogHandler()
+    handler = FusionLogHandler()
     handler.setFormatter(formatter)
     logger.addHandler(handler)
     logger.setLevel(logging.DEBUG)
@@ -84,10 +88,10 @@ def install():
         "instanceToggled", on_pyblish_instance_toggled
     )
 
-    # Fusion integration currently does not attach to direct callbacks of
-    # the application. So we use workfile callbacks to allow similar behavior
-    # on save and open
-    register_event_callback("workfile.open.after", on_after_open)
+    # Register events
+    register_event_callback("open", on_after_open)
+    register_event_callback("save", on_save)
+    register_event_callback("new", on_new)
 
 
 def uninstall():
@@ -137,8 +141,18 @@ def on_pyblish_instance_toggled(instance, old_value, new_value):
                 tool.SetAttrs({"TOOLB_PassThrough": passthrough})
 
 
-def on_after_open(_event):
-    comp = get_current_comp()
+def on_new(event):
+    comp = event["Rets"]["comp"]
+    validate_comp_prefs(comp, force_repair=True)
+
+
+def on_save(event):
+    comp = event["sender"]
+    validate_comp_prefs(comp)
+
+
+def on_after_open(event):
+    comp = event["sender"]
     validate_comp_prefs(comp)
 
     if any_outdated_containers():
@@ -254,3 +268,114 @@ def parse_container(tool):
     return container
 
 
+class FusionEventThread(QtCore.QThread):
+    """QThread which will periodically ping Fusion app for any events.
+
+    The fusion.UIManager must be set up to be notified of events before they'll
+    be reported by this thread, for example:
+        fusion.UIManager.AddNotify("Comp_Save", None)
+
+    """
+
+    on_event = QtCore.Signal(dict)
+
+    def run(self):
+
+        app = getattr(sys.modules["__main__"], "app", None)
+        if app is None:
+            # No Fusion app found
+            return
+
+        # As optimization store the GetEvent method directly because every
+        # getattr of UIManager.GetEvent tries to resolve the Remote Function
+        # through the PyRemoteObject
+        get_event = app.UIManager.GetEvent
+        delay = int(os.environ.get("OPENPYPE_FUSION_CALLBACK_INTERVAL", 1000))
+        while True:
+            if self.isInterruptionRequested():
+                return
+
+            # Process all events that have been queued up until now
+            while True:
+                event = get_event(False)
+                if not event:
+                    break
+                self.on_event.emit(event)
+
+            # Wait some time before processing events again
+            # to not keep blocking the UI
+            self.msleep(delay)
+
+
+class FusionEventHandler(QtCore.QObject):
+    """Emits OpenPype events based on Fusion events captured in a QThread.
+
+    This will emit the following OpenPype events based on Fusion actions:
+        save: Comp_Save, Comp_SaveAs
+        open: Comp_Opened
+        new: Comp_New
+
+    To use this you can attach it to you Qt UI so it runs in the background.
+    E.g.
+        >>> handler = FusionEventHandler(parent=window)
+        >>> handler.start()
+
+
+    """
+    ACTION_IDS = [
+        "Comp_Save",
+        "Comp_SaveAs",
+        "Comp_New",
+        "Comp_Opened"
+    ]
+
+    def __init__(self, parent=None):
+        super(FusionEventHandler, self).__init__(parent=parent)
+
+        # Set up Fusion event callbacks
+        fusion = getattr(sys.modules["__main__"], "fusion", None)
+        ui = fusion.UIManager
+
+        # Add notifications for the ones we want to listen to
+        notifiers = []
+        for action_id in self.ACTION_IDS:
+            notifier = ui.AddNotify(action_id, None)
+            notifiers.append(notifier)
+
+        # TODO: Not entirely sure whether these must be kept to avoid
+        #       garbage collection
+        self._notifiers = notifiers
+
+        self._event_thread = FusionEventThread(parent=self)
+        self._event_thread.on_event.connect(self._on_event)
+
+    def start(self):
+        self._event_thread.start()
+
+    def stop(self):
+        self._event_thread.stop()
+
+    def _on_event(self, event):
+        """Handle Fusion events to emit OpenPype events"""
+        if not event:
+            return
+
+        what = event["what"]
+
+        # Comp Save
+        if what in {"Comp_Save", "Comp_SaveAs"}:
+            if not event["Rets"].get("success"):
+                # If the Save action is cancelled it will still emit an
+                # event but with "success": False so we ignore those cases
+                return
+            # Comp was saved
+            emit_event("save", data=event)
+            return
+
+        # Comp New
+        elif what in {"Comp_New"}:
+            emit_event("new", data=event)
+
+        # Comp Opened
+        elif what in {"Comp_Opened"}:
+            emit_event("open", data=event)

openpype/hosts/fusion/api/pulse.py

@@ -19,9 +19,12 @@ def run(self):
         while True:
             if self.isInterruptionRequested():
                 return
-            try:
-                app.Test()
-            except Exception:
+
+            # We don't need to call Test because PyRemoteObject of the app
+            # will actually fail to even resolve the Test function if it has
+            # gone down. So we can actually already just check by confirming
+            # the method is still getting resolved. (Optimization)
+            if app.Test is None:
                 self.no_response.emit()
 
             self.msleep(interval)