[ui] Explicitely indicate opened templates in graph editor

Author: nicolas-lambert-tc

meshroom/core/graph.py

@@ -228,6 +228,7 @@ def __init__(self, name: str = "", parent: BaseObject = None):
         self._relativeCacheDir: str = ""
         self._cacheDir: str = ""
         self._filepath: str = ""
+        self._templateFilepath: str = ""
         self._fileDateVersion = 0
         self.header = {}
 
@@ -1553,6 +1554,7 @@ def _setFilepath(self, filepath):
         if self._filepath == newFilepath:
             return
         self._filepath = newFilepath
+        self._setTemplateFilepath("")
         # For now:
         #  * cache folder is located next to the graph file
         #  * graph name if the basename of the graph file
@@ -1565,10 +1567,22 @@ def _setFilepath(self, filepath):
 
     def _unsetFilepath(self):
         self._filepath = ""
+        self._setTemplateFilepath("")
         self.name = ""
         self.cacheDir = ""
         self.filepathChanged.emit()
 
+    @Slot(str)
+    def setTemplateFilepath(self, filepath):
+        self._setTemplateFilepath(filepath)
+
+    def _setTemplateFilepath(self, filepath):
+        newFilepath = Path(filepath).as_posix() if filepath else ""
+        if self._templateFilepath == newFilepath:
+            return
+        self._templateFilepath = newFilepath
+        self.templateFilepathChanged.emit()
+
     def updateInternals(self, startNodes=None, force=False):
         nodes, edges = self.dfsOnFinish(startNodes=startNodes)
         for node in nodes:
@@ -1811,6 +1825,8 @@ def setVerbose(self, v):
     edges = Property(BaseObject, edges.fget, constant=True)
     filepathChanged = Signal()
     filepath = Property(str, lambda self: self._filepath, notify=filepathChanged)
+    templateFilepathChanged = Signal()
+    templateFilepath = Property(str, lambda self: self._templateFilepath, notify=templateFilepathChanged)
     isSaving = Property(bool, isSaving.fget, constant=True)
     fileReleaseVersion = Property(str, lambda self: self.header.get(GraphIO.Keys.ReleaseVersion, "0.0"),
                                   notify=filepathChanged)

meshroom/ui/qml/Application.qml

@@ -1509,6 +1509,23 @@ Page {
                                 }
                             }
                         }
+                        // TemplateBadge
+                        MaterialToolButton {
+
+                            readonly property string templateFilePath: {
+                                const coreGraph = _currentScene ? _currentScene.graph : null
+                                const templatePath = coreGraph ? coreGraph.templateFilepath : ""
+                                return templatePath
+                            }
+
+                            text: MaterialIcons.library_books
+                            visible: Boolean(templateFilePath)
+                            font.pointSize: 11
+                            padding: 2
+                            checked: true
+                            ToolTip.text: `Current graph is a template: ${templateFilePath}`
+                            ToolTip.visible: hovered
+                        }
                     }
 
                     GraphEditor {

meshroom/ui/qml/GraphEditor/GraphEditor.qml

@@ -388,6 +388,50 @@ Item {
             }
         }
 
+        Canvas {
+            id: templateBackgroundStripes
+
+            anchors.fill: parent
+            visible: Boolean(root.graph && root.graph.templateFilepath)
+            opacity: 0.03
+
+            readonly property color stripeColor: activePalette.highlight
+            readonly property int stripeWidth: 21
+            readonly property int stripeGap: 42
+
+            onPaint: {
+                const ctx = getContext("2d")
+                ctx.clearRect(0, 0, width, height)
+
+                if (!visible) {
+                    return
+                }
+
+                ctx.save()
+                ctx.strokeStyle = stripeColor
+                ctx.lineWidth = stripeWidth
+
+                const diagonal = Math.sqrt(width * width + height * height)
+                const step = stripeWidth + stripeGap
+                ctx.translate(width * 0.5, height * 0.5)
+                ctx.rotate(-Math.PI / 4)
+
+                for (let x = -diagonal; x <= diagonal; x += step) {
+                    ctx.beginPath()
+                    ctx.moveTo(x, -diagonal)
+                    ctx.lineTo(x, diagonal)
+                    ctx.stroke()
+                }
+
+                ctx.restore()
+            }
+
+            onVisibleChanged: requestPaint()
+            onWidthChanged: requestPaint()
+            onHeightChanged: requestPaint()
+            onStripeColorChanged: requestPaint()
+        }
+
         Item {
             id: draggable
             transformOrigin: Item.TopLeft

meshroom/ui/scene.py

@@ -503,7 +503,10 @@ def load(self, url):
     @Slot(QUrl, result=bool)
     def loadTemplate(self, url):
         localFile = self._urlToLocalFile(url)
-        return self._loadWithErrorReport(self._initFromTemplateWithCopyOutputs, localFile)
+        loaded = self._loadWithErrorReport(self._initFromTemplateWithCopyOutputs, localFile)
+        if loaded:
+            self.graph.setTemplateFilepath(localFile)
+        return loaded
 
     @staticmethod
     def _urlToLocalFile(url) -> str: