3D-printing/Cura
1
0
Fork 0
mirror of https://github.com/Ultimaker/Cura.git synced 2025-07-06 14:37:29 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Revert "Merge branch '4.7' of github.com:Ultimaker/Cura into 4.7"

Browse source 
This reverts commit 7f47f12bf0, reversing
changes made to dd42c87da7.
This commit is contained in:
Ghostkeeper 2020-08-20 16:01:46 +02:00
parent 2fe9ee2cf2
commit 28f4d8513d
No known key found for this signature in database
GPG key ID: D2A8871EE34EC59A
13 changed files with 149 additions and 274 deletions
Download patch file Download diff file Expand all files Collapse all files

120
plugins/3MFReader/WorkspaceDialog.py
View file

@ -1,6 +1,5 @@
# Copyright (c) 2020 Ultimaker B.V.
# Copyright (c) 2016 Ultimaker B.V.
# Cura is released under the terms of the LGPLv3 or higher.
from typing import List, Optional, Dict, cast
from PyQt5.QtCore import pyqtSignal, QObject, pyqtProperty, QCoreApplication
from UM.FlameProfiler import pyqtSlot
@ -8,15 +7,10 @@ from UM.PluginRegistry import PluginRegistry
from UM.Application import Application
from UM.i18n import i18nCatalog
from UM.Settings.ContainerRegistry import ContainerRegistry
from cura.Settings.GlobalStack import GlobalStack
from .UpdatableMachinesModel import UpdatableMachinesModel
import os
import threading
import time
from cura.CuraApplication import CuraApplication
i18n_catalog = i18nCatalog("cura")
@ -35,7 +29,6 @@ class WorkspaceDialog(QObject):
"quality_changes": self._default_strategy,
"definition_changes": self._default_strategy,
"material": self._default_strategy}
self._override_machine = None
self._visible = False
self.showDialogSignal.connect(self.__show)
@ -58,7 +51,6 @@ class WorkspaceDialog(QObject):
self._extruders = []
self._objects_on_plate = False
self._is_printer_group = False
self._updatable_machines_model = UpdatableMachinesModel(self)
machineConflictChanged = pyqtSignal()
qualityChangesConflictChanged = pyqtSignal()
@ -71,7 +63,6 @@ class WorkspaceDialog(QObject):
qualityTypeChanged = pyqtSignal()
intentNameChanged = pyqtSignal()
machineNameChanged = pyqtSignal()
updatableMachinesChanged = pyqtSignal()
materialLabelsChanged = pyqtSignal()
objectsOnPlateChanged = pyqtSignal()
numUserSettingsChanged = pyqtSignal()
@ -90,33 +81,33 @@ class WorkspaceDialog(QObject):
self.isPrinterGroupChanged.emit()
@pyqtProperty(str, notify=variantTypeChanged)
def variantType(self) -> str:
def variantType(self):
return self._variant_type
def setVariantType(self, variant_type: str) -> None:
def setVariantType(self, variant_type):
if self._variant_type != variant_type:
self._variant_type = variant_type
self.variantTypeChanged.emit()
@pyqtProperty(str, notify=machineTypeChanged)
def machineType(self) -> str:
def machineType(self):
return self._machine_type
def setMachineType(self, machine_type: str) -> None:
def setMachineType(self, machine_type):
self._machine_type = machine_type
self.machineTypeChanged.emit()
def setNumUserSettings(self, num_user_settings: int) -> None:
def setNumUserSettings(self, num_user_settings):
if self._num_user_settings != num_user_settings:
self._num_user_settings = num_user_settings
self.numVisibleSettingsChanged.emit()
@pyqtProperty(int, notify=numUserSettingsChanged)
def numUserSettings(self) -> int:
def numUserSettings(self):
return self._num_user_settings
@pyqtProperty(bool, notify=objectsOnPlateChanged)
def hasObjectsOnPlate(self) -> bool:
def hasObjectsOnPlate(self):
return self._objects_on_plate
def setHasObjectsOnPlate(self, objects_on_plate):
@ -125,10 +116,10 @@ class WorkspaceDialog(QObject):
self.objectsOnPlateChanged.emit()
@pyqtProperty("QVariantList", notify = materialLabelsChanged)
def materialLabels(self) -> List[str]:
def materialLabels(self):
return self._material_labels
def setMaterialLabels(self, material_labels: List[str]) -> None:
def setMaterialLabels(self, material_labels):
if self._material_labels != material_labels:
self._material_labels = material_labels
self.materialLabelsChanged.emit()
@ -143,44 +134,36 @@ class WorkspaceDialog(QObject):
self.extrudersChanged.emit()
@pyqtProperty(str, notify = machineNameChanged)
def machineName(self) -> str:
def machineName(self):
return self._machine_name
def setMachineName(self, machine_name: str) -> None:
def setMachineName(self, machine_name):
if self._machine_name != machine_name:
self._machine_name = machine_name
self.machineNameChanged.emit()
@pyqtProperty(QObject, notify = updatableMachinesChanged)
def updatableMachinesModel(self) -> UpdatableMachinesModel:
return cast(UpdatableMachinesModel, self._updatable_machines_model)
def setUpdatableMachines(self, updatable_machines: List[GlobalStack]) -> None:
self._updatable_machines_model.update(updatable_machines)
self.updatableMachinesChanged.emit()
@pyqtProperty(str, notify=qualityTypeChanged)
def qualityType(self) -> str:
def qualityType(self):
return self._quality_type
def setQualityType(self, quality_type: str) -> None:
def setQualityType(self, quality_type):
if self._quality_type != quality_type:
self._quality_type = quality_type
self.qualityTypeChanged.emit()
@pyqtProperty(int, notify=numSettingsOverridenByQualityChangesChanged)
def numSettingsOverridenByQualityChanges(self) -> int:
def numSettingsOverridenByQualityChanges(self):
return self._num_settings_overridden_by_quality_changes
def setNumSettingsOverriddenByQualityChanges(self, num_settings_overridden_by_quality_changes: int) -> None:
def setNumSettingsOverriddenByQualityChanges(self, num_settings_overridden_by_quality_changes):
self._num_settings_overridden_by_quality_changes = num_settings_overridden_by_quality_changes
self.numSettingsOverridenByQualityChangesChanged.emit()
@pyqtProperty(str, notify=qualityNameChanged)
def qualityName(self) -> str:
def qualityName(self):
return self._quality_name
def setQualityName(self, quality_name: str) -> None:
def setQualityName(self, quality_name):
if self._quality_name != quality_name:
self._quality_name = quality_name
self.qualityNameChanged.emit()
@ -195,87 +178,80 @@ class WorkspaceDialog(QObject):
self.intentNameChanged.emit()
@pyqtProperty(str, notify=activeModeChanged)
def activeMode(self) -> str:
def activeMode(self):
return self._active_mode
def setActiveMode(self, active_mode: int) -> None:
def setActiveMode(self, active_mode):
if active_mode == 0:
self._active_mode = i18n_catalog.i18nc("@title:tab", "Recommended")
else:
self._active_mode = i18n_catalog.i18nc("@title:tab", "Custom")
self.activeModeChanged.emit()
@pyqtProperty(bool, notify = hasVisibleSettingsFieldChanged)
def hasVisibleSettingsField(self) -> bool:
@pyqtProperty(int, notify = hasVisibleSettingsFieldChanged)
def hasVisibleSettingsField(self):
return self._has_visible_settings_field
def setHasVisibleSettingsField(self, has_visible_settings_field: bool) -> None:
def setHasVisibleSettingsField(self, has_visible_settings_field):
self._has_visible_settings_field = has_visible_settings_field
self.hasVisibleSettingsFieldChanged.emit()
@pyqtProperty(int, constant = True)
def totalNumberOfSettings(self) -> int:
def totalNumberOfSettings(self):
general_definition_containers = ContainerRegistry.getInstance().findDefinitionContainers(id = "fdmprinter")
if not general_definition_containers:
return 0
return len(general_definition_containers[0].getAllKeys())
@pyqtProperty(int, notify = numVisibleSettingsChanged)
def numVisibleSettings(self) -> int:
def numVisibleSettings(self):
return self._num_visible_settings
def setNumVisibleSettings(self, num_visible_settings: int) -> None:
def setNumVisibleSettings(self, num_visible_settings):
if self._num_visible_settings != num_visible_settings:
self._num_visible_settings = num_visible_settings
self.numVisibleSettingsChanged.emit()
@pyqtProperty(bool, notify = machineConflictChanged)
def machineConflict(self) -> bool:
def machineConflict(self):
return self._has_machine_conflict
@pyqtProperty(bool, notify=qualityChangesConflictChanged)
def qualityChangesConflict(self) -> bool:
def qualityChangesConflict(self):
return self._has_quality_changes_conflict
@pyqtProperty(bool, notify=materialConflictChanged)
def materialConflict(self) -> bool:
def materialConflict(self):
return self._has_material_conflict
@pyqtSlot(str, str)
def setResolveStrategy(self, key: str, strategy: Optional[str]) -> None:
def setResolveStrategy(self, key, strategy):
if key in self._result:
self._result[key] = strategy
def getMachineToOverride(self) -> str:
return self._override_machine
@pyqtSlot(str)
def setMachineToOverride(self, machine_name: str) -> None:
self._override_machine = machine_name
@pyqtSlot()
def closeBackend(self) -> None:
def closeBackend(self):
"""Close the backend: otherwise one could end up with "Slicing..."""
Application.getInstance().getBackend().close()
def setMaterialConflict(self, material_conflict: bool) -> None:
def setMaterialConflict(self, material_conflict):
if self._has_material_conflict != material_conflict:
self._has_material_conflict = material_conflict
self.materialConflictChanged.emit()
def setMachineConflict(self, machine_conflict: bool) -> None:
def setMachineConflict(self, machine_conflict):
if self._has_machine_conflict != machine_conflict:
self._has_machine_conflict = machine_conflict
self.machineConflictChanged.emit()
def setQualityChangesConflict(self, quality_changes_conflict: bool) -> None:
def setQualityChangesConflict(self, quality_changes_conflict):
if self._has_quality_changes_conflict != quality_changes_conflict:
self._has_quality_changes_conflict = quality_changes_conflict
self.qualityChangesConflictChanged.emit()
def getResult(self) -> Dict[str, Optional[str]]:
if "machine" in self._result and self.updatableMachinesModel.count <= 1:
def getResult(self):
if "machine" in self._result and not self._has_machine_conflict:
self._result["machine"] = None
if "quality_changes" in self._result and not self._has_quality_changes_conflict:
self._result["quality_changes"] = None
@ -291,13 +267,11 @@ class WorkspaceDialog(QObject):
return self._result
def _createViewFromQML(self) -> None:
three_mf_reader_path = PluginRegistry.getInstance().getPluginPath("3MFReader")
if three_mf_reader_path:
path = os.path.join(three_mf_reader_path, self._qml_url)
self._view = CuraApplication.getInstance().createQmlComponent(path, {"manager": self})
def _createViewFromQML(self):
path = os.path.join(PluginRegistry.getInstance().getPluginPath("3MFReader"), self._qml_url)
self._view = Application.getInstance().createQmlComponent(path, {"manager": self})
def show(self) -> None:
def show(self):
# Emit signal so the right thread actually shows the view.
if threading.current_thread() != threading.main_thread():
self._lock.acquire()
@ -310,7 +284,7 @@ class WorkspaceDialog(QObject):
self.showDialogSignal.emit()
@pyqtSlot()
def notifyClosed(self) -> None:
def notifyClosed(self):
"""Used to notify the dialog so the lock can be released."""
self._result = {} # The result should be cleared before hide, because after it is released the main thread lock
@ -320,7 +294,7 @@ class WorkspaceDialog(QObject):
except:
pass
def hide(self) -> None:
def hide(self):
self._visible = False
self._view.hide()
try:
@ -329,7 +303,7 @@ class WorkspaceDialog(QObject):
pass
@pyqtSlot(bool)
def _onVisibilityChanged(self, visible: bool) -> None:
def _onVisibilityChanged(self, visible):
if not visible:
try:
self._lock.release()
@ -337,17 +311,17 @@ class WorkspaceDialog(QObject):
pass
@pyqtSlot()
def onOkButtonClicked(self) -> None:
def onOkButtonClicked(self):
self._view.hide()
self.hide()
@pyqtSlot()
def onCancelButtonClicked(self) -> None:
def onCancelButtonClicked(self):
self._result = {}
self._view.hide()
self.hide()
def waitForClose(self) -> None:
def waitForClose(self):
"""Block thread until the dialog is closed."""
if self._visible:
@ -360,7 +334,7 @@ class WorkspaceDialog(QObject):
time.sleep(1 / 50)
QCoreApplication.processEvents() # Ensure that the GUI does not freeze.
def __show(self) -> None:
def __show(self):
if self._view is None:
self._createViewFromQML()
if self._view: