From ac0c0d0698d2c7823df88fb25ff10d8625c3d3c9 Mon Sep 17 00:00:00 2001 From: Jaime van Kessel Date: Tue, 23 Jun 2020 14:54:56 +0200 Subject: [PATCH] Let the error checker calculate the error values a bit more "on demand" Previously it would just re-try all settings, but this really isn't needed (since we have a setting relationship object that can tell us what settings depend on what). This won't speed things up in a worst case scenario (since that will still be "caluclate all the settings") but it will speed it up in most cases. Most setting changes now only trigger a calculation that takes <0.2 sec isntead of the 1.1 sec. Yes, those numbers seem big, but the error checking is already built in such a way that it spreads this out over multiple frames (so it's not actually freezing that time, but it is doing shit it shouldn't do!) CURA-7106 --- cura/Machines/MachineErrorChecker.py | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-) diff --git a/cura/Machines/MachineErrorChecker.py b/cura/Machines/MachineErrorChecker.py index bc9ef723d4..7a2c509dda 100644 --- a/cura/Machines/MachineErrorChecker.py +++ b/cura/Machines/MachineErrorChecker.py @@ -1,4 +1,4 @@ -# Copyright (c) 2018 Ultimaker B.V. +# Copyright (c) 2020 Ultimaker B.V. # Cura is released under the terms of the LGPLv3 or higher. import time @@ -14,6 +14,7 @@ from UM.Settings.Validator import ValidatorState import cura.CuraApplication + class MachineErrorChecker(QObject): """This class performs setting error checks for the currently active machine. @@ -50,6 +51,8 @@ class MachineErrorChecker(QObject): self._error_check_timer.setInterval(100) self._error_check_timer.setSingleShot(True) + self._keys_to_check = set() + def initialize(self) -> None: self._error_check_timer.timeout.connect(self._rescheduleCheck) @@ -103,6 +106,7 @@ class MachineErrorChecker(QObject): if property_name != "value": return + self._keys_to_check.add(key) self.startErrorCheck() def startErrorCheck(self, *args: Any) -> None: @@ -140,7 +144,10 @@ class MachineErrorChecker(QObject): # Populate the (stack, key) tuples to check self._stacks_and_keys_to_check = deque() for stack in global_stack.extruderList: - for key in stack.getAllKeys(): + if not self._keys_to_check: + self._keys_to_check = stack.getAllKeys() + + for key in self._keys_to_check: self._stacks_and_keys_to_check.append((stack, key)) self._application.callLater(self._checkStack) @@ -181,18 +188,25 @@ class MachineErrorChecker(QObject): validator = validator_type(key) validation_state = validator(stack) if validation_state in (ValidatorState.Exception, ValidatorState.MaximumError, ValidatorState.MinimumError, ValidatorState.Invalid): - # Finish - self._setResult(True) + # Since we don't know if any of the settings we didn't check is has an error value, store the list for the + # next check. + keys_to_recheck = {setting_key for stack, setting_key in self._stacks_and_keys_to_check} + keys_to_recheck.add(key) + self._setResult(True, keys_to_recheck = keys_to_recheck) return # Schedule the check for the next key self._application.callLater(self._checkStack) - def _setResult(self, result: bool) -> None: + def _setResult(self, result: bool, keys_to_recheck = None) -> None: if result != self._has_errors: self._has_errors = result self.hasErrorUpdated.emit() self._machine_manager.stacksValidationChanged.emit() + if keys_to_recheck is None: + self._keys_to_check = set() + else: + self._keys_to_check = keys_to_recheck self._need_to_check = False self._check_in_progress = False self.needToWaitForResultChanged.emit()