Merge branch 'main' into CURA-12556_formula-parser-in-CuraEngine

Author: rburema

cura/CuraApplication.py

@@ -140,7 +140,7 @@ class CuraApplication(QtApplication):
     # SettingVersion represents the set of settings available in the machine/extruder definitions.
     # You need to make sure that this version number needs to be increased if there is any non-backwards-compatible
     # changes of the settings.
-    SettingVersion = 25
+    SettingVersion = 26
 
     Created = False
 

plugins/PaintTool/PaintTool.py

@@ -51,6 +51,7 @@ def __init__(self, view: PaintView) -> None:
         self._view: PaintView = view
         self._view.canUndoChanged.connect(self._onCanUndoChanged)
         self._view.canRedoChanged.connect(self._onCanRedoChanged)
+        self._view.currentPaintedObjectMeshDataChanged.connect(self._updateState)
 
         self._picking_pass: Optional[PickingPass] = None
         self._faces_selection_pass: Optional[SelectionPass] = None
@@ -198,40 +199,6 @@ def clear(self) -> None:
         self._view.clearPaint()
         self._updateScene(update_node = True)
 
-    @staticmethod
-    def _get_intersect_ratio_via_pt(a: numpy.ndarray, pt: numpy.ndarray, b: numpy.ndarray, c: numpy.ndarray) -> float:
-        # compute the intersection of (param) A - pt with (param) B - (param) C
-        if all(a == pt) or all(b == c) or all(a == c) or all(a == b):
-            return 1.0
-
-        # compute unit vectors of directions of lines A and B
-        udir_a = a - pt
-        udir_a /= numpy.linalg.norm(udir_a)
-        udir_b = b - c
-        udir_b /= numpy.linalg.norm(udir_b)
-
-        # find unit direction vector for line C, which is perpendicular to lines A and B
-        udir_res = numpy.cross(udir_b, udir_a)
-        udir_res_len = numpy.linalg.norm(udir_res)
-        if udir_res_len == 0:
-            return 1.0
-        udir_res /= udir_res_len
-
-        # solve system of equations
-        rhs = b - a
-        lhs = numpy.array([udir_a, -udir_b, udir_res]).T
-        try:
-            solved = numpy.linalg.solve(lhs, rhs)
-        except numpy.linalg.LinAlgError:
-            return 1.0
-
-        # get the ratio
-        intersect = ((a + solved[0] * udir_a) + (b + solved[1] * udir_b)) * 0.5
-        a_intersect_dist = numpy.linalg.norm(a - intersect)
-        if a_intersect_dist == 0:
-            return 1.0
-        return numpy.linalg.norm(pt - intersect) / a_intersect_dist
-
     def _nodeTransformChanged(self, *args) -> None:
         self._cache_dirty = True
 
@@ -453,7 +420,7 @@ def _updateActiveView(self) -> None:
     def _updateState(self):
         painted_object = self._view.getPaintedObject()
         if painted_object is not None and self._controller.getActiveTool() == self:
-            if painted_object.callDecoration("getPaintTexture") is not None:
+            if painted_object.callDecoration("getPaintTexture") is not None and painted_object.getMeshData().hasUVCoordinates():
                 new_state = PaintTool.Paint.State.READY
             else:
                 new_state = PaintTool.Paint.State.PREPARING_MODEL
@@ -472,6 +439,7 @@ def _onPrepareTextureFinished(self, job: Job):
             self._prepare_texture_job = None
             self._state = PaintTool.Paint.State.READY
             self.propertyChanged.emit()
+            self._updateScene()
 
     def _updateIgnoreUnselectedObjects(self):
         ignore_unselected_objects = self._controller.getActiveView().name == "PaintTool"

plugins/PaintTool/PaintView.py

@@ -61,11 +61,13 @@ def __init__(self) -> None:
 
     canUndoChanged = pyqtSignal(bool)
     canRedoChanged = pyqtSignal(bool)
+    currentPaintedObjectMeshDataChanged = pyqtSignal()
 
     def setPaintedObject(self, painted_object: Optional[SceneNode]):
         if self._painted_object is not None:
             texture_changed_signal = self._painted_object.callDecoration("getPaintTextureChangedSignal")
             texture_changed_signal.disconnect(self._onCurrentPaintedObjectTextureChanged)
+            self._painted_object.meshDataChanged.disconnect(self._onCurrentPaintedObjectMesDataChanged)
 
         self._paint_texture = None
         self._cursor_texture = None
@@ -78,6 +80,7 @@ def setPaintedObject(self, painted_object: Optional[SceneNode]):
             if texture_changed_signal is not None:
                 texture_changed_signal.connect(self._onCurrentPaintedObjectTextureChanged)
             self._onCurrentPaintedObjectTextureChanged()
+            self._painted_object.meshDataChanged.connect(self._onCurrentPaintedObjectMesDataChanged)
 
         self._updateCurrentBitsRanges()
 
@@ -99,6 +102,10 @@ def _onCurrentPaintedObjectTextureChanged(self) -> None:
         else:
             self._cursor_texture = None
 
+    def _onCurrentPaintedObjectMesDataChanged(self, object: SceneNode) -> None:
+        if object == self._painted_object:
+            self.currentPaintedObjectMeshDataChanged.emit()
+
     def canUndo(self):
         stack = self._getUndoStack()
         return stack.canUndo() if stack is not None else False

plugins/PostProcessingPlugin/PostProcessingPlugin.qml

@@ -39,6 +39,42 @@ UM.Dialog
 
         anchors.fill: parent
 
+        // Helper function to check if a setting should use multiline text area
+        // Supports "multiline" or "@[multiline]" or "@[multiline, other] comment"
+        function isMultilineSetting(definition)
+        {
+            if (!definition || !definition.comments)
+            {
+                return false;
+            }
+            
+            var commentsLower = definition.comments.toLowerCase();
+            
+            // Simple format: exact match
+            if (commentsLower === "multiline")
+            {
+                return true;
+            }
+            
+            // Directive format: parse @[...] and check if multiline is in the list
+            var directiveStart = commentsLower.indexOf("@[");
+            var directiveEnd = commentsLower.indexOf("]", directiveStart);
+            if (directiveStart >= 0 && directiveEnd > directiveStart)
+            {
+                var directivesText = commentsLower.substring(directiveStart + 2, directiveEnd);
+                var directives = directivesText.split(",");
+                for (var i = 0; i < directives.length; i++)
+                {
+                    if (directives[i].trim() === "multiline")
+                    {
+                        return true;
+                    }
+                }
+            }
+            
+            return false;
+        }
+
         ButtonGroup
         {
             id: selectedScriptGroup
@@ -301,6 +337,10 @@ UM.Dialog
                     {
                         if (provider.properties.enabled == "True" && model.type != undefined)
                         {
+                            if (definition && definition.comments && definition.comments.toLowerCase() === "multiline")
+                            {
+                                return UM.Theme.getSize("standard_list_lineheight").height + UM.Theme.getSize("narrow_margin").height + (UM.Theme.getSize("setting_control").height * 3);
+                            }
                             return UM.Theme.getSize("section").height;
                         }
                         else
@@ -331,6 +371,19 @@ UM.Dialog
                         settingLoader.item.showLinkedSettingIcon = false
                         settingLoader.item.doDepthIndentation = false
                         settingLoader.item.doQualityUserSettingEmphasis = false
+                        // Pass properties explicitly to custom components that don't extend SettingItem
+                        if (settingLoader.item.hasOwnProperty("definition")) {
+                            settingLoader.item.definition = settingLoader.definition
+                        }
+                        if (settingLoader.item.hasOwnProperty("settingDefinitionsModel")) {
+                            settingLoader.item.settingDefinitionsModel = settingLoader.settingDefinitionsModel
+                        }
+                        if (settingLoader.item.hasOwnProperty("propertyProvider")) {
+                            settingLoader.item.propertyProvider = settingLoader.propertyProvider
+                        }
+                        if (settingLoader.item.hasOwnProperty("globalPropertyProvider")) {
+                            settingLoader.item.globalPropertyProvider = settingLoader.globalPropertyProvider
+                        }
                     }
 
                     sourceComponent:
@@ -348,7 +401,7 @@ UM.Dialog
                             case "bool":
                                 return settingCheckBox
                             case "str":
-                                return settingTextField
+                                return base.isMultilineSetting(definition) ? settingTextArea : settingTextField
                             case "category":
                                 return settingCategory
                             default:
@@ -405,6 +458,13 @@ UM.Dialog
             Cura.SettingTextField { }
         }
 
+        Component
+        {
+            id: settingTextArea;
+
+            SettingTextArea { }
+        }
+
         Component
         {
             id: settingComboBox;

plugins/PostProcessingPlugin/SettingTextArea.qml

@@ -0,0 +1,108 @@
+// Copyright (c) 2025 Ultimaker B.V.
+// Cura is released under the terms of the LGPLv3 or higher.
+
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+
+import UM 1.7 as UM
+
+// Custom multiline text area component for post-processing script settings
+// Triggered when setting has "comments": "multiline" property
+Item
+{
+    id: base
+
+    // Properties passed from the Loader
+    property var definition
+    property var settingDefinitionsModel
+    property var propertyProvider
+    property var globalPropertyProvider
+    
+    // Standard setting item properties (required by loader but unused in this component)
+    property bool showRevertButton: false
+    property bool showInheritButton: false
+    property bool showLinkedSettingIcon: false
+    property bool doDepthIndentation: false
+    property bool doQualityUserSettingEmphasis: false
+
+    // Internal state tracking (unused but kept for potential future use)
+    property string textBeforeEdit
+    property bool textHasChanged
+
+    // Signals for tooltip support (required by Connections in loader)
+    // Note: These signals are declared but intentionally never emitted.
+    // This prevents tooltips from appearing on mouse-over, which would obstruct the text area
+    // while the user is typing or editing multiline content.
+    signal showTooltip(string text)
+    signal hideTooltip()
+
+    width: parent.width
+    // Height calculation: label height + spacing + text area (3x normal height for multiline editing)
+    height: UM.Theme.getSize("standard_list_lineheight").height + UM.Theme.getSize("narrow_margin").height + (UM.Theme.getSize("setting_control").height * 3)
+
+    UM.Label
+    {
+        id: labelText
+        anchors.top: parent.top
+        anchors.left: parent.left
+        anchors.right: parent.right
+        height: UM.Theme.getSize("standard_list_lineheight").height
+        text: definition ? definition.label : ""
+        elide: Text.ElideRight
+        font: UM.Theme.getFont("default_bold")
+        color: UM.Theme.getColor("text")
+    }
+
+    Flickable
+    {
+        id: flickable
+        anchors.top: labelText.bottom
+        anchors.topMargin: UM.Theme.getSize("narrow_margin").height
+        anchors.left: parent.left
+        anchors.right: parent.right
+        // Right margin to prevent overlap with parent ListView scrollbar
+        anchors.rightMargin: UM.Theme.getSize("default_margin").width + UM.Theme.getSize("narrow_margin").width
+        height: UM.Theme.getSize("setting_control").height * 3
+        
+        clip: true
+        ScrollBar.vertical: UM.ScrollBar { }
+        
+        TextArea.flickable: TextArea
+        {
+            id: textArea
+            
+            enabled: propertyProvider && propertyProvider.properties ? propertyProvider.properties.enabled === "True" : true
+            // Explicit undefined check to prevent QML warnings about undefined QString assignment
+            text: (propertyProvider && propertyProvider.properties && propertyProvider.properties.value !== undefined) ? propertyProvider.properties.value : ""
+            
+            background: Rectangle
+            {
+                color: UM.Theme.getColor("setting_control")
+                border.color: textArea.activeFocus ? UM.Theme.getColor("text_field_border_active") : UM.Theme.getColor("text_field_border")
+                border.width: UM.Theme.getSize("default_lining").width
+            }
+
+            onTextChanged:
+            {
+                // Save value on each keystroke when focused (live update)
+                if (activeFocus && propertyProvider)
+                {
+                    propertyProvider.setPropertyValue("value", text);
+                }
+            }
+
+            font: UM.Theme.getFont("default")
+            color: UM.Theme.getColor("text")
+            selectionColor: UM.Theme.getColor("text_selection")
+            selectedTextColor: UM.Theme.getColor("text")
+            wrapMode: TextEdit.NoWrap
+            selectByMouse: true
+
+            // Allow Enter/Return to insert newlines instead of closing dialog
+            Keys.onReturnPressed: function(event) { event.accepted = false; }
+            Keys.onEnterPressed: function(event) { event.accepted = false; }
+            // Escape key removes focus from text area
+            Keys.onEscapePressed: function(event) { focus = false; event.accepted = true; }
+        }
+    }
+}

plugins/PostProcessingPlugin/plugin.json

@@ -1,7 +1,7 @@
 {
     "name": "Post Processing",
     "author": "Ultimaker",
-    "version": "2.2.1",
+    "version": "2.3.0",
     "api": 8,
     "description": "Extension that allows for user created scripts for post processing",
     "catalog": "cura"