def test_roundtrip_stack(tmpdir, process_count, loaded_container_registry):
definition = loaded_container_registry.findDefinitionContainers(
id="multiple_settings")[0]
instances = loaded_container_registry.findInstanceContainers(
id="setting_values")[0]
container_stack = ContainerStack("test_stack")
container_stack.setName("Test Container Stack")
container_stack.setMetaDataEntry("test", "test")
container_stack.addContainer(definition)
container_stack.addContainer(instances)
temp_file = tmpdir.join("container_stack_test")
mp_run(process_count, write_data, temp_file, container_stack)
assert len(list(tmpdir.listdir())) == 1
results = mp_run(process_count, read_data, temp_file)
for result in results:
deserialized_stack = ContainerStack("test_stack")
deserialized_stack.deserialize(result)
assert deserialized_stack.getName() == container_stack.getName()
assert deserialized_stack.getMetaData() == container_stack.getMetaData(
)
assert deserialized_stack.getBottom() == container_stack.getBottom()
assert deserialized_stack.getTop() == container_stack.getTop()
class SettingOverrideDecorator(SceneNodeDecorator):
def __init__(self):
super().__init__()
self._stack = ContainerStack(stack_id = id(self))
self._stack.setDirty(False) # This stack does not need to be saved.
self._instance = InstanceContainer(container_id = "SettingOverrideInstanceContainer")
self._stack.addContainer(self._instance)
self._stack.propertyChanged.connect(self._onSettingChanged)
ContainerRegistry.getInstance().addContainer(self._stack)
Application.getInstance().globalContainerStackChanged.connect(self._onGlobalContainerStackChanged)
self._onGlobalContainerStackChanged()
def __deepcopy__(self, memo):
## Create a fresh decorator object
deep_copy = SettingOverrideDecorator()
## Copy the instance
deep_copy._instance = copy.deepcopy(self._instance, memo)
## Set the copied instance as the first (and only) instance container of the stack.
deep_copy._stack.replaceContainer(0, deep_copy._instance)
return deep_copy
def _onSettingChanged(self, instance, property):
if property == "value": # Only reslice if the value has changed.
Application.getInstance().getBackend().forceSlice()
def _onGlobalContainerStackChanged(self):
## Ensure that the next stack is always the global stack.
self._stack.setNextStack(Application.getInstance().getGlobalContainerStack())
def getStack(self):
return self._stack
def test_roundtrip_stack(tmpdir, process_count, loaded_container_registry):
definition = loaded_container_registry.findDefinitionContainers(id = "multiple_settings")[0]
instances = loaded_container_registry.findInstanceContainers(id = "setting_values")[0]
container_stack = ContainerStack("test_stack")
container_stack.setName("Test Container Stack")
container_stack.addMetaDataEntry("test", "test")
container_stack.addContainer(definition)
container_stack.addContainer(instances)
temp_file = tmpdir.join("container_stack_test")
mp_run(process_count, write_data, temp_file, container_stack)
assert len(list(tmpdir.listdir())) == 1
results = mp_run(process_count, read_data, temp_file)
for result in results:
deserialized_stack = ContainerStack("test_stack")
deserialized_stack.deserialize(result)
assert deserialized_stack.getName() == container_stack.getName()
assert deserialized_stack.getMetaData() == container_stack.getMetaData()
assert deserialized_stack.getBottom() == container_stack.getBottom()
assert deserialized_stack.getTop() == container_stack.getTop()
class CustomStackProxy(QObject):
def __init__(self, parent: QObject = None) -> None:
super().__init__(parent)
self._container_ids = [] # type: List[str]
self._stack = ContainerStack("CustomStack" + str(id(self)))
self._stack_id = self._stack.id
self._stack.setDirty(False) # never save this stack
Application.getInstance().getContainerRegistry().addContainer(
self._stack)
@pyqtProperty(str, constant=True)
def stackId(self):
return self._stack_id
## Set the containerIds property.
def setContainerIds(self, container_ids: List[str]):
if container_ids == self._container_ids:
return
self._container_ids = container_ids
while (self._stack.getContainers()):
self._stack.removeContainer(0)
for container_id in container_ids:
containers = Application.getInstance().getContainerRegistry(
).findContainers(id=container_id)
if containers:
self._stack.addContainer(containers[0])
self._stack.setDirty(False) # never save this stack
self.containerIdsChanged.emit()
## Emitted when the containerIds property changes.
containerIdsChanged = pyqtSignal()
## The ID of the container we should query for property values.
@pyqtProperty("QVariantList",
fset=setContainerIds,
notify=containerIdsChanged)
def containerIds(self):
return self._container_ids
@pyqtSlot(str)
def removeInstanceFromTop(self, key):
self._stack.getTop().removeInstance(key)
self._stack.getTop().setDirty(True)
class SettingOverrideDecorator(SceneNodeDecorator):
def __init__(self):
super().__init__()
self._stack = ContainerStack(id = "SettingOverrideStack")
self._instance = InstanceContainer(id = "SettingOverrideInstanceContainer")
self._stack.addContainer(self._instance)
Application.getInstance().globalContainerStackChanged.connect(self._onGlobalContainerStackChanged)
self._onGlobalContainerStackChanged()
def _onGlobalContainerStackChanged(self):
## Ensure that the next stack is always the global stack.
self._stack.setNextStack(Application.getInstance().getGlobalContainerStack())
def getStack(self):
return self._stack
class SettingOverrideDecorator(SceneNodeDecorator):
def __init__(self):
super().__init__()
self._stack = ContainerStack(id="SettingOverrideStack")
self._instance = InstanceContainer(
id="SettingOverrideInstanceContainer")
self._stack.addContainer(self._instance)
Application.getInstance().globalContainerStackChanged.connect(
self._onGlobalContainerStackChanged)
self._onGlobalContainerStackChanged()
def _onGlobalContainerStackChanged(self):
## Ensure that the next stack is always the global stack.
self._stack.setNextStack(
Application.getInstance().getGlobalContainerStack())
def getStack(self):
return self._stack
class SettingOverrideDecorator(SceneNodeDecorator):
def __init__(self):
super().__init__()
self._stack = ContainerStack(stack_id=id(self))
self._stack.setDirty(False) # This stack does not need to be saved.
self._instance = InstanceContainer(
container_id="SettingOverrideInstanceContainer")
self._stack.addContainer(self._instance)
self._stack.propertyChanged.connect(self._onSettingChanged)
ContainerRegistry.getInstance().addContainer(self._stack)
Application.getInstance().globalContainerStackChanged.connect(
self._onGlobalContainerStackChanged)
self._onGlobalContainerStackChanged()
def __deepcopy__(self, memo):
## Create a fresh decorator object
deep_copy = SettingOverrideDecorator()
## Copy the instance
deep_copy._instance = copy.deepcopy(self._instance, memo)
## Set the copied instance as the first (and only) instance container of the stack.
deep_copy._stack.replaceContainer(0, deep_copy._instance)
return deep_copy
def _onSettingChanged(self, instance, property):
if property == "value": # Only reslice if the value has changed.
Application.getInstance().getBackend().forceSlice()
def _onGlobalContainerStackChanged(self):
## Ensure that the next stack is always the global stack.
self._stack.setNextStack(
Application.getInstance().getGlobalContainerStack())
def getStack(self):
return self._stack
class Script:
def __init__(self):
super().__init__()
self._settings = None
self._stack = None
setting_data = self.getSettingData()
self._stack = ContainerStack(stack_id=id(self))
self._stack.setDirty(False) # This stack does not need to be saved.
## Check if the definition of this script already exists. If not, add it to the registry.
if "key" in setting_data:
definitions = ContainerRegistry.getInstance().findDefinitionContainers(id = setting_data["key"])
if definitions:
# Definition was found
self._definition = definitions[0]
else:
self._definition = DefinitionContainer(setting_data["key"])
self._definition.deserialize(json.dumps(setting_data))
ContainerRegistry.getInstance().addContainer(self._definition)
self._stack.addContainer(self._definition)
self._instance = InstanceContainer(container_id="ScriptInstanceContainer")
self._instance.setDefinition(self._definition)
self._stack.addContainer(self._instance)
ContainerRegistry.getInstance().addContainer(self._stack)
settingsLoaded = Signal()
## Needs to return a dict that can be used to construct a settingcategory file.
# See the example script for an example.
# It follows the same style / guides as the Uranium settings.
def getSettingData(self):
raise NotImplementedError()
def getDefinitionId(self):
if self._stack:
return self._stack.getBottom().getId()
def getStackId(self):
if self._stack:
return self._stack.getId()
## Convenience function that retrieves value of a setting from the stack.
def getSettingValueByKey(self, key):
return self._stack.getProperty(key, "value")
## Convenience function that finds the value in a line of g-code.
# When requesting key = x from line "G1 X100" the value 100 is returned.
def getValue(self, line, key, default = None):
if not key in line or (';' in line and line.find(key) > line.find(';')):
return default
sub_part = line[line.find(key) + 1:]
m = re.search('^[0-9]+\.?[0-9]*', sub_part)
if m is None:
return default
try:
return float(m.group(0))
except:
return default
## This is called when the script is executed.
# It gets a list of g-code strings and needs to return a (modified) list.
def execute(self, data):
raise NotImplementedError()
def createExtruderTrain(self, extruder_definition: DefinitionContainerInterface, machine_definition: DefinitionContainerInterface,
position, machine_id: str) -> None:
# Cache some things.
container_registry = ContainerRegistry.getInstance()
machine_definition_id = Application.getInstance().getMachineManager().getQualityDefinitionId(machine_definition)
# Create a container stack for this extruder.
extruder_stack_id = container_registry.uniqueName(extruder_definition.getId())
container_stack = ContainerStack(extruder_stack_id)
container_stack.setName(extruder_definition.getName()) # Take over the display name to display the stack with.
container_stack.addMetaDataEntry("type", "extruder_train")
container_stack.addMetaDataEntry("machine", machine_id)
container_stack.addMetaDataEntry("position", position)
container_stack.addContainer(extruder_definition)
# Find the variant to use for this extruder.
variant = container_registry.findInstanceContainers(id = "empty_variant")[0]
if machine_definition.getMetaDataEntry("has_variants"):
# First add any variant. Later, overwrite with preference if the preference is valid.
variants = container_registry.findInstanceContainers(definition = machine_definition_id, type = "variant")
if len(variants) >= 1:
variant = variants[0]
preferred_variant_id = machine_definition.getMetaDataEntry("preferred_variant")
if preferred_variant_id:
preferred_variants = container_registry.findInstanceContainers(id = preferred_variant_id, definition = machine_definition_id, type = "variant")
if len(preferred_variants) >= 1:
variant = preferred_variants[0]
else:
Logger.log("w", "The preferred variant \"%s\" of machine %s doesn't exist or is not a variant profile.", preferred_variant_id, machine_id)
# And leave it at the default variant.
container_stack.addContainer(variant)
# Find a material to use for this variant.
material = container_registry.findInstanceContainers(id = "empty_material")[0]
if machine_definition.getMetaDataEntry("has_materials"):
# First add any material. Later, overwrite with preference if the preference is valid.
machine_has_variant_materials = machine_definition.getMetaDataEntry("has_variant_materials", default = False)
if machine_has_variant_materials or machine_has_variant_materials == "True":
materials = container_registry.findInstanceContainers(type = "material", definition = machine_definition_id, variant = variant.getId())
else:
materials = container_registry.findInstanceContainers(type = "material", definition = machine_definition_id)
if len(materials) >= 1:
material = materials[0]
preferred_material_id = machine_definition.getMetaDataEntry("preferred_material")
if preferred_material_id:
global_stack = ContainerRegistry.getInstance().findContainerStacks(id = machine_id)
if global_stack:
approximate_material_diameter = str(round(global_stack[0].getProperty("material_diameter", "value")))
else:
approximate_material_diameter = str(round(machine_definition.getProperty("material_diameter", "value")))
search_criteria = { "type": "material", "id": preferred_material_id, "approximate_diameter": approximate_material_diameter}
if machine_definition.getMetaDataEntry("has_machine_materials"):
search_criteria["definition"] = machine_definition_id
if machine_definition.getMetaDataEntry("has_variants") and variant:
search_criteria["variant"] = variant.id
else:
search_criteria["definition"] = "fdmprinter"
preferred_materials = container_registry.findInstanceContainers(**search_criteria)
if len(preferred_materials) >= 1:
# In some cases we get multiple materials. In that case, prefer materials that are marked as read only.
read_only_preferred_materials = [preferred_material for preferred_material in preferred_materials if preferred_material.isReadOnly()]
if len(read_only_preferred_materials) >= 1:
material = read_only_preferred_materials[0]
else:
material = preferred_materials[0]
else:
Logger.log("w", "The preferred material \"%s\" of machine %s doesn't exist or is not a material profile.", preferred_material_id, machine_id)
# And leave it at the default material.
container_stack.addContainer(material)
# Find a quality to use for this extruder.
quality = container_registry.getEmptyInstanceContainer()
search_criteria = { "type": "quality" }
if machine_definition.getMetaDataEntry("has_machine_quality"):
search_criteria["definition"] = machine_definition_id
if machine_definition.getMetaDataEntry("has_materials") and material:
search_criteria["material"] = material.id
else:
search_criteria["definition"] = "fdmprinter"
preferred_quality = machine_definition.getMetaDataEntry("preferred_quality")
if preferred_quality:
search_criteria["id"] = preferred_quality
containers = ContainerRegistry.getInstance().findInstanceContainers(**search_criteria)
if not containers and preferred_quality:
Logger.log("w", "The preferred quality \"%s\" of machine %s doesn't exist or is not a quality profile.", preferred_quality, machine_id)
search_criteria.pop("id", None)
containers = ContainerRegistry.getInstance().findInstanceContainers(**search_criteria)
if containers:
quality = containers[0]
container_stack.addContainer(quality)
empty_quality_changes = container_registry.findInstanceContainers(id = "empty_quality_changes")[0]
container_stack.addContainer(empty_quality_changes)
user_profile = container_registry.findInstanceContainers(type = "user", extruder = extruder_stack_id)
if user_profile: # There was already a user profile, loaded from settings.
user_profile = user_profile[0]
else:
user_profile = InstanceContainer(extruder_stack_id + "_current_settings") # Add an empty user profile.
user_profile.addMetaDataEntry("type", "user")
user_profile.addMetaDataEntry("extruder", extruder_stack_id)
from cura.CuraApplication import CuraApplication
user_profile.addMetaDataEntry("setting_version", CuraApplication.SettingVersion)
user_profile.setDefinition(machine_definition)
container_registry.addContainer(user_profile)
container_stack.addContainer(user_profile)
# regardless of what the next stack is, we have to set it again, because of signal routing.
container_stack.setNextStack(Application.getInstance().getGlobalContainerStack())
container_registry.addContainer(container_stack)
class Script:
def __init__(self) -> None:
super().__init__()
self._stack = None # type: Optional[ContainerStack]
self._definition = None # type: Optional[DefinitionContainerInterface]
self._instance = None # type: Optional[InstanceContainer]
def initialize(self) -> None:
setting_data = self.getSettingData()
self._stack = ContainerStack(stack_id=str(id(self)))
self._stack.setDirty(False) # This stack does not need to be saved.
## Check if the definition of this script already exists. If not, add it to the registry.
if "key" in setting_data:
definitions = ContainerRegistry.getInstance().findDefinitionContainers(id=setting_data["key"])
if definitions:
# Definition was found
self._definition = definitions[0]
else:
self._definition = DefinitionContainer(setting_data["key"])
try:
self._definition.deserialize(json.dumps(setting_data))
ContainerRegistry.getInstance().addContainer(self._definition)
except ContainerFormatError:
self._definition = None
return
if self._definition is None:
return
self._stack.addContainer(self._definition)
self._instance = InstanceContainer(container_id="ScriptInstanceContainer")
self._instance.setDefinition(self._definition.getId())
self._instance.setMetaDataEntry("setting_version",
self._definition.getMetaDataEntry("setting_version", default=0))
self._stack.addContainer(self._instance)
self._stack.propertyChanged.connect(self._onPropertyChanged)
ContainerRegistry.getInstance().addContainer(self._stack)
settingsLoaded = Signal()
valueChanged = Signal() # Signal emitted whenever a value of a setting is changed
def _onPropertyChanged(self, key: str, property_name: str) -> None:
if property_name == "value":
self.valueChanged.emit()
# Property changed: trigger reslice
# To do this we use the global container stack propertyChanged.
# Re-slicing is necessary for setting changes in this plugin, because the changes
# are applied only once per "fresh" gcode
global_container_stack = Application.getInstance().getGlobalContainerStack()
if global_container_stack is not None:
global_container_stack.propertyChanged.emit(key, property_name)
## Needs to return a dict that can be used to construct a settingcategory file.
# See the example script for an example.
# It follows the same style / guides as the Uranium settings.
# Scripts can either override getSettingData directly, or use getSettingDataString
# to return a string that will be parsed as json. The latter has the benefit over
# returning a dict in that the order of settings is maintained.
def getSettingData(self) -> Dict[str, Any]:
setting_data_as_string = self.getSettingDataString()
setting_data = json.loads(setting_data_as_string, object_pairs_hook = collections.OrderedDict)
return setting_data
def getSettingDataString(self) -> str:
raise NotImplementedError()
def getDefinitionId(self) -> Optional[str]:
if self._stack:
bottom = self._stack.getBottom()
if bottom is not None:
return bottom.getId()
return None
def getStackId(self) -> Optional[str]:
if self._stack:
return self._stack.getId()
return None
## Convenience function that retrieves value of a setting from the stack.
def getSettingValueByKey(self, key: str) -> Any:
if self._stack is not None:
return self._stack.getProperty(key, "value")
return None
## Convenience function that finds the value in a line of g-code.
# When requesting key = x from line "G1 X100" the value 100 is returned.
def getValue(self, line: str, key: str, default = None) -> Any:
if not key in line or (';' in line and line.find(key) > line.find(';')):
return default
sub_part = line[line.find(key) + 1:]
m = re.search('^-?[0-9]+\.?[0-9]*', sub_part)
if m is None:
return default
try:
return int(m.group(0))
except ValueError: #Not an integer.
try:
return float(m.group(0))
except ValueError: #Not a number at all.
return default
## Convenience function to produce a line of g-code.
#
# You can put in an original g-code line and it'll re-use all the values
# in that line.
# All other keyword parameters are put in the result in g-code's format.
# For instance, if you put ``G=1`` in the parameters, it will output
# ``G1``. If you put ``G=1, X=100`` in the parameters, it will output
# ``G1 X100``. The parameters G and M will always be put first. The
# parameters T and S will be put second (or first if there is no G or M).
# The rest of the parameters will be put in arbitrary order.
# \param line The original g-code line that must be modified. If not
# provided, an entirely new g-code line will be produced.
# \return A line of g-code with the desired parameters filled in.
def putValue(self, line: str = "", **kwargs) -> str:
#Strip the comment.
comment = ""
if ";" in line:
comment = line[line.find(";"):]
line = line[:line.find(";")] #Strip the comment.
#Parse the original g-code line.
for part in line.split(" "):
if part == "":
continue
parameter = part[0]
if parameter in kwargs:
continue #Skip this one. The user-provided parameter overwrites the one in the line.
value = part[1:]
kwargs[parameter] = value
#Write the new g-code line.
result = ""
priority_parameters = ["G", "M", "T", "S", "F", "X", "Y", "Z", "E"] #First some parameters that get priority. In order of priority!
for priority_key in priority_parameters:
if priority_key in kwargs:
if result != "":
result += " "
result += priority_key + str(kwargs[priority_key])
del kwargs[priority_key]
for key, value in kwargs.items():
if result != "":
result += " "
result += key + str(value)
#Put the comment back in.
if comment != "":
if result != "":
result += " "
result += ";" + comment
return result
## This is called when the script is executed.
# It gets a list of g-code strings and needs to return a (modified) list.
def execute(self, data: List[str]) -> List[str]:
raise NotImplementedError()
class SettingOverrideDecorator(SceneNodeDecorator):
## Event indicating that the user selected a different extruder.
activeExtruderChanged = Signal()
def __init__(self):
super().__init__()
self._stack = ContainerStack(stack_id = id(self))
self._stack.setDirty(False) # This stack does not need to be saved.
self._instance = InstanceContainer(container_id = "SettingOverrideInstanceContainer")
self._stack.addContainer(self._instance)
if cura.Settings.ExtruderManager.getInstance().extruderCount > 1:
self._extruder_stack = cura.Settings.ExtruderManager.getInstance().getExtruderStack(0).getId()
else:
self._extruder_stack = None
self._stack.propertyChanged.connect(self._onSettingChanged)
ContainerRegistry.getInstance().addContainer(self._stack)
Application.getInstance().globalContainerStackChanged.connect(self._updateNextStack)
self.activeExtruderChanged.connect(self._updateNextStack)
self._updateNextStack()
def __deepcopy__(self, memo):
## Create a fresh decorator object
deep_copy = SettingOverrideDecorator()
## Copy the instance
deep_copy._instance = copy.deepcopy(self._instance, memo)
# Properly set the right extruder on the copy
deep_copy.setActiveExtruder(self._extruder_stack)
## Set the copied instance as the first (and only) instance container of the stack.
deep_copy._stack.replaceContainer(0, deep_copy._instance)
return deep_copy
## Gets the currently active extruder to print this object with.
#
# \return An extruder's container stack.
def getActiveExtruder(self):
return self._extruder_stack
## Gets the currently active extruders position
#
# \return An extruder's position, or None if no position info is available.
def getActiveExtruderPosition(self):
containers = ContainerRegistry.getInstance().findContainers(id = self.getActiveExtruder())
if containers:
container_stack = containers[0]
return container_stack.getMetaDataEntry("position", default=None)
def _onSettingChanged(self, instance, property_name): # Reminder: 'property' is a built-in function
if property_name == "value": # Only reslice if the value has changed.
Application.getInstance().getBackend().forceSlice()
## Makes sure that the stack upon which the container stack is placed is
# kept up to date.
def _updateNextStack(self):
if self._extruder_stack:
extruder_stack = ContainerRegistry.getInstance().findContainerStacks(id = self._extruder_stack)
if extruder_stack:
if self._stack.getNextStack():
old_extruder_stack_id = self._stack.getNextStack().getId()
else:
old_extruder_stack_id = ""
self._stack.setNextStack(extruder_stack[0])
if self._stack.getNextStack().getId() != old_extruder_stack_id: #Only reslice if the extruder changed.
Application.getInstance().getBackend().forceSlice()
else:
UM.Logger.log("e", "Extruder stack %s below per-object settings does not exist.", self._extruder_stack)
else:
self._stack.setNextStack(Application.getInstance().getGlobalContainerStack())
## Changes the extruder with which to print this node.
#
# \param extruder_stack_id The new extruder stack to print with.
def setActiveExtruder(self, extruder_stack_id):
self._extruder_stack = extruder_stack_id
self._updateNextStack()
self.activeExtruderChanged.emit()
def getStack(self):
return self._stack
class Script:
def __init__(self):
super().__init__()
self._settings = None
self._stack = None
setting_data = self.getSettingData()
self._stack = ContainerStack(stack_id=str(id(self)))
self._stack.setDirty(False) # This stack does not need to be saved.
## Check if the definition of this script already exists. If not, add it to the registry.
if "key" in setting_data:
definitions = ContainerRegistry.getInstance(
).findDefinitionContainers(id=setting_data["key"])
if definitions:
# Definition was found
self._definition = definitions[0]
else:
self._definition = DefinitionContainer(setting_data["key"])
try:
self._definition.deserialize(json.dumps(setting_data))
ContainerRegistry.getInstance().addContainer(
self._definition)
except ContainerFormatError:
self._definition = None
return
self._stack.addContainer(self._definition)
self._instance = InstanceContainer(
container_id="ScriptInstanceContainer")
self._instance.setDefinition(self._definition.getId())
self._instance.addMetaDataEntry(
"setting_version",
self._definition.getMetaDataEntry("setting_version", default=0))
self._stack.addContainer(self._instance)
self._stack.propertyChanged.connect(self._onPropertyChanged)
ContainerRegistry.getInstance().addContainer(self._stack)
settingsLoaded = Signal()
valueChanged = Signal(
) # Signal emitted whenever a value of a setting is changed
def _onPropertyChanged(self, key, property_name):
if property_name == "value":
self.valueChanged.emit()
# Property changed: trigger reslice
# To do this we use the global container stack propertyChanged.
# Reslicing is necessary for setting changes in this plugin, because the changes
# are applied only once per "fresh" gcode
global_container_stack = Application.getInstance(
).getGlobalContainerStack()
global_container_stack.propertyChanged.emit(key, property_name)
## Needs to return a dict that can be used to construct a settingcategory file.
# See the example script for an example.
# It follows the same style / guides as the Uranium settings.
# Scripts can either override getSettingData directly, or use getSettingDataString
# to return a string that will be parsed as json. The latter has the benefit over
# returning a dict in that the order of settings is maintained.
def getSettingData(self):
setting_data = self.getSettingDataString()
if type(setting_data) == str:
setting_data = json.loads(
setting_data, object_pairs_hook=collections.OrderedDict)
return setting_data
def getSettingDataString(self):
raise NotImplementedError()
def getDefinitionId(self):
if self._stack:
return self._stack.getBottom().getId()
def getStackId(self):
if self._stack:
return self._stack.getId()
## Convenience function that retrieves value of a setting from the stack.
def getSettingValueByKey(self, key):
return self._stack.getProperty(key, "value")
## Convenience function that finds the value in a line of g-code.
# When requesting key = x from line "G1 X100" the value 100 is returned.
def getValue(self, line, key, default=None):
if not key in line or (';' in line
and line.find(key) > line.find(';')):
return default
sub_part = line[line.find(key) + 1:]
m = re.search('^-?[0-9]+\.?[0-9]*', sub_part)
if m is None:
return default
try:
return float(m.group(0))
except:
return default
## Convenience function to produce a line of g-code.
#
# You can put in an original g-code line and it'll re-use all the values
# in that line.
# All other keyword parameters are put in the result in g-code's format.
# For instance, if you put ``G=1`` in the parameters, it will output
# ``G1``. If you put ``G=1, X=100`` in the parameters, it will output
# ``G1 X100``. The parameters G and M will always be put first. The
# parameters T and S will be put second (or first if there is no G or M).
# The rest of the parameters will be put in arbitrary order.
# \param line The original g-code line that must be modified. If not
# provided, an entirely new g-code line will be produced.
# \return A line of g-code with the desired parameters filled in.
def putValue(self, line="", **kwargs):
#Strip the comment.
comment = ""
if ";" in line:
comment = line[line.find(";"):]
line = line[:line.find(";")] #Strip the comment.
#Parse the original g-code line.
for part in line.split(" "):
if part == "":
continue
parameter = part[0]
if parameter in kwargs:
continue #Skip this one. The user-provided parameter overwrites the one in the line.
value = part[1:]
kwargs[parameter] = value
#Write the new g-code line.
result = ""
priority_parameters = [
"G", "M", "T", "S", "F", "X", "Y", "Z", "E"
] #First some parameters that get priority. In order of priority!
for priority_key in priority_parameters:
if priority_key in kwargs:
if result != "":
result += " "
result += priority_key + str(kwargs[priority_key])
del kwargs[priority_key]
for key, value in kwargs.items():
if result != "":
result += " "
result += key + str(value)
#Put the comment back in.
if comment != "":
if result != "":
result += " "
result += ";" + comment
return result
## This is called when the script is executed.
# It gets a list of g-code strings and needs to return a (modified) list.
def execute(self, data):
raise NotImplementedError()
class SettingOverrideDecorator(SceneNodeDecorator):
## Event indicating that the user selected a different extruder.
activeExtruderChanged = Signal()
def __init__(self):
super().__init__()
self._stack = ContainerStack(stack_id=id(self))
self._stack.setDirty(False) # This stack does not need to be saved.
self._instance = InstanceContainer(
container_id="SettingOverrideInstanceContainer")
self._stack.addContainer(self._instance)
if ExtruderManager.getInstance().extruderCount > 1:
self._extruder_stack = ExtruderManager.getInstance(
).getExtruderStack(0).getId()
else:
self._extruder_stack = None
self._stack.propertyChanged.connect(self._onSettingChanged)
ContainerRegistry.getInstance().addContainer(self._stack)
Application.getInstance().globalContainerStackChanged.connect(
self._updateNextStack)
self.activeExtruderChanged.connect(self._updateNextStack)
self._updateNextStack()
def __deepcopy__(self, memo):
## Create a fresh decorator object
deep_copy = SettingOverrideDecorator()
## Copy the instance
deep_copy._instance = copy.deepcopy(self._instance, memo)
# Properly set the right extruder on the copy
deep_copy.setActiveExtruder(self._extruder_stack)
## Set the copied instance as the first (and only) instance container of the stack.
deep_copy._stack.replaceContainer(0, deep_copy._instance)
return deep_copy
## Gets the currently active extruder to print this object with.
#
# \return An extruder's container stack.
def getActiveExtruder(self):
return self._extruder_stack
## Gets the signal that emits if the active extruder changed.
#
# This can then be accessed via a decorator.
def getActiveExtruderChangedSignal(self):
return self.activeExtruderChanged
## Gets the currently active extruders position
#
# \return An extruder's position, or None if no position info is available.
def getActiveExtruderPosition(self):
containers = ContainerRegistry.getInstance().findContainers(
id=self.getActiveExtruder())
if containers:
container_stack = containers[0]
return container_stack.getMetaDataEntry("position", default=None)
def _onSettingChanged(
self, instance,
property_name): # Reminder: 'property' is a built-in function
if property_name == "value": # Only reslice if the value has changed.
Application.getInstance().getBackend().forceSlice()
## Makes sure that the stack upon which the container stack is placed is
# kept up to date.
def _updateNextStack(self):
if self._extruder_stack:
extruder_stack = ContainerRegistry.getInstance(
).findContainerStacks(id=self._extruder_stack)
if extruder_stack:
if self._stack.getNextStack():
old_extruder_stack_id = self._stack.getNextStack().getId()
else:
old_extruder_stack_id = ""
self._stack.setNextStack(extruder_stack[0])
if self._stack.getNextStack().getId(
) != old_extruder_stack_id: #Only reslice if the extruder changed.
Application.getInstance().getBackend().forceSlice()
else:
UM.Logger.log(
"e",
"Extruder stack %s below per-object settings does not exist.",
self._extruder_stack)
else:
self._stack.setNextStack(
Application.getInstance().getGlobalContainerStack())
## Changes the extruder with which to print this node.
#
# \param extruder_stack_id The new extruder stack to print with.
def setActiveExtruder(self, extruder_stack_id):
self._extruder_stack = extruder_stack_id
self._updateNextStack()
self.activeExtruderChanged.emit()
def getStack(self):
return self._stack
def test_valueChanges(container_registry):
setting_property_provider = SettingPropertyProvider()
# First create the basics; A container stack that will hold 2 instance containers and a single definition container
container_stack = ContainerStack("test!")
instance_container = InstanceContainer("data")
second_instance_container = InstanceContainer("data2")
definition_container = DefinitionContainer("foo")
# Create a setting definition for our one and only setting!
setting_definition = SettingDefinition("test_setting")
setting_definition._deserialize_dict({"value": 10, "label": "blorp", "type": "float", "description": "nah", "maximum_value": 23, "maximum_value_warning": 21})
definition_container.addDefinition(setting_definition)
# Make a single setting instance for our one and only setting.
setting_instance = SettingInstance(setting_definition, instance_container)
setting_instance.setProperty("value", 20)
setting_instance.setProperty("enabled", False)
instance_container.addInstance(setting_instance)
# Make a setting instance that lives in our second instance_container
setting_instance2 = SettingInstance(setting_definition, second_instance_container)
second_instance_container.addInstance(setting_instance2)
# Now that both containers are done, actually add them.
container_stack.addContainer(definition_container)
container_stack.addContainer(second_instance_container)
container_stack.addContainer(instance_container)
setting_property_provider.setContainerStack(container_stack)
setting_property_provider.setKey("test_setting")
assert setting_property_provider.getPropertyValue("value", 0) == 20
setting_property_provider.setWatchedProperties(["enabled", "value", "validationState"])
assert setting_property_provider.properties.value("enabled") == "False"
assert setting_property_provider.properties.value("value") == "20"
# Validator state is a special property that gets added based on the type and the value
assert setting_property_provider.properties.value("validationState") == str(ValidatorState.Valid)
# Set the property value to something that will trigger a warning
setting_property_provider.setPropertyValue("value", 22)
assert setting_property_provider.properties.value("validationState") == str(ValidatorState.MaximumWarning)
assert setting_property_provider.getPropertyValue("value", 0) == 22
# The setting doesn't exist in our second instance container, so this should be None
assert setting_property_provider.getPropertyValue("value", 1) is None
# Set the property value to something that will trigger an error
setting_property_provider.setPropertyValue("value", 25)
# The Qtimer that we use to prevent flooding doesn't work in tests, so tickle the change manually.
setting_property_provider._update()
assert setting_property_provider.properties.value("validationState") == str(ValidatorState.MaximumError)
# We now ask for the second instance container to be targeted
setting_property_provider.setStoreIndex(1)
assert setting_property_provider.storeIndex == 1
setting_property_provider.setPropertyValue("value", 2)
setting_property_provider._update()
# So now we should see a change in that instance container
assert setting_property_provider.getPropertyValue("value", 1) == 2
# But not if we ask the provider, because the container above it still has a 25 as value!
assert setting_property_provider.getPropertyValue("value", 0) == 25
assert setting_property_provider.stackLevels == [0, 1, 2]
# We're asking for an index that doesn't exist.
assert setting_property_provider.getPropertyValue("value", 2000) is None
# The value is used, so the property must be true
assert setting_property_provider.isValueUsed
# Try to remove the setting from the container
setting_property_provider.removeFromContainer(0)
assert setting_property_provider.getPropertyValue("value", 0) is None
# Ensure that a weird index doesn't break
setting_property_provider.removeFromContainer(90001)
def createExtruderTrain(self, extruder_definition: DefinitionContainerInterface, machine_definition: DefinitionContainerInterface,
position, machine_id: str) -> None:
# Cache some things.
container_registry = ContainerRegistry.getInstance()
machine_definition_id = Application.getInstance().getMachineManager().getQualityDefinitionId(machine_definition)
# Create a container stack for this extruder.
extruder_stack_id = container_registry.uniqueName(extruder_definition.getId())
container_stack = ContainerStack(extruder_stack_id)
container_stack.setName(extruder_definition.getName()) # Take over the display name to display the stack with.
container_stack.addMetaDataEntry("type", "extruder_train")
container_stack.addMetaDataEntry("machine", machine_id)
container_stack.addMetaDataEntry("position", position)
container_stack.addContainer(extruder_definition)
# Find the variant to use for this extruder.
variant = container_registry.findInstanceContainers(id = "empty_variant")[0]
if machine_definition.getMetaDataEntry("has_variants"):
# First add any variant. Later, overwrite with preference if the preference is valid.
variants = container_registry.findInstanceContainers(definition = machine_definition_id, type = "variant")
if len(variants) >= 1:
variant = variants[0]
preferred_variant_id = machine_definition.getMetaDataEntry("preferred_variant")
if preferred_variant_id:
preferred_variants = container_registry.findInstanceContainers(id = preferred_variant_id, definition = machine_definition_id, type = "variant")
if len(preferred_variants) >= 1:
variant = preferred_variants[0]
else:
Logger.log("w", "The preferred variant \"%s\" of machine %s doesn't exist or is not a variant profile.", preferred_variant_id, machine_id)
# And leave it at the default variant.
container_stack.addContainer(variant)
# Find a material to use for this variant.
material = container_registry.findInstanceContainers(id = "empty_material")[0]
if machine_definition.getMetaDataEntry("has_materials"):
# First add any material. Later, overwrite with preference if the preference is valid.
machine_has_variant_materials = machine_definition.getMetaDataEntry("has_variant_materials", default = False)
if machine_has_variant_materials or machine_has_variant_materials == "True":
materials = container_registry.findInstanceContainers(type = "material", definition = machine_definition_id, variant = variant.getId())
else:
materials = container_registry.findInstanceContainers(type = "material", definition = machine_definition_id)
if len(materials) >= 1:
material = materials[0]
preferred_material_id = machine_definition.getMetaDataEntry("preferred_material")
if preferred_material_id:
global_stack = ContainerRegistry.getInstance().findContainerStacks(id = machine_id)
if global_stack:
approximate_material_diameter = str(round(global_stack[0].getProperty("material_diameter", "value")))
else:
approximate_material_diameter = str(round(machine_definition.getProperty("material_diameter", "value")))
search_criteria = { "type": "material", "id": preferred_material_id, "approximate_diameter": approximate_material_diameter}
if machine_definition.getMetaDataEntry("has_machine_materials"):
search_criteria["definition"] = machine_definition_id
if machine_definition.getMetaDataEntry("has_variants") and variant:
search_criteria["variant"] = variant.id
else:
search_criteria["definition"] = "fdmprinter"
preferred_materials = container_registry.findInstanceContainers(**search_criteria)
if len(preferred_materials) >= 1:
# In some cases we get multiple materials. In that case, prefer materials that are marked as read only.
read_only_preferred_materials = [preferred_material for preferred_material in preferred_materials if preferred_material.isReadOnly()]
if len(read_only_preferred_materials) >= 1:
material = read_only_preferred_materials[0]
else:
material = preferred_materials[0]
else:
Logger.log("w", "The preferred material \"%s\" of machine %s doesn't exist or is not a material profile.", preferred_material_id, machine_id)
# And leave it at the default material.
container_stack.addContainer(material)
# Find a quality to use for this extruder.
quality = container_registry.getEmptyInstanceContainer()
search_criteria = { "type": "quality" }
if machine_definition.getMetaDataEntry("has_machine_quality"):
search_criteria["definition"] = machine_definition_id
if machine_definition.getMetaDataEntry("has_materials") and material:
search_criteria["material"] = material.id
else:
search_criteria["definition"] = "fdmprinter"
preferred_quality = machine_definition.getMetaDataEntry("preferred_quality")
if preferred_quality:
search_criteria["id"] = preferred_quality
containers = ContainerRegistry.getInstance().findInstanceContainers(**search_criteria)
if not containers and preferred_quality:
Logger.log("w", "The preferred quality \"%s\" of machine %s doesn't exist or is not a quality profile.", preferred_quality, machine_id)
search_criteria.pop("id", None)
containers = ContainerRegistry.getInstance().findInstanceContainers(**search_criteria)
if containers:
quality = containers[0]
container_stack.addContainer(quality)
empty_quality_changes = container_registry.findInstanceContainers(id = "empty_quality_changes")[0]
container_stack.addContainer(empty_quality_changes)
user_profile = container_registry.findInstanceContainers(type = "user", extruder = extruder_stack_id)
if user_profile: # There was already a user profile, loaded from settings.
user_profile = user_profile[0]
else:
user_profile = InstanceContainer(extruder_stack_id + "_current_settings") # Add an empty user profile.
user_profile.addMetaDataEntry("type", "user")
user_profile.addMetaDataEntry("extruder", extruder_stack_id)
from cura.CuraApplication import CuraApplication
user_profile.addMetaDataEntry("setting_version", CuraApplication.SettingVersion)
user_profile.setDefinition(machine_definition)
container_registry.addContainer(user_profile)
container_stack.addContainer(user_profile)
# regardless of what the next stack is, we have to set it again, because of signal routing.
container_stack.setNextStack(Application.getInstance().getGlobalContainerStack())
container_registry.addContainer(container_stack)
class Script:
def __init__(self) -> None:
super().__init__()
self._stack = None # type: Optional[ContainerStack]
self._definition = None # type: Optional[DefinitionContainerInterface]
self._instance = None # type: Optional[InstanceContainer]
def initialize(self) -> None:
setting_data = self.getSettingData()
self._stack = ContainerStack(stack_id=str(id(self)))
self._stack.setDirty(False) # This stack does not need to be saved.
# Check if the definition of this script already exists. If not, add it to the registry.
if "key" in setting_data:
definitions = ContainerRegistry.getInstance(
).findDefinitionContainers(id=setting_data["key"])
if definitions:
# Definition was found
self._definition = definitions[0]
else:
self._definition = DefinitionContainer(setting_data["key"])
try:
self._definition.deserialize(json.dumps(setting_data))
ContainerRegistry.getInstance().addContainer(
self._definition)
except ContainerFormatError:
self._definition = None
return
if self._definition is None:
return
self._stack.addContainer(self._definition)
self._instance = InstanceContainer(
container_id="ScriptInstanceContainer")
self._instance.setDefinition(self._definition.getId())
self._instance.setMetaDataEntry(
"setting_version",
self._definition.getMetaDataEntry("setting_version", default=0))
self._stack.addContainer(self._instance)
self._stack.propertyChanged.connect(self._onPropertyChanged)
ContainerRegistry.getInstance().addContainer(self._stack)
settingsLoaded = Signal()
valueChanged = Signal(
) # Signal emitted whenever a value of a setting is changed
def _onPropertyChanged(self, key: str, property_name: str) -> None:
if property_name == "value":
self.valueChanged.emit()
# Property changed: trigger reslice
# To do this we use the global container stack propertyChanged.
# Re-slicing is necessary for setting changes in this plugin, because the changes
# are applied only once per "fresh" gcode
global_container_stack = Application.getInstance(
).getGlobalContainerStack()
if global_container_stack is not None:
global_container_stack.propertyChanged.emit(key, property_name)
# Needs to return a dict that can be used to construct a settingcategory file.
# See the example script for an example.
# It follows the same style / guides as the Uranium settings.
# Scripts can either override getSettingData directly, or use getSettingDataString
# to return a string that will be parsed as json. The latter has the benefit over
# returning a dict in that the order of settings is maintained.
def getSettingData(self) -> Dict[str, Any]:
setting_data_as_string = self.getSettingDataString()
setting_data = json.loads(setting_data_as_string,
object_pairs_hook=collections.OrderedDict)
return setting_data
def getSettingDataString(self) -> str:
raise NotImplementedError()
def getDefinitionId(self) -> Optional[str]:
if self._stack:
bottom = self._stack.getBottom()
if bottom is not None:
return bottom.getId()
return None
def getStackId(self) -> Optional[str]:
if self._stack:
return self._stack.getId()
return None
# Convenience function that retrieves value of a setting from the stack.
def getSettingValueByKey(self, key: str) -> Any:
if self._stack is not None:
return self._stack.getProperty(key, "value")
return None
# Convenience function that finds the value in a line of g-code.
# When requesting key = x from line "G1 X100" the value 100 is returned.
def getValue(self, line: str, key: str, default=None) -> Any:
if key not in line or (';' in line
and line.find(key) > line.find(';')):
return default
sub_part = line[line.find(key) + 1:]
m = re.search('^-?[0-9]+\.?[0-9]*', sub_part)
if m is None:
return default
try:
return int(m.group(0))
except ValueError: # Not an integer.
try:
return float(m.group(0))
except ValueError: # Not a number at all.
return default
# Convenience function to produce a line of g-code.
#
# You can put in an original g-code line and it will re-use all the values in that line.
# All other keyword parameters are put in the result in g-code's format.
# For instance, if you put "G=1" in the parameters, it will output "G1".
# If you put "G=1", X=100" in the parameters, it will output "G1 X100".
# The parameters will be put in this order "G", "M", "T", "S", "F", "X", "Y", "Z", "E"
# followed by any other parameters
# \param line The original g-code line that must be modified. If not provided, an entirely new g-code line will be produced.
# \return A line of g-code with the desired parameters filled in.
def putValue(self, line: str = "", **kwargs) -> str:
# Strip the comment.
comment = ""
if ";" in line:
comment = line[line.find(";"):]
line = line[:line.find(";")] # Strip the comment.
# Parse the original g-code line and add them to kwargs.
for part in line.split(" "):
if part == "":
continue
parameter = part[0]
if parameter not in kwargs:
value = part[1:]
kwargs[parameter] = value
# Start writing the new g-code line.
line_parts = list()
# First add these parameters in order
for parameter in ["G", "M", "T", "S", "F", "X", "Y", "Z", "E"]:
if parameter in kwargs:
line_parts.append(parameter + str(kwargs.pop(parameter)))
# Then add the rest of the parameters
for parameter, value in kwargs.items():
line_parts.append(parameter + str(value))
# If there was a comment, put it back in.
if comment != "":
line_parts.append(comment)
# Construct the new line
return " ".join(line_parts)
# This is called when the script is executed.
# It gets a list of g-code strings and needs to return a (modified) list.
def execute(self, data: List[str]) -> List[str]:
raise NotImplementedError()
class Script:
def __init__(self):
super().__init__()
self._settings = None
self._stack = None
setting_data = self.getSettingData()
self._stack = ContainerStack(stack_id = str(id(self)))
self._stack.setDirty(False) # This stack does not need to be saved.
## Check if the definition of this script already exists. If not, add it to the registry.
if "key" in setting_data:
definitions = ContainerRegistry.getInstance().findDefinitionContainers(id = setting_data["key"])
if definitions:
# Definition was found
self._definition = definitions[0]
else:
self._definition = DefinitionContainer(setting_data["key"])
self._definition.deserialize(json.dumps(setting_data))
ContainerRegistry.getInstance().addContainer(self._definition)
self._stack.addContainer(self._definition)
self._instance = InstanceContainer(container_id="ScriptInstanceContainer")
self._instance.setDefinition(self._definition.getId())
self._instance.addMetaDataEntry("setting_version", self._definition.getMetaDataEntry("setting_version", default = 0))
self._stack.addContainer(self._instance)
self._stack.propertyChanged.connect(self._onPropertyChanged)
ContainerRegistry.getInstance().addContainer(self._stack)
settingsLoaded = Signal()
valueChanged = Signal() # Signal emitted whenever a value of a setting is changed
def _onPropertyChanged(self, key, property_name):
if property_name == "value":
self.valueChanged.emit()
# Property changed: trigger reslice
# To do this we use the global container stack propertyChanged.
# Reslicing is necessary for setting changes in this plugin, because the changes
# are applied only once per "fresh" gcode
global_container_stack = Application.getInstance().getGlobalContainerStack()
global_container_stack.propertyChanged.emit(key, property_name)
## Needs to return a dict that can be used to construct a settingcategory file.
# See the example script for an example.
# It follows the same style / guides as the Uranium settings.
# Scripts can either override getSettingData directly, or use getSettingDataString
# to return a string that will be parsed as json. The latter has the benefit over
# returning a dict in that the order of settings is maintained.
def getSettingData(self):
setting_data = self.getSettingDataString()
if type(setting_data) == str:
setting_data = json.loads(setting_data, object_pairs_hook = collections.OrderedDict)
return setting_data
def getSettingDataString(self):
raise NotImplementedError()
def getDefinitionId(self):
if self._stack:
return self._stack.getBottom().getId()
def getStackId(self):
if self._stack:
return self._stack.getId()
## Convenience function that retrieves value of a setting from the stack.
def getSettingValueByKey(self, key):
return self._stack.getProperty(key, "value")
## Convenience function that finds the value in a line of g-code.
# When requesting key = x from line "G1 X100" the value 100 is returned.
def getValue(self, line, key, default = None):
if not key in line or (';' in line and line.find(key) > line.find(';')):
return default
sub_part = line[line.find(key) + 1:]
m = re.search('^-?[0-9]+\.?[0-9]*', sub_part)
if m is None:
return default
try:
return float(m.group(0))
except:
return default
## This is called when the script is executed.
# It gets a list of g-code strings and needs to return a (modified) list.
def execute(self, data):
raise NotImplementedError()
def test_valueChanges(container_registry):
setting_property_provider = SettingPropertyProvider()
# First create the basics; A container stack that will hold 2 instance containers and a single definition container
container_stack = ContainerStack("test!")
instance_container = InstanceContainer("data")
second_instance_container = InstanceContainer("data2")
definition_container = DefinitionContainer("foo")
# Create a setting definition for our one and only setting!
setting_definition = SettingDefinition("test_setting")
setting_definition._deserialize_dict({"value": 10, "label": "blorp", "type": "float", "description": "nah", "maximum_value": 23, "maximum_value_warning": 21, "enabled": "test_setting != 20"})
definition_container.addDefinition(setting_definition)
# Make a single setting instance for our one and only setting.
setting_instance = SettingInstance(setting_definition, instance_container)
setting_instance.setProperty("value", 20)
setting_instance.setProperty("enabled", False)
instance_container.addInstance(setting_instance)
# Make a setting instance that lives in our second instance_container
setting_instance2 = SettingInstance(setting_definition, second_instance_container)
second_instance_container.addInstance(setting_instance2)
# Now that both containers are done, actually add them.
container_stack.addContainer(definition_container)
container_stack.addContainer(second_instance_container)
container_stack.addContainer(instance_container)
setting_property_provider.setContainerStack(container_stack)
setting_property_provider.setKey("test_setting")
assert setting_property_provider.key == "test_setting"
assert setting_property_provider.getPropertyValue("value", 0) == 20
setting_property_provider.setWatchedProperties(["enabled", "value", "validationState"])
setting_property_provider._update()
assert setting_property_provider.watchedProperties == ["enabled", "value", "validationState"]
assert setting_property_provider.properties.value("enabled") == "False"
assert setting_property_provider.properties.value("value") == "20"
# Validator state is a special property that gets added based on the type and the value
assert setting_property_provider.properties.value("validationState") == str(ValidatorState.Valid)
# Set the property value to something that will trigger a warning
setting_property_provider.setPropertyValue("value", 22)
assert setting_property_provider.properties.value("validationState") == str(ValidatorState.MaximumWarning)
assert setting_property_provider.getPropertyValue("value", 0) == 22
# The setting doesn't exist in our second instance container, so this should be None
assert setting_property_provider.getPropertyValue("value", 1) is None
# Set the property value to something that will trigger an error
setting_property_provider.setPropertyValue("value", 25)
# The Qtimer that we use to prevent flooding doesn't work in tests, so tickle the change manually.
setting_property_provider._update()
assert setting_property_provider.properties.value("validationState") == str(ValidatorState.MaximumError)
# We now ask for the second instance container to be targeted
setting_property_provider.setStoreIndex(1)
assert setting_property_provider.storeIndex == 1
setting_property_provider.setPropertyValue("value", 2)
setting_property_provider._update()
# So now we should see a change in that instance container
assert setting_property_provider.getPropertyValue("value", 1) == 2
# But not if we ask the provider, because the container above it still has a 25 as value!
assert setting_property_provider.getPropertyValue("value", 0) == 25
assert setting_property_provider.stackLevels == [0, 1, 2]
# We're asking for an index that doesn't exist.
assert setting_property_provider.getPropertyValue("value", 2000) is None
# The value is used, so the property must be true
assert setting_property_provider.isValueUsed
# Try to remove the setting from the container
setting_property_provider.removeFromContainer(0)
assert setting_property_provider.getPropertyValue("value", 0) is None
# Ensure that a weird index doesn't break
setting_property_provider.removeFromContainer(90001)
class CuraSettingsGuide(Extension, QObject):
"""
The main manager and entry point for the Cura Settings Guide.
This adds a menu item to the extensions menu and to the context menu of
every article. It creates a dialogue window to display the guide in, and
makes the menu items open said dialogue window.
This class is also exposed to the QML code, which can use it to request the
articles and metadata about the article.
"""
def __init__(self, parent=None) -> None:
"""
Executed during registration of the plug-in.
This adds a menu item to the extensions menu and the context menu of the
settings.
:param parent: The parent QObject this is located in. Unused by this
particular object.
"""
QObject.__init__(self, parent)
Extension.__init__(self)
self.setMenuName("Ѕettings Guide") # Using Cyrillic Ѕ instead of normal S to prevent MacOS detecting the word "setting" and pulling this menu item out of context.
self.addMenuItem("Ѕettings Guide", self.startWelcomeGuide)
self._dialog = None # Cached instance of the dialogue window.
self._container_stack = None # Stack that provides not only the normal settings but also the extra articles added by this guide.
self._markdown_per_folder = {} # For each directory containing Markdown files, create one renderer that correctly dereferences images relatively.
self.articles = {} # type: Dict[str, Dict[str, List[List[str]]]] # All of the articles by key and language. Key: article ID, value: Dict with language as key and lists of items in each article as value.
self.load_definitions()
self.article_locations = self.find_articles()
self._selected_article_id = "" # Which article is currently shown for the user. Empty string indicates it's the welcome screen.
# Add context menu item to the settings list to open the guide for that setting.
application = CuraApplication.getInstance()
self._selected_language = application.getPreferences().getValue("general/language")
application.getCuraAPI().interface.settings.addContextMenuItem({
"name": "Settings Guide",
"icon_name": "help-contents",
"actions": ["sidebarMenuItemOnClickHandler"],
"menu_item": MenuItemHandler.MenuItemHandler(self)
})
application.getPreferences().addPreference("settings_guide/show+articles+in+setting+tooltips+%28requires+restart%29", False)
self.adjust_theme()
application.initializationFinished.connect(self.load_all_in_background)
def adjust_theme(self):
"""
Makes the tooltips wider, if displaying articles in the tooltips.
"""
application = CuraApplication.getInstance()
preferences = application.getPreferences()
if preferences.getValue("settings_guide/show+articles+in+setting+tooltips+%28requires+restart%29"):
preferences.addPreference("general/theme", application.default_theme)
theme_name = preferences.getValue("general/theme")
if theme_name.endswith("_settingsguideadjust"):
return # Already adjusted.
theme_path = Resources.getPath(Resources.Themes, theme_name)
# Create a new theme where we can adjust the tooltip.
new_theme_name = theme_name + "_settingsguideadjust"
new_theme_path = Resources.getStoragePath(Resources.Themes, new_theme_name)
try:
shutil.copytree(theme_path, new_theme_path)
except OSError: # Already exists. Happens when the user manually adjusted the theme back in the preferences screen.
try:
os.removedirs(new_theme_path)
shutil.copytree(theme_path, new_theme_path)
except OSError:
pass # Perhaps no rights?
# Adjust the tooltip width.
with open(os.path.join(theme_path, "theme.json")) as f:
adjusted_theme = json.load(f)
if "sizes" not in adjusted_theme:
adjusted_theme["sizes"] = {}
adjusted_theme["sizes"]["tooltip"] = [50.0, 10.0]
with open(os.path.join(new_theme_path, "theme.json"), "w") as f:
json.dump(adjusted_theme, f)
# Enable the new theme.
preferences.setValue("general/theme", new_theme_name)
application.default_theme = new_theme_name
def load_all_in_background(self):
"""
Runs the load_all() function as a background task.
"""
class ArticleLoadJob(Job):
"""
A background task that loads all articles of the guide.
"""
def __init__(self, guide):
"""
Creates the background task.
:param guide: The CuraSettingsGuide object which has the
function to call.
"""
self.guide = guide
def run(self):
"""
Runs the background task.
Cura will call this function from a different thread.
"""
self.guide.load_all()
JobQueue.getInstance().add(ArticleLoadJob(self))
def load_all(self):
"""
Pre-cache all articles.
This is meant to run as a background task. This makes sure all setting
descriptions are loaded so that they can load faster next time the
article is requested. It also makes sure that the setting description
is correctly displayed (after a while).
"""
for article_id in self._container_stack.getAllKeys():
self._getArticle(article_id) # Load articles one by one.
Logger.log("i", "Finished loading Settings Guide articles.")
def load_definitions(self):
"""
Load all the setting definitions into a custom container stack.
This container stack also contains extra entries for the articles that
are not settings.
The result is stored in self._container_stack.
"""
if self._container_stack:
return # Already done earlier. Don't re-load.
with open(os.path.join(os.path.dirname(__file__), "resources", "settings_guide_definitions.def.json")) as f:
definitions_serialised = f.read()
definition_container = DefinitionContainer("settings_guide_definitions")
definition_container.deserialize(definitions_serialised)
ContainerRegistry.getInstance().addContainer(definition_container)
self._container_stack = ContainerStack("settings_guide_stack")
self._container_stack.addContainer(definition_container)
ContainerRegistry.getInstance().addContainer(self._container_stack)
def find_articles(self):
"""
For each article and language, find where the Markdown file is
located.
:return: A nested dictionary mapping article ID to language to file
path.
"""
result = {}
# Find the English translations first.
for root, _, files in os.walk(os.path.join(os.path.dirname(__file__), "resources", "articles")):
for filename in files:
base_name, extension = os.path.splitext(filename)
if extension != ".md":
continue # Only interested in article files.
result[base_name] = {"en_US": os.path.join(root, filename)}
# Find the translated articles in the translations folder.
for language in os.listdir(os.path.join(os.path.dirname(__file__), "resources", "translations")):
language_path = os.path.join(os.path.dirname(__file__), "resources", "translations", language)
if not os.path.isdir(language_path):
continue # Not a translation folder.
for root, _, files in os.walk(language_path):
for filename in files:
base_name, extension = os.path.splitext(filename)
if extension != ".md":
continue # Only interested in article files.
if base_name not in result:
continue # Translation for an article that doesn't exist in English?
result[base_name][language] = os.path.join(root, filename)
return result
def load_window(self):
"""
Create the GUI window for the guide.
The window's QML element is stored in a field. There can only be one
instance at a time.
"""
self.load_definitions()
if self._dialog:
return # Dialogue already open.
Logger.log("d", "Creating Settings Guide window.")
plugin_path = PluginRegistry.getInstance().getPluginPath(self.getPluginId())
if plugin_path is None:
plugin_path = os.path.dirname(__file__)
path = os.path.join(plugin_path, "resources", "qml", "SettingsGuide.qml")
self._dialog = CuraApplication.getInstance().createQmlComponent(path, {"manager": self})
if not self._dialog:
Logger.log("e", "Unable to create settings guide dialogue.")
def startWelcomeGuide(self) -> None:
"""
Opens the guide in the welcome page.
"""
self.load_window()
if not self._dialog:
return
self.setSelectedArticleId("") # Display welcome page.
self._dialog.show()
def startWelcomeGuideAndSelectArticle(self, article_key: str) -> None:
"""
Opens the guide and immediately selects a certain article.
:param article_key: The key of the article to show the guide of.
"""
self.load_window()
if not self._dialog:
return
self.currentArticleReset.emit()
self.setSelectedArticleId(article_key)
self._dialog.show()
currentArticleReset = pyqtSignal() #Signal to indicate that the article list should reset its current index.
def _getArticle(self, article_id, language="en_US") -> List[List[str]]:
"""
Gets the rich text of a specified article.
This function lazily loads an article from a file. If it's never been
loaded before the article gets parsed and stored. Otherwise it'll get
taken from the cache.
:param article_id: The ID of the article to get.
:param language: The language to get the article in.
"""
if article_id in self.articles and language in self.articles[article_id]:
return self.articles[article_id][language]
images_path = os.path.join(os.path.dirname(__file__), "resources", "articles", "images")
try:
if language not in self.article_locations[article_id]:
language = "en_US" # Fall back to English if the preferred language is not available.
markdown_file = self.article_locations[article_id][language]
with open(markdown_file, encoding="utf-8") as f:
markdown_str = f.read()
images_path = os.path.dirname(markdown_file)
except (OSError, KeyError): # File doesn't exist or is otherwise not readable.
if self._container_stack and article_id in self._container_stack.getAllKeys():
markdown_str = "*" + self._container_stack.getProperty(article_id, "description") + "*" # Use the setting description as fallback.
else:
markdown_str = "There is no article on this topic."
if images_path not in self._markdown_per_folder:
renderer = QtMarkdownRenderer.QtMarkdownRenderer(images_path)
self._markdown_per_folder[images_path] = mistune.Markdown(renderer=renderer) # Renders the Markdown articles into the subset of HTML supported by Qt.
preferences = CuraApplication.getInstance().getPreferences()
find_images = re.compile(r"!\[(.*)\]\(([^\)]+)\)")
find_checkboxes = re.compile(r"\[ \]\s*([^\n]+)")
image_description = None
parts = [] # type: List[List[str]] # List of items in the article. Each item starts with a type ID, and then a variable number of data items.
for index, part_between_images in enumerate(find_images.split(markdown_str)):
# The parts of the regex split alternate between text, image description and image URL.
if index % 3 == 0:
part_between_images = part_between_images.strip()
if part_between_images or index == 0:
parts_between_checkboxes = find_checkboxes.split(part_between_images)
for index2, part_between_checkboxes in enumerate(parts_between_checkboxes):
part_between_checkboxes = part_between_checkboxes.strip()
# The parts of the regex split alternate between text and checkbox description.
if index2 % 2 == 0:
if part_between_checkboxes:
rich_text = self._markdown_per_folder[images_path](part_between_checkboxes)
parts.append(["rich_text", rich_text])
else: # if index2 == 1:
preference_key = "settings_guide/" + urllib.parse.quote_plus(part_between_checkboxes).lower()
parts.append(["checkbox", preference_key, part_between_checkboxes])
elif index % 3 == 1:
image_description = mistune.markdown(part_between_images)
else: # if index % 3 == 2:
if image_description is not None:
if parts[-1][0] != "images": # List of images.
parts.append(["images"])
image_url = os.path.join(images_path, part_between_images)
parts[-1].append(QUrl.fromLocalFile(image_url).toString() + "|" + image_description)
image_description = None
if article_id not in self.articles:
self.articles[article_id] = {}
self.articles[article_id][language] = parts
if preferences.getValue("settings_guide/show+articles+in+setting+tooltips+%28requires+restart%29"):
# Load the article into the actual setting description as well.
global_stack = CuraApplication.getInstance().getGlobalContainerStack()
if global_stack and article_id in global_stack.getAllKeys():
complete_article = self._markdown_per_folder[images_path](markdown_str)
definition = global_stack.definition.findDefinitions(key=article_id)[0]
definition._SettingDefinition__property_values["description"] = complete_article
return self.articles[article_id][language]
@pyqtSlot(str, result=bool)
def isArticleFile(self, filename: str) -> bool:
"""
Tests whether a file name is the file name of an existing article.
This test is used to determine if a link should refer to a different
article or to the internet.
:param filename: The file name to test for.
:return: True if the file name is the file name of an existing article,
or False if it isn't.
"""
return os.path.exists(filename)
@pyqtProperty(QObject, constant=True)
def containerStack(self) -> Optional[ContainerStack]:
"""
The specialised container stack containing setting definitions for all
of the articles in the guide.
:return: A container stack with extra definitions for all articles in
the guide.
"""
return self._container_stack
@pyqtProperty(str, constant=True)
def pluginVersion(self) -> str:
"""
Get the version number of this plug-in.
This plug-in version is a semantic version number in three parts
("1.2.3").
:return: The version number of this plug-in.
"""
return self.getVersion()
selectedArticleChanged = pyqtSignal()
@pyqtSlot(str)
def setSelectedArticleId(self, article_key: str) -> None:
"""
Show a certain article in the dialogue.
:param article_key: The key of the article to display.
"""
if self._selected_article_id != article_key:
self._selected_article_id = article_key
self.selectedArticleChanged.emit()
@pyqtProperty(str, fset=setSelectedArticleId, notify=selectedArticleChanged)
def selectedArticleId(self) -> str:
"""
Returns the key of the article that is currently selected.
If no article has been selected (the logo is being shown), an empty
string is returned.
:return: The key of the article that is currently selected.
"""
return self._selected_article_id
@pyqtProperty("QVariantList", notify=selectedArticleChanged)
def selectedArticle(self) -> List[List[str]]:
"""
Returns the currently selected article.
This article data is a rich text document, properly formatted from the
Markdown files in the article directory. Each article is a list of
items, some of which are text and some of which are image lists.
:return: The the currently selected article.
"""
return self._getArticle(self._selected_article_id, self._selected_language)
