def _getPropertyValue(self, property_name): # Use the evaluation context to skip certain containers context = PropertyEvaluationContext(self._stack) context.context["evaluate_from_container_index"] = self._store_index property_value = self._stack.getProperty(self._key, property_name, context = context) if isinstance(property_value, SettingFunction): property_value = property_value(self._stack) if property_name == "value": setting_type = self._stack.getProperty(self._key, "type") if setting_type is not None: property_value = SettingDefinition.settingValueToString(setting_type, property_value) else: property_value = "" elif property_name == "validationState": # Setting is not validated. This can happen if there is only a setting definition. # We do need to validate it, because a setting defintions value can be set by a function, which could # be an invalid setting. if property_value is None: if not self._validator: definition = self._stack.getSettingDefinition(self._key) if definition: validator_type = SettingDefinition.getValidatorForType(definition.type) if validator_type: self._validator = validator_type(self._key) if self._validator: property_value = self._validator(self._stack) return str(property_value)
def benchmark_findDefinitions(benchmark, filter, match_count): definition = SettingDefinition("test", None) definition.deserialize({ "label": "Test", "type": "int", "default_value": 10, "description": "Test Setting", "children": { "test_child_1": { "label": "Test Child 1", "type": "int", "default_value": 20, "description": "Test Child Setting 1" }, "test_child_2": { "label": "Test Child 2", "type": "int", "default_value": 20, "description": "Test Child Setting 2" } } }) result = benchmark(definition.findDefinitions, **filter) assert len(result) == match_count
def _createSettingDefinition(properties): result = SettingDefinition(properties["key"]) # Key MUST be present. if "default_value" in properties: result._SettingDefinition__property_values["default_value"] = properties["default_value"] # Nota bene: Setting a private value depends on implementation, but changing a property is not currently exposed. result._SettingDefinition__property_values["description"] = "Test setting definition" result._SettingDefinition__property_values["type"] = "str" if "children" in properties: for child in properties["children"]: result.children.append(_createSettingDefinition(child)) return result
def __init__(self, parent = None, *args, **kwargs): super().__init__(parent = parent, *args, **kwargs) self._container_id = None self._container = None self._i18n_catalog = None self._root_key = "" self._root = None self._definition_list = [] self._row_index_list = [] self._expanded = set() self._visible = set() self._exclude = set() self._show_all = False self._show_ancestors = False self._visibility_handler = None self._filter_dict = {} self._role_names = { self.KeyRole: b"key", self.DepthRole: b"depth", self.VisibleRole: b"visible", self.ExpandedRole: b"expanded", } index = self.ExpandedRole + 1 for name in SettingDefinition.getPropertyNames(): self._role_names[index] = name.encode() index += 1
def deserialize(self, serialized): # update the serialized data first serialized = super().deserialize(serialized) parsed = self._readAndValidateSerialized(serialized) # Update properties with the data from the JSON self._name = parsed["name"] self._metadata = parsed["metadata"] for key, value in parsed["settings"].items(): definition = SettingDefinition(key, self, None, self._i18n_catalog) definition.deserialize(value) self._definitions.append(definition) for definition in self._definitions: self._updateRelations(definition)
def __init__(self, parent = None, *args, **kwargs): super().__init__(parent = parent, *args, **kwargs) self._container_id = None self._container = None self._role_names = { self.KeyRole: b"key" } index = self.KeyRole + 1 for name in SettingDefinition.getPropertyNames(): self._role_names[index] = name.encode() index += 1
def deserialize(self, serialized: str, file_name: Optional[str] = None) -> str: # update the serialized data first serialized = super().deserialize(serialized, file_name) parsed, is_valid = self.readAndValidateSerialized(serialized) # Update properties with the data from the JSON old_id = self.getId() #The ID must be set via the constructor. Retain it. self._metadata = parsed["metadata"] self._metadata["id"] = old_id self._metadata["name"] = parsed["name"] self._metadata["version"] = self.Version #Guaranteed to be equal to what's in the parsed data by the validation. self._metadata["container_type"] = DefinitionContainer for key, value in parsed["settings"].items(): definition = SettingDefinition(key, self, None, self._i18n_catalog) definition.deserialize(value) self._definitions.append(definition) for definition in self._definitions: self._updateRelations(definition) return serialized
def getErrorKeys(self) -> List[str]: error_keys = [] for key in self.getAllKeys(): validation_state = self.getProperty(key, "validationState") if validation_state is None: # Setting is not validated. This can happen if there is only a setting definition. # We do need to validate it, because a setting defintions value can be set by a function, which could # be an invalid setting. definition = cast(SettingDefinition, self.getSettingDefinition(key)) validator_type = SettingDefinition.getValidatorForType(definition.type) if validator_type: validator = validator_type(key) validation_state = validator(self) if validation_state in (ValidatorState.Exception, ValidatorState.MaximumError, ValidatorState.MinimumError): error_keys.append(key) return error_keys
def _getPropertyValue(self, property_name: str) -> str: property_value = self._container.getProperty(self._key, property_name) if isinstance(property_value, SettingFunction): property_value = property_value(self._container) if property_name == "value": setting_type = self._container.getProperty(self._key, "type") if not setting_type: instance = self._container.getInstance(self._key) if instance: setting_type = instance.definition.type if setting_type: property_value = SettingDefinition.settingValueToString(setting_type, property_value) return str(property_value)
def hasErrors(self) -> bool: for key in self.getAllKeys(): enabled = self.getProperty(key, "enabled") if not enabled: continue validation_state = self.getProperty(key, "validationState") if validation_state is None: # Setting is not validated. This can happen if there is only a setting definition. # We do need to validate it, because a setting defintions value can be set by a function, which could # be an invalid setting. definition = cast(SettingDefinition, self.getSettingDefinition(key)) validator_type = SettingDefinition.getValidatorForType(definition.type) if validator_type: validator = validator_type(key) validation_state = validator(self) if validation_state in (ValidatorState.Exception, ValidatorState.MaximumError, ValidatorState.MinimumError): return True return False
def hasErrors(self) -> bool: for key in self.getAllKeys(): enabled = self.getProperty(key, "enabled") if not enabled: continue validation_state = self.getProperty(key, "validationState") if validation_state is None: # Setting is not validated. This can happen if there is only a setting definition. # We do need to validate it, because a setting defintions value can be set by a function, which could # be an invalid setting. definition = self.getSettingDefinition(key) validator_type = SettingDefinition.getValidatorForType( definition.type) if validator_type: validator = validator_type(key) validation_state = validator(self) if validation_state in (ValidatorState.Exception, ValidatorState.MaximumError, ValidatorState.MinimumError): return True return False
def __init__(self, parent = None, *args, **kwargs): super().__init__(parent = parent) self._container_id = None # type: Optional[str] self._container = None # type: Optional[DefinitionContainerInterface] self._i18n_catalog = None self._root_key = "" # type: str self._root = None # type: Optional[SettingDefinition] self._definition_list = [] # type: List[SettingDefinition] self._row_index_list = [] # type: List[int] self._expanded = set() # type: Set[str] self._visible = set() # type: Set[str] self._exclude = set() # type: Set[str] self._show_all = False # type: bool self._show_ancestors = False # type: bool self._visibility_handler = None # type: Optional[SettingPreferenceVisibilityHandler] self._update_visible_row_scheduled = False # type: bool self._destroyed = False # type: bool self._filter_dict = {} # type: Dict[str, str] self._role_names = { self.KeyRole: b"key", self.DepthRole: b"depth", self.VisibleRole: b"visible", self.ExpandedRole: b"expanded", } # type: Dict[int, bytes] index = self.ExpandedRole + 1 for name in SettingDefinition.getPropertyNames(): self._role_names[index] = name.encode() index += 1 self.destroyed.connect(self._onDestroyed) self.expandedChanged.connect(self.onExpandedChanged)
def _checkStack(self): if self._need_to_check: Logger.log("d", "Need to check for errors again. Discard the current progress and reschedule a check.") self._check_in_progress = False self._application.callLater(self.startErrorCheck) return self._check_in_progress = True # If there is nothing to check any more, it means there is no error. if not self._stacks_and_keys_to_check: # Finish self._setResult(False) return # Get the next stack and key to check stack, key = self._stacks_and_keys_to_check.popleft() enabled = stack.getProperty(key, "enabled") if not enabled: self._application.callLater(self._checkStack) return validation_state = stack.getProperty(key, "validationState") if validation_state is None: # Setting is not validated. This can happen if there is only a setting definition. # We do need to validate it, because a setting definitions value can be set by a function, which could # be an invalid setting. definition = stack.getSettingDefinition(key) validator_type = SettingDefinition.getValidatorForType(definition.type) if validator_type: validator = validator_type(key) validation_state = validator(stack) if validation_state in (ValidatorState.Exception, ValidatorState.MaximumError, ValidatorState.MinimumError): # Finish self._setResult(True) return # Schedule the check for the next key self._application.callLater(self._checkStack)
def _checkStack(self) -> None: if self._need_to_check: Logger.log("d", "Need to check for errors again. Discard the current progress and reschedule a check.") self._check_in_progress = False self._application.callLater(self.startErrorCheck) return self._check_in_progress = True # If there is nothing to check any more, it means there is no error. if not self._stacks_and_keys_to_check: # Finish self._setResult(False) return # Get the next stack and key to check stack, key = self._stacks_and_keys_to_check.popleft() enabled = stack.getProperty(key, "enabled") if not enabled: self._application.callLater(self._checkStack) return validation_state = stack.getProperty(key, "validationState") if validation_state is None: # Setting is not validated. This can happen if there is only a setting definition. # We do need to validate it, because a setting definitions value can be set by a function, which could # be an invalid setting. definition = stack.getSettingDefinition(key) validator_type = SettingDefinition.getValidatorForType(definition.type) if validator_type: validator = validator_type(key) validation_state = validator(stack) if validation_state in (ValidatorState.Exception, ValidatorState.MaximumError, ValidatorState.MinimumError): # Finish self._setResult(True) return # Schedule the check for the next key self._application.callLater(self._checkStack)
def _checkStackForErrors(self, stack: ContainerStack) -> bool: top_of_stack = cast(InstanceContainer, stack.getTop()) # Cache for efficiency. changed_setting_keys = top_of_stack.getAllKeys() # Add all relations to changed settings as well. for key in top_of_stack.getAllKeys(): instance = top_of_stack.getInstance(key) if instance is None: continue self._addRelations(changed_setting_keys, instance.definition.relations) Job.yieldThread() for changed_setting_key in changed_setting_keys: validation_state = stack.getProperty(changed_setting_key, "validationState") if validation_state is None: definition = cast( SettingDefinition, stack.getSettingDefinition(changed_setting_key)) validator_type = SettingDefinition.getValidatorForType( definition.type) if validator_type: validator = validator_type(changed_setting_key) validation_state = validator(stack) if validation_state in (ValidatorState.Exception, ValidatorState.MaximumError, ValidatorState.MinimumError, ValidatorState.Invalid): Logger.log( "w", "Setting %s is not valid, but %s. Aborting slicing.", changed_setting_key, validation_state) return True Job.yieldThread() return False
def __init__(self, parent=None, *args, **kwargs): super().__init__(parent=parent, *args, **kwargs) self._container_id = None self._container = None self._i18n_catalog = None self._root_key = "" self._root = None self._definition_list = [] self._row_index_list = [] self._expanded = set() self._visible = set() self._exclude = set() self._show_all = False # type: bool self._show_ancestors = False # type: bool self._visibility_handler = None self._update_visible_row_scheduled = False # type: bool self._destroyed = False # type: bool self._filter_dict = {} self._role_names = { self.KeyRole: b"key", self.DepthRole: b"depth", self.VisibleRole: b"visible", self.ExpandedRole: b"expanded", } index = self.ExpandedRole + 1 for name in SettingDefinition.getPropertyNames(): self._role_names[index] = name.encode() index += 1 self.destroyed.connect(self._onDestroyed)
def getErrorKeys(self) -> List[str]: """Get all the keys that are in an error state in this stack""" error_keys = [] for key in self.getAllKeys(): validation_state = self.getProperty(key, "validationState") if validation_state is None: # Setting is not validated. This can happen if there is only a setting definition. # We do need to validate it, because a setting defintions value can be set by a function, which could # be an invalid setting. definition = cast(SettingDefinition, self.getSettingDefinition(key)) validator_type = SettingDefinition.getValidatorForType( definition.type) if validator_type: validator = validator_type(key) validation_state = validator(self) if validation_state in (ValidatorState.Exception, ValidatorState.MaximumError, ValidatorState.MinimumError, ValidatorState.Invalid): error_keys.append(key) return error_keys
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)
def __init__(self): Resources.addSearchPath(os.path.join(QtApplication.getInstallPrefix(), "share", "cura", "resources")) if not hasattr(sys, "frozen"): Resources.addSearchPath(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "resources")) self._open_file_queue = [] # Files to open when plug-ins are loaded. # Need to do this before ContainerRegistry tries to load the machines SettingDefinition.addSupportedProperty("settable_per_mesh", DefinitionPropertyType.Any, default = True, read_only = True) SettingDefinition.addSupportedProperty("settable_per_extruder", DefinitionPropertyType.Any, default = True, read_only = True) # this setting can be changed for each group in one-at-a-time mode SettingDefinition.addSupportedProperty("settable_per_meshgroup", DefinitionPropertyType.Any, default = True, read_only = True) SettingDefinition.addSupportedProperty("settable_globally", DefinitionPropertyType.Any, default = True, read_only = True) # From which stack the setting would inherit if not defined per object (handled in the engine) # AND for settings which are not settable_per_mesh: # which extruder is the only extruder this setting is obtained from SettingDefinition.addSupportedProperty("limit_to_extruder", DefinitionPropertyType.Function, default = "-1") # For settings which are not settable_per_mesh and not settable_per_extruder: # A function which determines the glabel/meshgroup value by looking at the values of the setting in all (used) extruders SettingDefinition.addSupportedProperty("resolve", DefinitionPropertyType.Function, default = None, depends_on = "value") SettingDefinition.addSettingType("extruder", None, str, Validator) SettingFunction.registerOperator("extruderValues", cura.Settings.ExtruderManager.getExtruderValues) SettingFunction.registerOperator("extruderValue", cura.Settings.ExtruderManager.getExtruderValue) SettingFunction.registerOperator("resolveOrValue", cura.Settings.ExtruderManager.getResolveOrValue) ## Add the 4 types of profiles to storage. Resources.addStorageType(self.ResourceTypes.QualityInstanceContainer, "quality") Resources.addStorageType(self.ResourceTypes.VariantInstanceContainer, "variants") Resources.addStorageType(self.ResourceTypes.MaterialInstanceContainer, "materials") Resources.addStorageType(self.ResourceTypes.UserInstanceContainer, "user") Resources.addStorageType(self.ResourceTypes.ExtruderStack, "extruders") Resources.addStorageType(self.ResourceTypes.MachineStack, "machine_instances") ContainerRegistry.getInstance().addResourceType(self.ResourceTypes.QualityInstanceContainer) ContainerRegistry.getInstance().addResourceType(self.ResourceTypes.VariantInstanceContainer) ContainerRegistry.getInstance().addResourceType(self.ResourceTypes.MaterialInstanceContainer) ContainerRegistry.getInstance().addResourceType(self.ResourceTypes.UserInstanceContainer) ContainerRegistry.getInstance().addResourceType(self.ResourceTypes.ExtruderStack) ContainerRegistry.getInstance().addResourceType(self.ResourceTypes.MachineStack) ## Initialise the version upgrade manager with Cura's storage paths. import UM.VersionUpgradeManager #Needs to be here to prevent circular dependencies. UM.VersionUpgradeManager.VersionUpgradeManager.getInstance().setCurrentVersions( { ("quality", UM.Settings.InstanceContainer.Version): (self.ResourceTypes.QualityInstanceContainer, "application/x-uranium-instancecontainer"), ("machine_stack", UM.Settings.ContainerStack.Version): (self.ResourceTypes.MachineStack, "application/x-uranium-containerstack"), ("preferences", UM.Preferences.Version): (Resources.Preferences, "application/x-uranium-preferences"), ("user", UM.Settings.InstanceContainer.Version): (self.ResourceTypes.UserInstanceContainer, "application/x-uranium-instancecontainer") } ) self._machine_action_manager = MachineActionManager.MachineActionManager() self._machine_manager = None # This is initialized on demand. self._setting_inheritance_manager = None self._additional_components = {} # Components to add to certain areas in the interface super().__init__(name = "cura", version = CuraVersion, buildtype = CuraBuildType) self.setWindowIcon(QIcon(Resources.getPath(Resources.Images, "cura-icon.png"))) self.setRequiredPlugins([ "CuraEngineBackend", "MeshView", "LayerView", "STLReader", "SelectionTool", "CameraTool", "GCodeWriter", "LocalFileOutputDevice" ]) self._physics = None self._volume = None self._output_devices = {} self._print_information = None self._previous_active_tool = None self._platform_activity = False self._scene_bounding_box = AxisAlignedBox.Null self._job_name = None self._center_after_select = False self._camera_animation = None self._cura_actions = None self._started = False self._message_box_callback = None self._message_box_callback_arguments = [] self._i18n_catalog = i18nCatalog("cura") self.getController().getScene().sceneChanged.connect(self.updatePlatformActivity) self.getController().toolOperationStopped.connect(self._onToolOperationStopped) Resources.addType(self.ResourceTypes.QmlFiles, "qml") Resources.addType(self.ResourceTypes.Firmware, "firmware") self.showSplashMessage(self._i18n_catalog.i18nc("@info:progress", "Loading machines...")) # Add empty variant, material and quality containers. # Since they are empty, they should never be serialized and instead just programmatically created. # We need them to simplify the switching between materials. empty_container = ContainerRegistry.getInstance().getEmptyInstanceContainer() empty_variant_container = copy.deepcopy(empty_container) empty_variant_container._id = "empty_variant" empty_variant_container.addMetaDataEntry("type", "variant") ContainerRegistry.getInstance().addContainer(empty_variant_container) empty_material_container = copy.deepcopy(empty_container) empty_material_container._id = "empty_material" empty_material_container.addMetaDataEntry("type", "material") ContainerRegistry.getInstance().addContainer(empty_material_container) empty_quality_container = copy.deepcopy(empty_container) empty_quality_container._id = "empty_quality" empty_quality_container.setName("Not supported") empty_quality_container.addMetaDataEntry("quality_type", "normal") empty_quality_container.addMetaDataEntry("type", "quality") ContainerRegistry.getInstance().addContainer(empty_quality_container) empty_quality_changes_container = copy.deepcopy(empty_container) empty_quality_changes_container._id = "empty_quality_changes" empty_quality_changes_container.addMetaDataEntry("type", "quality_changes") ContainerRegistry.getInstance().addContainer(empty_quality_changes_container) # Set the filename to create if cura is writing in the config dir. self._config_lock_filename = os.path.join(Resources.getConfigStoragePath(), CONFIG_LOCK_FILENAME) self.waitConfigLockFile() ContainerRegistry.getInstance().load() Preferences.getInstance().addPreference("cura/active_mode", "simple") Preferences.getInstance().addPreference("cura/recent_files", "") Preferences.getInstance().addPreference("cura/categories_expanded", "") Preferences.getInstance().addPreference("cura/jobname_prefix", True) Preferences.getInstance().addPreference("view/center_on_select", True) Preferences.getInstance().addPreference("mesh/scale_to_fit", True) Preferences.getInstance().addPreference("mesh/scale_tiny_meshes", True) for key in [ "dialog_load_path", # dialog_save_path is in LocalFileOutputDevicePlugin "dialog_profile_path", "dialog_material_path"]: Preferences.getInstance().addPreference("local_file/%s" % key, os.path.expanduser("~/")) Preferences.getInstance().setDefault("local_file/last_used_type", "text/x-gcode") Preferences.getInstance().setDefault("general/visible_settings", """ machine_settings resolution layer_height shell wall_thickness top_bottom_thickness infill infill_sparse_density material material_print_temperature material_bed_temperature material_diameter material_flow retraction_enable speed speed_print speed_travel acceleration_print acceleration_travel jerk_print jerk_travel travel cooling cool_fan_enabled support support_enable support_extruder_nr support_type support_interface_density platform_adhesion adhesion_type adhesion_extruder_nr brim_width raft_airgap layer_0_z_overlap raft_surface_layers dual prime_tower_enable prime_tower_size prime_tower_position_x prime_tower_position_y meshfix blackmagic print_sequence infill_mesh experimental """.replace("\n", ";").replace(" ", "")) JobQueue.getInstance().jobFinished.connect(self._onJobFinished) self.applicationShuttingDown.connect(self.saveSettings) self.engineCreatedSignal.connect(self._onEngineCreated) self._recent_files = [] files = Preferences.getInstance().getValue("cura/recent_files").split(";") for f in files: if not os.path.isfile(f): continue self._recent_files.append(QUrl.fromLocalFile(f))
import sys import json from UM.Settings.SettingDefinition import SettingDefinition, DefinitionPropertyType from UM.Settings.Validator import Validator from UM.Settings.DefinitionContainer import DefinitionContainer if len(sys.argv) < 3: print("Usage: query.py [file] [query]") exit(1) file_path = sys.argv[1] # These are defined by Cura but we would still like to be able to query them. SettingDefinition.addSupportedProperty("settable_per_mesh", DefinitionPropertyType.Any, default=True, read_only=True) SettingDefinition.addSupportedProperty("settable_per_extruder", DefinitionPropertyType.Any, default=True, read_only=True) SettingDefinition.addSupportedProperty("settable_per_meshgroup", DefinitionPropertyType.Any, default=True, read_only=True) SettingDefinition.addSupportedProperty("settable_globally", DefinitionPropertyType.Any, default=True, read_only=True) SettingDefinition.addSupportedProperty("limit_to_extruder", DefinitionPropertyType.Function,
def __init__(self): Resources.addSearchPath( os.path.join(QtApplication.getInstallPrefix(), "share", "cura", "resources")) if not hasattr(sys, "frozen"): Resources.addSearchPath( os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "resources")) self._open_file_queue = [] # Files to open when plug-ins are loaded. # Need to do this before ContainerRegistry tries to load the machines SettingDefinition.addSupportedProperty("global_only", DefinitionPropertyType.Function, default=False) SettingDefinition.addSettingType("extruder", int, str, UM.Settings.Validator) super().__init__(name="cura", version=CuraVersion, buildtype=CuraBuildType) self.setWindowIcon( QIcon(Resources.getPath(Resources.Images, "cura-icon.png"))) self.setRequiredPlugins([ "CuraEngineBackend", "MeshView", "LayerView", "STLReader", "SelectionTool", "CameraTool", "GCodeWriter", "LocalFileOutputDevice" ]) self._physics = None self._volume = None self._platform = None self._output_devices = {} self._print_information = None self._i18n_catalog = None self._previous_active_tool = None self._platform_activity = False self._scene_bounding_box = AxisAlignedBox() self._job_name = None self._center_after_select = False self._camera_animation = None self._cura_actions = None self._started = False self.getController().getScene().sceneChanged.connect( self.updatePlatformActivity) self.getController().toolOperationStopped.connect( self._onToolOperationStopped) Resources.addType(self.ResourceTypes.QmlFiles, "qml") Resources.addType(self.ResourceTypes.Firmware, "firmware") ## Add the 4 types of profiles to storage. Resources.addStorageType(self.ResourceTypes.QualityInstanceContainer, "quality") Resources.addStorageType(self.ResourceTypes.VariantInstanceContainer, "variants") Resources.addStorageType(self.ResourceTypes.MaterialInstanceContainer, "materials") Resources.addStorageType(self.ResourceTypes.UserInstanceContainer, "user") Resources.addStorageType(self.ResourceTypes.ExtruderStack, "extruders") Resources.addStorageType(self.ResourceTypes.MachineStack, "machine_instances") ContainerRegistry.getInstance().addResourceType( self.ResourceTypes.QualityInstanceContainer) ContainerRegistry.getInstance().addResourceType( self.ResourceTypes.VariantInstanceContainer) ContainerRegistry.getInstance().addResourceType( self.ResourceTypes.MaterialInstanceContainer) ContainerRegistry.getInstance().addResourceType( self.ResourceTypes.UserInstanceContainer) ContainerRegistry.getInstance().addResourceType( self.ResourceTypes.ExtruderStack) ContainerRegistry.getInstance().addResourceType( self.ResourceTypes.MachineStack) # Add empty variant, material and quality containers. # Since they are empty, they should never be serialized and instead just programmatically created. # We need them to simplify the switching between materials. empty_container = ContainerRegistry.getInstance( ).getEmptyInstanceContainer() empty_variant_container = copy.deepcopy(empty_container) empty_variant_container._id = "empty_variant" empty_variant_container.addMetaDataEntry("type", "variant") ContainerRegistry.getInstance().addContainer(empty_variant_container) empty_material_container = copy.deepcopy(empty_container) empty_material_container._id = "empty_material" empty_material_container.addMetaDataEntry("type", "material") ContainerRegistry.getInstance().addContainer(empty_material_container) empty_quality_container = copy.deepcopy(empty_container) empty_quality_container._id = "empty_quality" empty_quality_container.addMetaDataEntry("type", "quality") ContainerRegistry.getInstance().addContainer(empty_quality_container) ContainerRegistry.getInstance().load() Preferences.getInstance().addPreference("cura/active_mode", "simple") Preferences.getInstance().addPreference("cura/recent_files", "") Preferences.getInstance().addPreference("cura/categories_expanded", "") Preferences.getInstance().addPreference("cura/jobname_prefix", True) Preferences.getInstance().addPreference("view/center_on_select", True) Preferences.getInstance().addPreference("mesh/scale_to_fit", True) Preferences.getInstance().addPreference("mesh/scale_tiny_meshes", True) Preferences.getInstance().setDefault("local_file/last_used_type", "text/x-gcode") Preferences.getInstance().setDefault( "general/visible_settings", """ machine_settings resolution layer_height shell wall_thickness top_bottom_thickness infill infill_sparse_density material material_print_temperature material_bed_temperature material_diameter material_flow retraction_enable speed speed_print speed_travel travel cooling cool_fan_enabled support support_enable support_type support_roof_density platform_adhesion adhesion_type brim_width raft_airgap layer_0_z_overlap raft_surface_layers meshfix blackmagic print_sequence dual experimental """.replace("\n", ";").replace(" ", "")) JobQueue.getInstance().jobFinished.connect(self._onJobFinished) self.applicationShuttingDown.connect(self.saveSettings) self._recent_files = [] files = Preferences.getInstance().getValue("cura/recent_files").split( ";") for f in files: if not os.path.isfile(f): continue self._recent_files.append(QUrl.fromLocalFile(f))
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 _updateRelations(self, definition: SettingDefinition): for property in SettingDefinition.getPropertyNames(DefinitionPropertyType.Function): self._processFunction(definition, property) for child in definition.children: self._updateRelations(child)
def _onContainerLoadComplete(self, container_id): container = ContainerRegistry.getInstance().findContainers( id=container_id)[0] if not isinstance(container, DefinitionContainer): # skip containers that are not definitions return if container.getMetaDataEntry("type") == "extruder": # skip extruder definitions return material_settings_category = container.findDefinitions(key="material") klipper_settings_category = container.findDefinitions( key=self._category_key) if material_settings_category and not klipper_settings_category: # this machine doesn't have a GCODE Offset setting yet material_settings_category = material_settings_category[0] klipper_settings_category = SettingDefinition( self._category_key, container, None, self._i18n_catalog) category_dict = self._category_dict category_dict["children"] = OrderedDict() klipper_gcode_offset_definition = SettingDefinition( self._setting_k_g_offset_key, container, klipper_settings_category, self._i18n_catalog) klipper_gcode_offset_definition.deserialize( self._setting_k_g_offset_dict) klipper_pa_definition = SettingDefinition( self._setting_k_pa_key, container, klipper_settings_category, self._i18n_catalog) klipper_pa_definition.deserialize(self._setting_k_pa_dict) klipper_pa_l_definition = SettingDefinition( self._setting_k_pa_l_key, container, klipper_settings_category, self._i18n_catalog) klipper_pa_l_definition.deserialize(self._setting_k_pa_l_dict) category_dict["children"][ self._setting_k_g_offset_key] = self._setting_k_g_offset_dict category_dict["children"][ self._setting_k_pa_key] = self._setting_k_pa_dict category_dict["children"][ self._setting_k_pa_l_key] = self._setting_k_pa_l_dict klipper_settings_category.deserialize(category_dict) container.addDefinition(klipper_settings_category) container._updateRelations(klipper_settings_category)
def _onContainerLoadComplete(self, container_id): container = ContainerRegistry.getInstance().findContainers( id=container_id)[0] if not isinstance(container, DefinitionContainer): # skip containers that are not definitions return if container.getMetaDataEntry("type") == "extruder": # skip extruder definitions return material_category1 = container.findDefinitions( key="material") # Pressure Advance material_category2 = container.findDefinitions( key="material") # Pressure Advance Lookahead speed_category1 = container.findDefinitions( key="speed") # square corner velocity speed_category4 = container.findDefinitions( key="speed") # acceleration speed_category2 = container.findDefinitions( key="speed") # acceleration to deceleration speed_category3 = container.findDefinitions( key="speed") # acceleration order pressure_advance_setting = container.findDefinitions( key=self._setting_key_klipper_pressure_advance) pressure_advance_lookahead_setting = container.findDefinitions( key=self._setting_key_klipper_pressure_advance_lookahead) square_corner_velocity_setting = container.findDefinitions( key=self._setting_key_square_corner_velocity) acceleration_setting = container.findDefinitions( key=self._setting_key_klipper_acceleration) acceleration_to_deceleration_setting = container.findDefinitions( key=self._setting_key_klipper_acceleration_to_deceleration) acceleration_order_setting = container.findDefinitions( key=self._setting_key_klipper_acceleration_order) # Pressure Advance Lookahead if material_category2 and not pressure_advance_lookahead_setting: # this machine doesn't have a Pressure Advance setting yet material_category2 = material_category2[0] pressure_advance_lookahead_definition = SettingDefinition( self._setting_key_klipper_pressure_advance_lookahead, container, material_category2, self._i18n_catalog) pressure_advance_lookahead_definition.deserialize( self._setting_dict_klipper_pressure_advance_lookahead) # add the setting to the already existing PA setting definition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff material_category2._children.append( pressure_advance_lookahead_definition) container._definition_cache[ self. _setting_key_klipper_pressure_advance_lookahead] = pressure_advance_lookahead_definition container._updateRelations(pressure_advance_lookahead_definition) # Pressure Advance if material_category1 and not pressure_advance_setting: # this machine doesn't have a Pressure Advance setting yet material_category1 = material_category1[0] pressure_advance_definition = SettingDefinition( self._setting_key_klipper_pressure_advance, container, material_category1, self._i18n_catalog) pressure_advance_definition.deserialize( self._setting_dict_klipper_pressure_advance) # add the setting to the already existing PA setting definition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff material_category1._children.append(pressure_advance_definition) container._definition_cache[ self. _setting_key_klipper_pressure_advance] = pressure_advance_definition container._updateRelations(pressure_advance_definition) # Square Corner Velocity if speed_category1 and not square_corner_velocity_setting: # this machine doesn't have a Square Corner Velocity setting yet speed_category1 = speed_category1[0] square_corner_velocity_definition = SettingDefinition( self._setting_key_square_corner_velocity, container, speed_category1, self._i18n_catalog) square_corner_velocity_definition.deserialize( self._setting_dict_square_corner_velocity) # add the setting to the already existing speed settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff speed_category1._children.append(square_corner_velocity_definition) container._definition_cache[ self. _setting_key_square_corner_velocity] = square_corner_velocity_definition container._updateRelations(square_corner_velocity_definition) # Acceleration if speed_category4 and not acceleration_setting: # this machine doesn't have a Acceleration setting yet speed_category4 = speed_category4[0] klipper_acceleration_definition = SettingDefinition( self._setting_key_klipper_acceleration, container, speed_category4, self._i18n_catalog) klipper_acceleration_definition.deserialize( self._setting_dict_klipper_acceleration) # add the setting to the already existing speed settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff speed_category4._children.append(klipper_acceleration_definition) container._definition_cache[ self. _setting_key_klipper_acceleration] = klipper_acceleration_definition container._updateRelations(klipper_acceleration_definition) # Acceleration to Deceleration if speed_category2 and not acceleration_to_deceleration_setting: # this machine doesn't have a Acceleration to deceleration setting yet speed_category2 = speed_category2[0] klipper_acceleration_to_deceleration_definition = SettingDefinition( self._setting_key_klipper_acceleration_to_deceleration, container, speed_category2, self._i18n_catalog) klipper_acceleration_to_deceleration_definition.deserialize( self._setting_dict_klipper_acceleration_to_deceleration) # add the setting to the already existing speed settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff speed_category2._children.append( klipper_acceleration_to_deceleration_definition) container._definition_cache[ self. _setting_key_klipper_acceleration_to_deceleration] = klipper_acceleration_to_deceleration_definition container._updateRelations( klipper_acceleration_to_deceleration_definition) # Acceleration Order if speed_category3 and not acceleration_order_setting: # this machine doesn't have a Acceleration to deceleration setting yet speed_category3 = speed_category3[0] klipper_acceleration_order_definition = SettingDefinition( self._setting_key_klipper_acceleration_order, container, speed_category3, self._i18n_catalog) klipper_acceleration_order_definition.deserialize( self._setting_dict_klipper_acceleration_order) # add the setting to the already existing speed settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff speed_category3._children.append( klipper_acceleration_order_definition) container._definition_cache[ self. _setting_key_klipper_acceleration_order] = klipper_acceleration_order_definition container._updateRelations(klipper_acceleration_order_definition)
import os import sys import json from UM.Settings.SettingDefinition import SettingDefinition, DefinitionPropertyType from UM.Settings.Validator import Validator from UM.Settings.DefinitionContainer import DefinitionContainer if len(sys.argv) < 3: print("Usage: query.py [file] [query]") exit(1) file_path = sys.argv[1] # These are defined by Cura but we would still like to be able to query them. SettingDefinition.addSupportedProperty("settable_per_mesh", DefinitionPropertyType.Any, default = True, read_only = True) SettingDefinition.addSupportedProperty("settable_per_extruder", DefinitionPropertyType.Any, default = True, read_only = True) SettingDefinition.addSupportedProperty("settable_per_meshgroup", DefinitionPropertyType.Any, default = True, read_only = True) SettingDefinition.addSupportedProperty("settable_globally", DefinitionPropertyType.Any, default = True, read_only = True) SettingDefinition.addSupportedProperty("limit_to_extruder", DefinitionPropertyType.Function, default = "-1") SettingDefinition.addSupportedProperty("resolve", DefinitionPropertyType.Function, default = None) SettingDefinition.addSettingType("extruder", None, str, Validator) definition = DefinitionContainer(os.path.basename(file_path)) with open(file_path, encoding = "utf-8") as f: definition.deserialize(f.read()) query = json.loads(sys.argv[2]) results = definition.findDefinitions(**query)
def __init__(self): Resources.addSearchPath( os.path.join(QtApplication.getInstallPrefix(), "share", "cura", "resources")) if not hasattr(sys, "frozen"): Resources.addSearchPath( os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "resources")) self._open_file_queue = [] # Files to open when plug-ins are loaded. # Need to do this before ContainerRegistry tries to load the machines SettingDefinition.addSupportedProperty("settable_per_mesh", DefinitionPropertyType.Any, default=True, read_only=True) SettingDefinition.addSupportedProperty("settable_per_extruder", DefinitionPropertyType.Any, default=True, read_only=True) # this setting can be changed for each group in one-at-a-time mode SettingDefinition.addSupportedProperty("settable_per_meshgroup", DefinitionPropertyType.Any, default=True, read_only=True) SettingDefinition.addSupportedProperty("settable_globally", DefinitionPropertyType.Any, default=True, read_only=True) # From which stack the setting would inherit if not defined per object (handled in the engine) # AND for settings which are not settable_per_mesh: # which extruder is the only extruder this setting is obtained from SettingDefinition.addSupportedProperty("limit_to_extruder", DefinitionPropertyType.Function, default="-1") # For settings which are not settable_per_mesh and not settable_per_extruder: # A function which determines the glabel/meshgroup value by looking at the values of the setting in all (used) extruders SettingDefinition.addSupportedProperty("resolve", DefinitionPropertyType.Function, default=None) SettingDefinition.addSettingType("extruder", None, str, Validator) SettingFunction.registerOperator( "extruderValues", cura.Settings.ExtruderManager.getExtruderValues) SettingFunction.registerOperator( "extruderValue", cura.Settings.ExtruderManager.getExtruderValue) SettingFunction.registerOperator( "resolveOrValue", cura.Settings.ExtruderManager.getResolveOrValue) ## Add the 4 types of profiles to storage. Resources.addStorageType(self.ResourceTypes.QualityInstanceContainer, "quality") Resources.addStorageType(self.ResourceTypes.VariantInstanceContainer, "variants") Resources.addStorageType(self.ResourceTypes.MaterialInstanceContainer, "materials") Resources.addStorageType(self.ResourceTypes.UserInstanceContainer, "user") Resources.addStorageType(self.ResourceTypes.ExtruderStack, "extruders") Resources.addStorageType(self.ResourceTypes.MachineStack, "machine_instances") ContainerRegistry.getInstance().addResourceType( self.ResourceTypes.QualityInstanceContainer) ContainerRegistry.getInstance().addResourceType( self.ResourceTypes.VariantInstanceContainer) ContainerRegistry.getInstance().addResourceType( self.ResourceTypes.MaterialInstanceContainer) ContainerRegistry.getInstance().addResourceType( self.ResourceTypes.UserInstanceContainer) ContainerRegistry.getInstance().addResourceType( self.ResourceTypes.ExtruderStack) ContainerRegistry.getInstance().addResourceType( self.ResourceTypes.MachineStack) ## Initialise the version upgrade manager with Cura's storage paths. import UM.VersionUpgradeManager #Needs to be here to prevent circular dependencies. UM.VersionUpgradeManager.VersionUpgradeManager.getInstance( ).setCurrentVersions({ ("quality", UM.Settings.InstanceContainer.Version): (self.ResourceTypes.QualityInstanceContainer, "application/x-uranium-instancecontainer"), ("machine_stack", UM.Settings.ContainerStack.Version): (self.ResourceTypes.MachineStack, "application/x-uranium-containerstack"), ("preferences", UM.Preferences.Version): (Resources.Preferences, "application/x-uranium-preferences"), ("user", UM.Settings.InstanceContainer.Version): (self.ResourceTypes.UserInstanceContainer, "application/x-uranium-instancecontainer") }) self._machine_action_manager = MachineActionManager.MachineActionManager( ) self._machine_manager = None # This is initialized on demand. self._setting_inheritance_manager = None self._additional_components = { } # Components to add to certain areas in the interface super().__init__(name="cura", version=CuraVersion, buildtype=CuraBuildType) self.setWindowIcon( QIcon(Resources.getPath(Resources.Images, "cura-icon.png"))) self.setRequiredPlugins([ "CuraEngineBackend", "MeshView", "LayerView", "STLReader", "SelectionTool", "CameraTool", "GCodeWriter", "LocalFileOutputDevice" ]) self._physics = None self._volume = None self._output_devices = {} self._print_information = None self._previous_active_tool = None self._platform_activity = False self._scene_bounding_box = AxisAlignedBox.Null self._job_name = None self._center_after_select = False self._camera_animation = None self._cura_actions = None self._started = False self._message_box_callback = None self._message_box_callback_arguments = [] self._i18n_catalog = i18nCatalog("cura") self.getController().getScene().sceneChanged.connect( self.updatePlatformActivity) self.getController().toolOperationStopped.connect( self._onToolOperationStopped) Resources.addType(self.ResourceTypes.QmlFiles, "qml") Resources.addType(self.ResourceTypes.Firmware, "firmware") self.showSplashMessage( self._i18n_catalog.i18nc("@info:progress", "Loading machines...")) # Add empty variant, material and quality containers. # Since they are empty, they should never be serialized and instead just programmatically created. # We need them to simplify the switching between materials. empty_container = ContainerRegistry.getInstance( ).getEmptyInstanceContainer() empty_variant_container = copy.deepcopy(empty_container) empty_variant_container._id = "empty_variant" empty_variant_container.addMetaDataEntry("type", "variant") ContainerRegistry.getInstance().addContainer(empty_variant_container) empty_material_container = copy.deepcopy(empty_container) empty_material_container._id = "empty_material" empty_material_container.addMetaDataEntry("type", "material") ContainerRegistry.getInstance().addContainer(empty_material_container) empty_quality_container = copy.deepcopy(empty_container) empty_quality_container._id = "empty_quality" empty_quality_container.setName("Not supported") empty_quality_container.addMetaDataEntry("quality_type", "normal") empty_quality_container.addMetaDataEntry("type", "quality") ContainerRegistry.getInstance().addContainer(empty_quality_container) empty_quality_changes_container = copy.deepcopy(empty_container) empty_quality_changes_container._id = "empty_quality_changes" empty_quality_changes_container.addMetaDataEntry( "type", "quality_changes") ContainerRegistry.getInstance().addContainer( empty_quality_changes_container) # Set the filename to create if cura is writing in the config dir. self._config_lock_filename = os.path.join( Resources.getConfigStoragePath(), CONFIG_LOCK_FILENAME) self.waitConfigLockFile() ContainerRegistry.getInstance().load() Preferences.getInstance().addPreference("cura/active_mode", "simple") Preferences.getInstance().addPreference("cura/recent_files", "") Preferences.getInstance().addPreference("cura/categories_expanded", "") Preferences.getInstance().addPreference("cura/jobname_prefix", True) Preferences.getInstance().addPreference("view/center_on_select", True) Preferences.getInstance().addPreference("mesh/scale_to_fit", True) Preferences.getInstance().addPreference("mesh/scale_tiny_meshes", True) for key in [ "dialog_load_path", # dialog_save_path is in LocalFileOutputDevicePlugin "dialog_profile_path", "dialog_material_path" ]: Preferences.getInstance().addPreference("local_file/%s" % key, os.path.expanduser("~/")) Preferences.getInstance().setDefault("local_file/last_used_type", "text/x-gcode") Preferences.getInstance().setDefault( "general/visible_settings", """ machine_settings resolution layer_height shell wall_thickness top_bottom_thickness infill infill_sparse_density material material_print_temperature material_bed_temperature material_diameter material_flow retraction_enable speed speed_print speed_travel acceleration_print acceleration_travel jerk_print jerk_travel travel cooling cool_fan_enabled support support_enable support_extruder_nr support_type support_interface_density platform_adhesion adhesion_type adhesion_extruder_nr brim_width raft_airgap layer_0_z_overlap raft_surface_layers dual prime_tower_enable prime_tower_size prime_tower_position_x prime_tower_position_y meshfix blackmagic print_sequence infill_mesh experimental """.replace("\n", ";").replace(" ", "")) JobQueue.getInstance().jobFinished.connect(self._onJobFinished) self.applicationShuttingDown.connect(self.saveSettings) self.engineCreatedSignal.connect(self._onEngineCreated) self._recent_files = [] files = Preferences.getInstance().getValue("cura/recent_files").split( ";") for f in files: if not os.path.isfile(f): continue self._recent_files.append(QUrl.fromLocalFile(f))
def _onContainerLoadComplete(self, container_id: str) -> None: if not ContainerRegistry.getInstance().isLoaded(container_id): # skip containers that could not be loaded, or subsequent findContainers() will cause an infinite loop return try: container = ContainerRegistry.getInstance().findContainers( id=container_id)[0] except IndexError: # the container no longer exists return if not isinstance(container, DefinitionContainer): # skip containers that are not definitions return if container.getMetaDataEntry("type") == "extruder": # skip extruder definitions return try: category = container.findDefinitions(key="blackmagic")[0] except IndexError: Logger.log( "e", "Could not find parent category setting to add settings to") return for setting_key in self._settings_dict.keys(): setting_definition = SettingDefinition(setting_key, container, category, self._i18n_catalog) setting_definition.deserialize(self._settings_dict[setting_key]) # add the setting to the already existing blackmagic settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff category._children.append(setting_definition) container._definition_cache[setting_key] = setting_definition self._expanded_categories = self._application.expandedCategories.copy( ) self._updateAddedChildren(container, setting_definition) self._application.setExpandedCategories(self._expanded_categories) self._expanded_categories.clear() container._updateRelations(setting_definition) preferences = self._application.getPreferences() if not preferences.getValue("arcwelderplugin/settings_made_visible"): setting_keys = self._getAllSettingKeys(self._settings_dict) visible_settings = preferences.getValue("general/visible_settings") visible_settings_changed = False for key in setting_keys: if key not in visible_settings: visible_settings += ";%s" % key visible_settings_changed = True if visible_settings_changed: preferences.setValue("general/visible_settings", visible_settings) preferences.setValue("arcwelderplugin/settings_made_visible", True)
html += formatKeyValueTableRow("read only", safeCall(def_container.isReadOnly), extra_class="metadata") html += formatKeyValueTableRow("path", safeCall(def_container.getPath), extra_class="metadata") html += formatKeyValueTableRow("metadata", safeCall(def_container.getMetaData), extra_class="metadata") except: pass return html setting_prop_names = SettingDefinition.getPropertyNames() def formatSettingValue(container, key, properties=None): if properties is None: properties = setting_prop_names value = "<ul class=\"property_list\">\n" comma = "" properties.sort() for prop_name in properties: prop_value = container.getProperty(key, prop_name) if prop_value is not None: value += " <li>\n" value += " <span class='prop_name'>" + encode( prop_name) + ":</span> " + encode(repr(prop_value))
def __init__(self): Resources.addSearchPath(os.path.join(QtApplication.getInstallPrefix(), "share", "cura", "resources")) if not hasattr(sys, "frozen"): Resources.addSearchPath(os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "resources")) self._open_file_queue = [] # Files to open when plug-ins are loaded. # Need to do this before ContainerRegistry tries to load the machines SettingDefinition.addSupportedProperty("global_only", DefinitionPropertyType.Function, default = False) SettingDefinition.addSettingType("extruder", int, str, UM.Settings.Validator) super().__init__(name = "cura", version = CuraVersion, buildtype = CuraBuildType) self.setWindowIcon(QIcon(Resources.getPath(Resources.Images, "cura-icon.png"))) self.setRequiredPlugins([ "CuraEngineBackend", "MeshView", "LayerView", "STLReader", "SelectionTool", "CameraTool", "GCodeWriter", "LocalFileOutputDevice" ]) self._physics = None self._volume = None self._platform = None self._output_devices = {} self._print_information = None self._i18n_catalog = None self._previous_active_tool = None self._platform_activity = False self._scene_bounding_box = AxisAlignedBox() self._job_name = None self._center_after_select = False self._camera_animation = None self._cura_actions = None self._started = False self.getController().getScene().sceneChanged.connect(self.updatePlatformActivity) self.getController().toolOperationStopped.connect(self._onToolOperationStopped) Resources.addType(self.ResourceTypes.QmlFiles, "qml") Resources.addType(self.ResourceTypes.Firmware, "firmware") ## Add the 4 types of profiles to storage. Resources.addStorageType(self.ResourceTypes.QualityInstanceContainer, "quality") Resources.addStorageType(self.ResourceTypes.VariantInstanceContainer, "variants") Resources.addStorageType(self.ResourceTypes.MaterialInstanceContainer, "materials") Resources.addStorageType(self.ResourceTypes.UserInstanceContainer, "user") Resources.addStorageType(self.ResourceTypes.ExtruderStack, "extruders") Resources.addStorageType(self.ResourceTypes.MachineStack, "machine_instances") ContainerRegistry.getInstance().addResourceType(self.ResourceTypes.QualityInstanceContainer) ContainerRegistry.getInstance().addResourceType(self.ResourceTypes.VariantInstanceContainer) ContainerRegistry.getInstance().addResourceType(self.ResourceTypes.MaterialInstanceContainer) ContainerRegistry.getInstance().addResourceType(self.ResourceTypes.UserInstanceContainer) ContainerRegistry.getInstance().addResourceType(self.ResourceTypes.ExtruderStack) ContainerRegistry.getInstance().addResourceType(self.ResourceTypes.MachineStack) # Add empty variant, material and quality containers. # Since they are empty, they should never be serialized and instead just programmatically created. # We need them to simplify the switching between materials. empty_container = ContainerRegistry.getInstance().getEmptyInstanceContainer() empty_variant_container = copy.deepcopy(empty_container) empty_variant_container._id = "empty_variant" empty_variant_container.addMetaDataEntry("type", "variant") ContainerRegistry.getInstance().addContainer(empty_variant_container) empty_material_container = copy.deepcopy(empty_container) empty_material_container._id = "empty_material" empty_material_container.addMetaDataEntry("type", "material") ContainerRegistry.getInstance().addContainer(empty_material_container) empty_quality_container = copy.deepcopy(empty_container) empty_quality_container._id = "empty_quality" empty_quality_container.addMetaDataEntry("type", "quality") ContainerRegistry.getInstance().addContainer(empty_quality_container) ContainerRegistry.getInstance().load() Preferences.getInstance().addPreference("cura/active_mode", "simple") Preferences.getInstance().addPreference("cura/recent_files", "") Preferences.getInstance().addPreference("cura/categories_expanded", "") Preferences.getInstance().addPreference("cura/jobname_prefix", True) Preferences.getInstance().addPreference("view/center_on_select", True) Preferences.getInstance().addPreference("mesh/scale_to_fit", True) Preferences.getInstance().addPreference("mesh/scale_tiny_meshes", True) Preferences.getInstance().setDefault("local_file/last_used_type", "text/x-gcode") Preferences.getInstance().setDefault("general/visible_settings", """ machine_settings resolution layer_height shell wall_thickness top_bottom_thickness infill infill_sparse_density material material_print_temperature material_bed_temperature material_diameter material_flow retraction_enable speed speed_print speed_travel travel cooling cool_fan_enabled support support_enable support_type support_roof_density platform_adhesion adhesion_type brim_width raft_airgap layer_0_z_overlap raft_surface_layers meshfix blackmagic print_sequence dual experimental """.replace("\n", ";").replace(" ", "")) JobQueue.getInstance().jobFinished.connect(self._onJobFinished) self.applicationShuttingDown.connect(self.saveSettings) self._recent_files = [] files = Preferences.getInstance().getValue("cura/recent_files").split(";") for f in files: if not os.path.isfile(f): continue self._recent_files.append(QUrl.fromLocalFile(f))