Move acre to the master branch

colorbleed/__init__.py

@@ -1,7 +1,8 @@
 import os
+import json
 
-from pyblish import api as pyblish
-from avalon import api as avalon
+import pyblish.api
+import avalon.api
 
 from .launcher_actions import register_launcher_actions
 from .lib import collect_container_metadata
@@ -16,11 +17,36 @@
 
 def install():
     print("Registering global plug-ins..")
-    pyblish.register_plugin_path(PUBLISH_PATH)
-    avalon.register_plugin_path(avalon.Loader, LOAD_PATH)
+    pyblish.api.register_plugin_path(PUBLISH_PATH)
+    avalon.api.register_plugin_path(avalon.api.Loader, LOAD_PATH)
+
+    # Register default "local" target
+    print("Registering pyblish target: local")
+    pyblish.api.register_target("local")
+
+    # Set a Pyblish QML post collector order: pyblish-qml#356
+    post_collector_order = str(pyblish.api.CollectorOrder + 0.3)
+    os.environ["PYBLISH_QML_POST_COLLECT"] = post_collector_order
+
+    # Try and set project specific environment if it has implemented any
+    # todo: implement better project-specific settings
+    template = "{AVALON_PROJECTS}/{AVALON_PROJECT}/resources/pipeline/env.json"
+    override_path = template.format(**avalon.api.Session)
+    if os.path.isfile(override_path):
+        print("Loading project env override: %s" % override_path)
+        try:
+            with open(override_path, "r") as f:
+                override = json.load(f)
+                override = {str(key): str(value) for key, value in
+                            override.items()}
+                os.environ.update(override)
+        except Exception as exc:
+            print(exc)
 
 
 def uninstall():
     print("Deregistering global plug-ins..")
-    pyblish.deregister_plugin_path(PUBLISH_PATH)
-    avalon.deregister_plugin_path(avalon.Loader, LOAD_PATH)
+    pyblish.api.deregister_plugin_path(PUBLISH_PATH)
+    avalon.api.deregister_plugin_path(avalon.api.Loader, LOAD_PATH)
+
+    pyblish.api.deregister_target("local")

colorbleed/fusion/menu.py

@@ -0,0 +1,179 @@
+import os
+import sys
+
+from Qt import QtWidgets, QtCore
+
+from .pipeline import (
+    publish
+)
+
+from avalon import api
+from avalon.tools import (
+    creator,
+    loader,
+    sceneinventory,
+    workfiles
+)
+
+
+def load_stylesheet():
+    path = os.path.join(os.path.dirname(__file__), "menu_style.qss")
+    if not os.path.exists(path):
+        print("Unable to load stylesheet, file not found in resources")
+        return ""
+
+    with open(path, "r") as file_stream:
+        stylesheet = file_stream.read()
+    return stylesheet
+
+
+class Spacer(QtWidgets.QWidget):
+    def __init__(self, height, *args, **kwargs):
+        super(self.__class__, self).__init__(*args, **kwargs)
+
+        self.setFixedHeight(height)
+
+        real_spacer = QtWidgets.QWidget(self)
+        real_spacer.setObjectName("Spacer")
+        real_spacer.setFixedHeight(height)
+
+        layout = QtWidgets.QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.addWidget(real_spacer)
+
+        self.setLayout(layout)
+
+
+class Menu(QtWidgets.QWidget):
+    def __init__(self, *args, **kwargs):
+        super(self.__class__, self).__init__(*args, **kwargs)
+
+        self.setObjectName("AvalonMenu")
+
+        self.setWindowFlags(
+            QtCore.Qt.Window
+            | QtCore.Qt.CustomizeWindowHint
+            | QtCore.Qt.WindowTitleHint
+            | QtCore.Qt.WindowCloseButtonHint
+            | QtCore.Qt.WindowStaysOnTopHint
+        )
+        self.render_mode_widget = None
+        self.setWindowTitle("Avalon")
+
+        asset_label = QtWidgets.QLabel("Context", self)
+        asset_label.setStyleSheet("""QLabel {
+            font-size: 14px;
+            font-weight: 600;
+            color: #ffaf24;
+        }""")
+        asset_label.setAlignment(QtCore.Qt.AlignHCenter)
+
+        workfiles_btn = QtWidgets.QPushButton("Workfiles", self)
+        create_btn = QtWidgets.QPushButton("Create...", self)
+        load_btn = QtWidgets.QPushButton("Load...", self)
+        publish_btn = QtWidgets.QPushButton("Publish...", self)
+        inventory_btn = QtWidgets.QPushButton("Manage...", self)
+        #rendermode_btn = QtWidgets.QPushButton("Set render mode", self)
+
+        layout = QtWidgets.QVBoxLayout(self)
+        layout.setContentsMargins(10, 20, 10, 20)
+
+        layout.addWidget(asset_label)
+
+        layout.addWidget(Spacer(15, self))
+
+        layout.addWidget(workfiles_btn)
+
+        layout.addWidget(Spacer(15, self))
+
+        layout.addWidget(create_btn)
+        layout.addWidget(load_btn)
+        layout.addWidget(publish_btn)
+        layout.addWidget(inventory_btn)
+
+        #layout.addWidget(Spacer(15, self))
+
+        #layout.addWidget(rendermode_btn)
+
+        self.setLayout(layout)
+
+        self.asset_label = asset_label
+
+        self.resize(250, 100)
+
+        workfiles_btn.clicked.connect(self.on_workfile_clicked)
+        create_btn.clicked.connect(self.on_create_clicked)
+        publish_btn.clicked.connect(self.on_publish_clicked)
+        load_btn.clicked.connect(self.on_load_clicked)
+        inventory_btn.clicked.connect(self.on_inventory_clicked)
+        #rendermode_btn.clicked.connect(self.on_rendermode_clicked)
+
+        self._callbacks = []
+        self.register_callback("taskChanged", self.on_task_changed)
+        self.on_task_changed()
+
+    def on_task_changed(self):
+        # Update current context label
+        label = api.Session["AVALON_ASSET"]
+        self.asset_label.setText(label)
+
+    def register_callback(self, name, fn):
+
+        # Create a wrapper callback that we only store
+        # for as long as we want it to persist as callback
+        callback = lambda *args: fn()
+        self._callbacks.append(callback)
+        api.on(name, callback)
+
+    def deregister_all_callbacks(self):
+        self._callbacks[:] = []
+
+    def on_workfile_clicked(self):
+        print("Clicked Workfile")
+        workfiles.show()
+
+    def on_create_clicked(self):
+        print("Clicked Create")
+        creator.show()
+
+    def on_publish_clicked(self):
+        print("Clicked Publish")
+        publish()
+
+    def on_load_clicked(self):
+        print("Clicked Load")
+        loader.show(use_context=True)
+
+    def on_inventory_clicked(self):
+        print("Clicked Inventory")
+        sceneinventory.show()
+
+    def on_rendermode_clicked(self):
+        from avalon import style
+        print("Clicked Set Render Mode")
+        if self.render_mode_widget is None:
+            window = set_rendermode.SetRenderMode()
+            window.setStyleSheet(style.load_stylesheet())
+            window.show()
+            self.render_mode_widget = window
+        else:
+            self.render_mode_widget.show()
+
+    def closeEvent(self, event):
+        self.deregister_all_callbacks()
+        super(Menu, self).closeEvent(event)
+
+
+def launch_menu():
+    app = QtWidgets.QApplication(sys.argv)
+    app.setQuitOnLastWindowClosed(False)
+
+    menu = Menu()
+
+    stylesheet = load_stylesheet()
+    menu.setStyleSheet(stylesheet)
+
+    menu.show()
+
+    sys.exit(app.exec_())
+

colorbleed/fusion/menu_style.qss

@@ -0,0 +1,29 @@
+QWidget {
+    background-color: #282828;
+    border-radius: 3;
+}
+
+QPushButton {
+    border: 1px solid #090909;
+    background-color: #201f1f;
+    color: #ffffff;
+    padding: 5;
+}
+
+QPushButton:focus {
+    background-color: "#171717";
+    color: #d0d0d0;
+}
+
+QPushButton:hover {
+    background-color: "#171717";
+    color: #e64b3d;
+}
+
+#PypeMenu {
+    border: 1px solid #fef9ef;
+}
+
+#Spacer {
+    background-color: #282828;
+}

colorbleed/fusion/pipeline.py

@@ -0,0 +1,68 @@
+import os
+import sys
+
+import avalon.api
+import avalon.fusion
+
+import pyblish_lite
+
+
+def publish():
+
+    def _install_pyblish_qml_settings():
+
+        from pyblish_qml import settings
+
+        sys.stdout.write("Applying Pyblish QML settings..\n")
+
+        if settings.ContextLabel == settings.ContextLabelDefault:
+            settings.ContextLabel = "Fusion"
+        if settings.WindowTitle == settings.WindowTitleDefault:
+            settings.WindowTitle = "Pyblish (Fusion)"
+
+    def _install_pyblish_lite_settings():
+
+        from pyblish_lite import settings
+
+        sys.stdout.write("Applying Pyblish Lite settings..\n")
+        settings.ContextLabel = "Fusion"
+        settings.WindowTitle = "Pyblish (Fusion)"
+        # Customize the width and height of the window
+        settings.WindowSize = (600, 650)
+
+    def _set_current_working_dir():
+        # Set current working directory next to comp
+
+        comp = avalon.fusion.get_current_comp()
+        if comp is None:
+            raise RuntimeError("Fusion 'comp' variable not set. "
+                               "Are you running this as Comp script?")
+
+        filename = comp.MapPath(comp.GetAttrs()["COMPS_FileName"])
+        if filename and os.path.exists(filename):
+            cwd = os.path.dirname(filename)
+        else:
+            # Fallback to Avalon projects root
+            # for unsaved files.
+            cwd = os.environ["AVALON_PROJECTS"]
+
+        os.chdir(cwd)
+
+    print("Starting Pyblish setup..")
+
+    # Install avalon
+    avalon.api.install(avalon.fusion)
+
+    # force current working directory to NON FUSION path
+    # os.getcwd will return the binary folder of Fusion in this case
+    _set_current_working_dir()
+
+    # install fusion title
+    _install_pyblish_lite_settings()
+
+    # Run QML in modal mode so it keeps listening to the
+    # server in the main thread and keeps this process
+    # open until QML finishes.
+    print("Running pyblish_lite.show()..")
+    #pyblish_qml.show(modal=True)
+    pyblish_lite.show()