Merge branch 'master' into CURA-8640_PyQt6

# Conflicts:
#	cura/UI/CuraSplashScreen.py

cura/Arranging/Arrange.py

@@ -1,258 +0,0 @@
-# Copyright (c) 2020 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
-from typing import Optional
-
-from UM.Decorators import deprecated
-from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
-from UM.Logger import Logger
-from UM.Math.Polygon import Polygon
-from UM.Math.Vector import Vector
-from UM.Scene.SceneNode import SceneNode
-from cura.Arranging.ShapeArray import ShapeArray
-from cura.BuildVolume import BuildVolume
-from cura.Scene import ZOffsetDecorator
-
-from collections import namedtuple
-
-import numpy
-import copy
-
-LocationSuggestion = namedtuple("LocationSuggestion", ["x", "y", "penalty_points", "priority"])
-"""Return object for  bestSpot"""
-
-
-class Arrange:
-    """
-    The Arrange classed is used together with :py:class:`cura.Arranging.ShapeArray.ShapeArray`. Use it to find good locations for objects that you try to put
-    on a build place. Different priority schemes can be defined so it alters the behavior while using the same logic.
-
-    .. note::
-
-       Make sure the scale is the same between :py:class:`cura.Arranging.ShapeArray.ShapeArray` objects and the :py:class:`cura.Arranging.Arrange.Arrange` instance.
-    """
-
-    build_volume = None  # type: Optional[BuildVolume]
-
-    @deprecated("Use the functions in Nest2dArrange instead", "4.8")
-    def __init__(self, x, y, offset_x, offset_y, scale = 0.5):
-        self._scale = scale  # convert input coordinates to arrange coordinates
-        world_x, world_y = int(x * self._scale), int(y * self._scale)
-        self._shape = (world_y, world_x)
-        self._priority = numpy.zeros((world_y, world_x), dtype=numpy.int32)  # beware: these are indexed (y, x)
-        self._priority_unique_values = []
-        self._occupied = numpy.zeros((world_y, world_x), dtype=numpy.int32)  # beware: these are indexed (y, x)
-        self._offset_x = int(offset_x * self._scale)
-        self._offset_y = int(offset_y * self._scale)
-        self._last_priority = 0
-        self._is_empty = True
-
-    @classmethod
-    @deprecated("Use the functions in Nest2dArrange instead", "4.8")
-    def create(cls, scene_root = None, fixed_nodes = None, scale = 0.5, x = 350, y = 250, min_offset = 8) -> "Arrange":
-        """Helper to create an :py:class:`cura.Arranging.Arrange.Arrange` instance
-
-        Either fill in scene_root and create will find all sliceable nodes by itself, or use fixed_nodes to provide the
-        nodes yourself.
-
-        :param scene_root: Root for finding all scene nodes default = None
-        :param fixed_nodes: Scene nodes to be placed default = None
-        :param scale: default = 0.5
-        :param x: default = 350
-        :param y: default = 250
-        :param min_offset: default = 8
-        """
-
-        arranger = Arrange(x, y, x // 2, y // 2, scale = scale)
-        arranger.centerFirst()
-
-        if fixed_nodes is None:
-            fixed_nodes = []
-            for node_ in DepthFirstIterator(scene_root):
-                # Only count sliceable objects
-                if node_.callDecoration("isSliceable"):
-                    fixed_nodes.append(node_)
-
-        # Place all objects fixed nodes
-        for fixed_node in fixed_nodes:
-            vertices = fixed_node.callDecoration("getConvexHullHead") or fixed_node.callDecoration("getConvexHull")
-            if not vertices:
-                continue
-            vertices = vertices.getMinkowskiHull(Polygon.approximatedCircle(min_offset))
-            points = copy.deepcopy(vertices._points)
-
-            # After scaling (like up to 0.1 mm) the node might not have points
-            if not points.size:
-                continue
-            try:
-                shape_arr = ShapeArray.fromPolygon(points, scale = scale)
-            except ValueError:
-                Logger.logException("w", "Unable to create polygon")
-                continue
-            arranger.place(0, 0, shape_arr)
-
-        # If a build volume was set, add the disallowed areas
-        if Arrange.build_volume:
-            disallowed_areas = Arrange.build_volume.getDisallowedAreasNoBrim()
-            for area in disallowed_areas:
-                points = copy.deepcopy(area._points)
-                shape_arr = ShapeArray.fromPolygon(points, scale = scale)
-                arranger.place(0, 0, shape_arr, update_empty = False)
-        return arranger
-
-    def resetLastPriority(self):
-        """This resets the optimization for finding location based on size"""
-
-        self._last_priority = 0
-
-    @deprecated("Use the functions in Nest2dArrange instead", "4.8")
-    def findNodePlacement(self, node: SceneNode, offset_shape_arr: ShapeArray, hull_shape_arr: ShapeArray, step = 1) -> bool:
-        """Find placement for a node (using offset shape) and place it (using hull shape)
-
-        :param node: The node to be placed
-        :param offset_shape_arr: shape array with offset, for placing the shape
-        :param hull_shape_arr: shape array without offset, used to find location
-        :param step: default = 1
-        :return: the nodes that should be placed
-        """
-
-        best_spot = self.bestSpot(
-            hull_shape_arr, start_prio = self._last_priority, step = step)
-        x, y = best_spot.x, best_spot.y
-
-        # Save the last priority.
-        self._last_priority = best_spot.priority
-
-        # Ensure that the object is above the build platform
-        node.removeDecorator(ZOffsetDecorator.ZOffsetDecorator)
-        bbox = node.getBoundingBox()
-        if bbox:
-            center_y = node.getWorldPosition().y - bbox.bottom
-        else:
-            center_y = 0
-
-        if x is not None:  # We could find a place
-            node.setPosition(Vector(x, center_y, y))
-            found_spot = True
-            self.place(x, y, offset_shape_arr)  # place the object in arranger
-        else:
-            Logger.log("d", "Could not find spot!")
-            found_spot = False
-            node.setPosition(Vector(200, center_y, 100))
-        return found_spot
-
-    def centerFirst(self):
-        """Fill priority, center is best. Lower value is better. """
-
-        # Square distance: creates a more round shape
-        self._priority = numpy.fromfunction(
-            lambda j, i: (self._offset_x - i) ** 2 + (self._offset_y - j) ** 2, self._shape, dtype=numpy.int32)
-        self._priority_unique_values = numpy.unique(self._priority)
-        self._priority_unique_values.sort()
-
-    def backFirst(self):
-        """Fill priority, back is best. Lower value is better """
-
-        self._priority = numpy.fromfunction(
-            lambda j, i: 10 * j + abs(self._offset_x - i), self._shape, dtype=numpy.int32)
-        self._priority_unique_values = numpy.unique(self._priority)
-        self._priority_unique_values.sort()
-
-    def checkShape(self, x, y, shape_arr) -> Optional[numpy.ndarray]:
-        """Return the amount of "penalty points" for polygon, which is the sum of priority
-
-        :param x: x-coordinate to check shape
-        :param y: y-coordinate to check shape
-        :param shape_arr: the shape array object to place
-        :return: None if occupied
-        """
-
-        x = int(self._scale * x)
-        y = int(self._scale * y)
-        offset_x = x + self._offset_x + shape_arr.offset_x
-        offset_y = y + self._offset_y + shape_arr.offset_y
-        if offset_x < 0 or offset_y < 0:
-            return None  # out of bounds in self._occupied
-        occupied_x_max = offset_x + shape_arr.arr.shape[1]
-        occupied_y_max = offset_y + shape_arr.arr.shape[0]
-        if occupied_x_max > self._occupied.shape[1] + 1 or occupied_y_max > self._occupied.shape[0] + 1:
-            return None  # out of bounds in self._occupied
-        occupied_slice = self._occupied[
-            offset_y:occupied_y_max,
-            offset_x:occupied_x_max]
-        try:
-            if numpy.any(occupied_slice[numpy.where(shape_arr.arr == 1)]):
-                return None
-        except IndexError:  # out of bounds if you try to place an object outside
-            return None
-        prio_slice = self._priority[
-            offset_y:offset_y + shape_arr.arr.shape[0],
-            offset_x:offset_x + shape_arr.arr.shape[1]]
-        return numpy.sum(prio_slice[numpy.where(shape_arr.arr == 1)])
-
-    def bestSpot(self, shape_arr, start_prio = 0, step = 1) -> LocationSuggestion:
-        """Find "best" spot for ShapeArray
-
-        :param shape_arr: shape array
-        :param start_prio: Start with this priority value (and skip the ones before)
-        :param step: Slicing value, higher = more skips = faster but less accurate
-        :return: namedtuple with properties x, y, penalty_points, priority.
-        """
-
-        start_idx_list = numpy.where(self._priority_unique_values == start_prio)
-        if start_idx_list:
-            try:
-                start_idx = start_idx_list[0][0]
-            except IndexError:
-                start_idx = 0
-        else:
-            start_idx = 0
-        priority = 0
-        for priority in self._priority_unique_values[start_idx::step]:
-            tryout_idx = numpy.where(self._priority == priority)
-            for idx in range(len(tryout_idx[0])):
-                x = tryout_idx[1][idx]
-                y = tryout_idx[0][idx]
-                projected_x = int((x - self._offset_x) / self._scale)
-                projected_y = int((y - self._offset_y) / self._scale)
-
-                penalty_points = self.checkShape(projected_x, projected_y, shape_arr)
-                if penalty_points is not None:
-                    return LocationSuggestion(x = projected_x, y = projected_y, penalty_points = penalty_points, priority = priority)
-        return LocationSuggestion(x = None, y = None, penalty_points = None, priority = priority)  # No suitable location found :-(
-
-    def place(self, x, y, shape_arr, update_empty = True):
-        """Place the object.
-
-        Marks the locations in self._occupied and self._priority
-
-        :param x:
-        :param y:
-        :param shape_arr:
-        :param update_empty: updates the _is_empty, used when adding disallowed areas
-        """
-
-        x = int(self._scale * x)
-        y = int(self._scale * y)
-        offset_x = x + self._offset_x + shape_arr.offset_x
-        offset_y = y + self._offset_y + shape_arr.offset_y
-        shape_y, shape_x = self._occupied.shape
-
-        min_x = min(max(offset_x, 0), shape_x - 1)
-        min_y = min(max(offset_y, 0), shape_y - 1)
-        max_x = min(max(offset_x + shape_arr.arr.shape[1], 0), shape_x - 1)
-        max_y = min(max(offset_y + shape_arr.arr.shape[0], 0), shape_y - 1)
-        occupied_slice = self._occupied[min_y:max_y, min_x:max_x]
-        # we use a slice of shape because it can be out of bounds
-        new_occupied = numpy.where(shape_arr.arr[
-            min_y - offset_y:max_y - offset_y, min_x - offset_x:max_x - offset_x] == 1)
-        if update_empty and new_occupied:
-            self._is_empty = False
-        occupied_slice[new_occupied] = 1
-
-        # Set priority to low (= high number), so it won't get picked at trying out.
-        prio_slice = self._priority[min_y:max_y, min_x:max_x]
-        prio_slice[new_occupied] = 999
-
-    @property
-    def isEmpty(self):
-        return self._is_empty

cura/Arranging/ArrangeObjectsAllBuildPlatesJob.py

@@ -1,154 +0,0 @@
-# Copyright (c) 2019 Ultimaker B.V.
-# Cura is released under the terms of the LGPLv3 or higher.
-
-from UM.Application import Application
-from UM.Job import Job
-from UM.Scene.SceneNode import SceneNode
-from UM.Math.Vector import Vector
-from UM.Operations.TranslateOperation import TranslateOperation
-from UM.Operations.GroupedOperation import GroupedOperation
-from UM.Message import Message
-from UM.i18n import i18nCatalog
-i18n_catalog = i18nCatalog("cura")
-
-from cura.Scene.ZOffsetDecorator import ZOffsetDecorator
-from cura.Arranging.Arrange import Arrange
-from cura.Arranging.ShapeArray import ShapeArray
-
-from typing import List
-
-
-class ArrangeArray:
-    """Do arrangements on multiple build plates (aka builtiplexer)"""
-
-    def __init__(self, x: int, y: int, fixed_nodes: List[SceneNode]) -> None:
-        self._x = x
-        self._y = y
-        self._fixed_nodes = fixed_nodes
-        self._count = 0
-        self._first_empty = None
-        self._has_empty = False
-        self._arrange = []  # type: List[Arrange]
-
-    def _updateFirstEmpty(self):
-        for i, a in enumerate(self._arrange):
-            if a.isEmpty:
-                self._first_empty = i
-                self._has_empty = True
-                return
-        self._first_empty = None
-        self._has_empty = False
-
-    def add(self):
-        new_arrange = Arrange.create(x = self._x, y = self._y, fixed_nodes = self._fixed_nodes)
-        self._arrange.append(new_arrange)
-        self._count += 1
-        self._updateFirstEmpty()
-
-    def count(self):
-        return self._count
-
-    def get(self, index):
-        return self._arrange[index]
-
-    def getFirstEmpty(self):
-        if not self._has_empty:
-            self.add()
-        return self._arrange[self._first_empty]
-
-
-class ArrangeObjectsAllBuildPlatesJob(Job):
-    def __init__(self, nodes: List[SceneNode], min_offset = 8) -> None:
-        super().__init__()
-        self._nodes = nodes
-        self._min_offset = min_offset
-
-    def run(self):
-        status_message = Message(i18n_catalog.i18nc("@info:status", "Finding new location for objects"),
-                                 lifetime = 0,
-                                 dismissable=False,
-                                 progress = 0,
-                                 title = i18n_catalog.i18nc("@info:title", "Finding Location"))
-        status_message.show()
-
-
-        # Collect nodes to be placed
-        nodes_arr = []  # fill with (size, node, offset_shape_arr, hull_shape_arr)
-        for node in self._nodes:
-            offset_shape_arr, hull_shape_arr = ShapeArray.fromNode(node, min_offset = self._min_offset)
-            nodes_arr.append((offset_shape_arr.arr.shape[0] * offset_shape_arr.arr.shape[1], node, offset_shape_arr, hull_shape_arr))
-
-        # Sort the nodes with the biggest area first.
-        nodes_arr.sort(key=lambda item: item[0])
-        nodes_arr.reverse()
-
-        global_container_stack = Application.getInstance().getGlobalContainerStack()
-        machine_width = global_container_stack.getProperty("machine_width", "value")
-        machine_depth = global_container_stack.getProperty("machine_depth", "value")
-
-        x, y = machine_width, machine_depth
-
-        arrange_array = ArrangeArray(x = x, y = y, fixed_nodes = [])
-        arrange_array.add()
-
-        # Place nodes one at a time
-        start_priority = 0
-        grouped_operation = GroupedOperation()
-        found_solution_for_all = True
-        left_over_nodes = []  # nodes that do not fit on an empty build plate
-
-        for idx, (size, node, offset_shape_arr, hull_shape_arr) in enumerate(nodes_arr):
-            # For performance reasons, we assume that when a location does not fit,
-            # it will also not fit for the next object (while what can be untrue).
-
-            try_placement = True
-
-            current_build_plate_number = 0  # always start with the first one
-
-            while try_placement:
-                # make sure that current_build_plate_number is not going crazy or you'll have a lot of arrange objects
-                while current_build_plate_number >= arrange_array.count():
-                    arrange_array.add()
-                arranger = arrange_array.get(current_build_plate_number)
-
-                best_spot = arranger.bestSpot(hull_shape_arr, start_prio=start_priority)
-                x, y = best_spot.x, best_spot.y
-                node.removeDecorator(ZOffsetDecorator)
-                if node.getBoundingBox():
-                    center_y = node.getWorldPosition().y - node.getBoundingBox().bottom
-                else:
-                    center_y = 0
-                if x is not None:  # We could find a place
-                    arranger.place(x, y, offset_shape_arr)  # place the object in the arranger
-
-                    node.callDecoration("setBuildPlateNumber", current_build_plate_number)
-                    grouped_operation.addOperation(TranslateOperation(node, Vector(x, center_y, y), set_position = True))
-                    try_placement = False
-                else:
-                    # very naive, because we skip to the next build plate if one model doesn't fit.
-                    if arranger.isEmpty:
-                        # apparently we can never place this object
-                        left_over_nodes.append(node)
-                        try_placement = False
-                    else:
-                        # try next build plate
-                        current_build_plate_number += 1
-                        try_placement = True
-
-            status_message.setProgress((idx + 1) / len(nodes_arr) * 100)
-            Job.yieldThread()
-
-        for node in left_over_nodes:
-            node.callDecoration("setBuildPlateNumber", -1)  # these are not on any build plate
-            found_solution_for_all = False
-
-        grouped_operation.push()
-
-        status_message.hide()
-
-        if not found_solution_for_all:
-            no_full_solution_message = Message(i18n_catalog.i18nc("@info:status",
-                                                                  "Unable to find a location within the build volume for all objects"),
-                                               title = i18n_catalog.i18nc("@info:title", "Can't Find Location"),
-                                               message_type = Message.MessageType.WARNING)
-            no_full_solution_message.show()

cura/CuraApplication.py

@@ -52,8 +52,6 @@ from UM.i18n import i18nCatalog
 from cura import ApplicationMetadata
 from cura.API import CuraAPI
 from cura.API.Account import Account
-from cura.Arranging.Arrange import Arrange
-from cura.Arranging.ArrangeObjectsAllBuildPlatesJob import ArrangeObjectsAllBuildPlatesJob
 from cura.Arranging.ArrangeObjectsJob import ArrangeObjectsJob
 from cura.Arranging.Nest2DArrange import arrange
 from cura.Machines.MachineErrorChecker import MachineErrorChecker
@@ -835,9 +833,6 @@ class CuraApplication(QtApplication):
         root = self.getController().getScene().getRoot()
         self._volume = BuildVolume.BuildVolume(self, root)
 
-        # Ensure that the old style arranger still works.
-        Arrange.build_volume = self._volume
-
         # initialize info objects
         self._print_information = PrintInformation.PrintInformation(self)
         self._cura_actions = CuraActions.CuraActions(self)
@@ -1393,33 +1388,6 @@ class CuraApplication(QtApplication):
                 op.addOperation(SetTransformOperation(node, Vector(0, center_y, 0), Quaternion(), Vector(1, 1, 1)))
             op.push()
 
-    @pyqtSlot()
-    def arrangeObjectsToAllBuildPlates(self) -> None:
-        """Arrange all objects."""
-
-        nodes_to_arrange = []
-        for node in DepthFirstIterator(self.getController().getScene().getRoot()):
-            if not isinstance(node, SceneNode):
-                continue
-
-            if not node.getMeshData() and not node.callDecoration("isGroup"):
-                continue  # Node that doesn't have a mesh and is not a group.
-
-            parent_node = node.getParent()
-            if parent_node and parent_node.callDecoration("isGroup"):
-                continue  # Grouped nodes don't need resetting as their parent (the group) is reset)
-
-            if not node.callDecoration("isSliceable") and not node.callDecoration("isGroup"):
-                continue  # i.e. node with layer data
-
-            bounding_box = node.getBoundingBox()
-            # Skip nodes that are too big
-            if bounding_box is None or bounding_box.width < self._volume.getBoundingBox().width or bounding_box.depth < self._volume.getBoundingBox().depth:
-                nodes_to_arrange.append(node)
-        job = ArrangeObjectsAllBuildPlatesJob(nodes_to_arrange)
-        job.start()
-        self.getCuraSceneController().setActiveBuildPlate(0)  # Select first build plate
-
     # Single build plate
     @pyqtSlot()
     def arrangeAll(self) -> None:

cura/PrinterOutput/PrinterOutputModel.py

@@ -1,4 +0,0 @@
-import warnings
-warnings.warn("Importing cura.PrinterOutput.PrinterOutputModel has been deprecated since 4.1, use cura.PrinterOutput.Models.PrinterOutputModel instead", DeprecationWarning, stacklevel=2)
-# We moved the the models to one submodule deeper
-from cura.PrinterOutput.Models.PrinterOutputModel import PrinterOutputModel

cura/PrinterOutputDevice.py

@@ -1,4 +0,0 @@
-import warnings
-warnings.warn("Importing cura.PrinterOutputDevice has been deprecated since 4.1, use cura.PrinterOutput.PrinterOutputDevice instead", DeprecationWarning, stacklevel=2)
-# We moved the PrinterOutput device to it's own submodule.
-from cura.PrinterOutput.PrinterOutputDevice import PrinterOutputDevice, ConnectionState

cura/Settings/GlobalStack.py

@@ -60,16 +60,6 @@ class GlobalStack(CuraContainerStack):
     extrudersChanged = pyqtSignal()
     configuredConnectionTypesChanged = pyqtSignal()
 
-    @pyqtProperty("QVariantMap", notify = extrudersChanged)
-    @deprecated("Please use extruderList instead.", "4.4")
-    def extruders(self) -> Dict[str, "ExtruderStack"]:
-        """Get the list of extruders of this stack.
-
-        :return: The extruders registered with this stack.
-        """
-
-        return self._extruders
-
     @pyqtProperty("QVariantList", notify = extrudersChanged)
     def extruderList(self) -> List["ExtruderStack"]:
         result_tuple_list = sorted(list(self._extruders.items()), key=lambda x: int(x[0]))

cura/UI/CuraSplashScreen.py

@@ -14,7 +14,7 @@ import time
 class CuraSplashScreen(QSplashScreen):
     def __init__(self):
         super().__init__()
-        self._scale = 0.7
+        self._scale = 1
         self._version_y_offset = 0  # when extra visual elements are in the background image, move version text down
 
         if ApplicationMetadata.IsAlternateVersion:
@@ -69,23 +69,21 @@ class CuraSplashScreen(QSplashScreen):
         version = Application.getInstance().getVersion().split("-")
 
         # Draw version text
-        font = QFont()  # Using system-default font here
-        font.setPixelSize(18)
+        font = QFont()
+        font.setPixelSize(24)
         painter.setFont(font)
-        painter.drawText(60, 70 + self._version_y_offset, round(330 * self._scale), round(230 * self._scale), Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop, version[0] if not ApplicationMetadata.IsAlternateVersion else ApplicationMetadata.CuraBuildType)
-        if len(version) > 1:
-            font.setPixelSize(16)
-            painter.setFont(font)
-            painter.setPen(QColor(200, 200, 200, 255))
-            painter.drawText(247, 105 + self._version_y_offset, round(330 * self._scale), round(255 * self._scale), Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop, version[1])
-        painter.setPen(QColor(255, 255, 255, 255))
+
+        if len(version) == 1:
+            painter.drawText(40, 104 + self._version_y_offset, round(330 * self._scale), round(230 * self._scale), Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop, version[0] if not ApplicationMetadata.IsAlternateVersion else ApplicationMetadata.CuraBuildType)
+        elif len(version) > 1:
+            painter.drawText(40, 104 + self._version_y_offset, round(330 * self._scale), round(230 * self._scale), Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop, version[0] +" "+ version[1] if not ApplicationMetadata.IsAlternateVersion else ApplicationMetadata.CuraBuildType)
 
         # Draw the loading image
         pen = QPen()
-        pen.setWidthF(6 * self._scale)
-        pen.setColor(QColor(32, 166, 219, 255))
+        pen.setWidthF(2 * self._scale)
+        pen.setColor(QColor(255, 255, 255, 255))
         painter.setPen(pen)
-        painter.drawArc(60, 150, round(32 * self._scale), round(32 * self._scale), round(self._loading_image_rotation_angle * 16), 300 * 16)
+        painter.drawArc(38, 324, round(20 * self._scale), round(20 * self._scale), round(self._loading_image_rotation_angle * 16), 300 * 16)
 
         # Draw message text
         if self._current_message:
@@ -95,7 +93,7 @@ class CuraSplashScreen(QSplashScreen):
             pen.setColor(QColor(255, 255, 255, 255))
             painter.setPen(pen)
             painter.setFont(font)
-            painter.drawText(100, 128, 170, 64,
+            painter.drawText(70, 320, 170, 24,
                              Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter | Qt.TextFlag.TextWordWrap,
                              self._current_message)
 

plugins/3MFReader/WorkspaceDialog.qml

@@ -17,8 +17,7 @@ UM.Dialog
     minimumWidth: UM.Theme.getSize("popup_dialog").width
     minimumHeight: UM.Theme.getSize("popup_dialog").height
     width: minimumWidth
-    height: Math.max(dialogSummaryItem.height + 2 * buttonsItem.height, minimumHeight) // 2 * button height to also have some extra space around the button relative to the button size
-
+    
     property int comboboxHeight: UM.Theme.getSize("default_margin").height
 
     onClosing: manager.notifyClosed()
@@ -67,7 +66,7 @@ UM.Dialog
             Column
             {
                 width: parent.width
-                height: cildrenRect.height
+                height: childrenRect.height
 
                 UM.Label
                 {
@@ -149,7 +148,7 @@ UM.Dialog
                 Column
                 {
                     width: parent.width
-                    height: cildrenRect.height
+                    height: childrenRect.height
 
                     UM.Label
                     {
@@ -225,7 +224,7 @@ UM.Dialog
                 Column
                 {
                     width: parent.width
-                    height: cildrenRect.height
+                    height: childrenRect.height
 
                     UM.Label
                     {
@@ -341,7 +340,7 @@ UM.Dialog
                 Column
                 {
                     width: parent.width
-                    height: cildrenRect.height
+                    height: childrenRect.height
                     Row
                     {
                         height: childrenRect.height
@@ -382,7 +381,7 @@ UM.Dialog
             Column
             {
                 width: parent.width
-                height: cildrenRect.height
+                height: childrenRect.height
 
                 UM.Label
                 {

resources/definitions/fdmprinter.def.json

@@ -758,6 +758,16 @@
                     "default_value": 10.0,
                     "settable_per_mesh": false,
                     "settable_per_extruder": true
+                },
+                "machine_scale_fan_speed_zero_to_one":
+                {
+                    "label": "Scale Fan Speed To 0-1",
+                    "description": "Scale the fan speed to be between 0 and 1 instead of between 0 and 256.",
+                    "type": "bool",
+                    "default_value": true,
+                    "settable_per_mesh": false,
+                    "settable_per_extruder": false,
+                    "settable_per_meshgroup": false
                 }
             }
         },
@@ -1211,8 +1221,6 @@
                     "unit": "mm",
                     "minimum_value_warning": ".5 * max(wall_line_width_0, wall_line_width_x)",
                     "maximum_value_warning": "min(wall_line_width_0, wall_line_width_x)",
-                    "minimum_value_warning_old": "(0.1 + 0.4 * machine_nozzle_size) if inset_direction == \"outside_in\" else 0.1 * machine_nozzle_size",
-                    "maximum_value_warning_old": "2 * machine_nozzle_size",
                     "default_value": 0.3,
                     "value": "machine_nozzle_size * .75",
                     "type": "float",
@@ -1239,7 +1247,6 @@
                                     "unit": "%",
                                     "default_value": 50,
                                     "value": "max(1, min(99, 100 * (2 * min_even_wall_line_width - wall_line_width_0) / wall_line_width_0))",
-                                    "value_explicit": "100 * (2 * min_even_wall_line_width - wall_line_width_0) / (wall_line_width_0 + wall_line_width_x - wall_line_width_0)",
                                     "minimum_value": "1",
                                     "maximum_value": "99"
                                 }
@@ -6454,8 +6461,10 @@
                     "description": "The maximum extrusion area deviation allowed when removing intermediate points from a straight line. An intermediate point may serve as width-changing point in a long straight line. Therefore, if it is removed, it will cause the line to have a uniform width and, as a result, lose (or gain) a bit of extrusion area. If you increase this you may notice slight under- (or over-) extrusion in between straight parallel walls, as more intermediate width-changing points will be allowed to be removed. Your print will be less accurate, but the g-code will be smaller.",
                     "type": "float",
                     "unit": "μm²",
-                    "default_value": 50000,
+                    "default_value": 2000,
                     "minimum_value": "0",
+                    "minimum_value_warning": "500",
+                    "maximum_value_warning": "50000",
                     "settable_per_mesh": true
                 }
             }

resources/definitions/ultimaker.def.json

@@ -62,9 +62,6 @@
         "speed_equalize_flow_width_factor": {
             "value": "110.0"
         },
-        "meshfix_maximum_extrusion_area_deviation": {
-            "value": "50000"
-        },
         "top_layers": {
             "value": "math.ceil(round(top_thickness / resolveOrValue('layer_height'), 4))"
         },