def _parsePluginInfo(self, plugin_id, file_data, meta_data):
try:
meta_data["plugin"] = json.loads(file_data)
except json.decoder.JSONDecodeError:
Logger.logException("e", "Failed to parse plugin.json for plugin %s", plugin_id)
raise InvalidMetaDataError(plugin_id)
# Check if metadata is valid;
if "version" not in meta_data["plugin"]:
Logger.log("e", "Version must be set!")
raise InvalidMetaDataError(plugin_id)
# Check if the plugin states what API version it needs.
if "api" not in meta_data["plugin"] and "supported_sdk_versions" not in meta_data["plugin"]:
Logger.log("e", "The API or the supported_sdk_versions must be set!")
raise InvalidMetaDataError(plugin_id)
else:
# Store the api_version as a Version object.
all_supported_sdk_versions = [] # type: List[Version]
if "supported_sdk_versions" in meta_data["plugin"]:
all_supported_sdk_versions += [Version(supported_version) for supported_version in
meta_data["plugin"]["supported_sdk_versions"]]
if "api" in meta_data["plugin"]:
all_supported_sdk_versions += [Version(meta_data["plugin"]["api"])]
meta_data["plugin"]["supported_sdk_versions"] = all_supported_sdk_versions
if "i18n-catalog" in meta_data["plugin"]:
# A catalog was set, try to translate a few strings
i18n_catalog = i18nCatalog(meta_data["plugin"]["i18n-catalog"])
if "name" in meta_data["plugin"]:
meta_data["plugin"]["name"] = i18n_catalog.i18n(meta_data["plugin"]["name"])
if "description" in meta_data["plugin"]:
meta_data["plugin"]["description"] = i18n_catalog.i18n(meta_data["plugin"]["description"])
def loadSettingsFromFile(self, file_name):
with open(file_name, "rt", -1, "utf-8") as f:
data = json.load(f, object_pairs_hook=collections.OrderedDict)
self._i18n_catalog = i18nCatalog(os.path.basename(file_name))
self._json_file = file_name
if "id" in data:
self._type_id = data["id"]
if "platform" in data:
self._platform_mesh = data["platform"]
if "platform_texture" in data:
self._platform_texture = data["platform_texture"]
if "name" in data:
self._type_name = data["name"]
if "version" in data:
self._type_version = str(data["version"])
if "icon" in data:
self._icon = data["icon"]
if "inherits" in data:
inherits_from = MachineSettings()
inherits_from.loadSettingsFromFile(os.path.dirname(file_name) + "/" + data["inherits"])
self._machine_settings = inherits_from._machine_settings
self._categories = inherits_from._categories
if "machine_settings" in data:
for key, value in data["machine_settings"].items():
setting = self.getSettingByKey(key)
if not setting:
setting = Setting(key, self._i18n_catalog)
self.addSetting(setting)
setting.fillByDict(value)
if "categories" in data:
for key, value in data["categories"].items():
category = self.getSettingsCategory(key)
if not category:
category = SettingsCategory(key, self._i18n_catalog, self)
self.addSettingsCategory(category)
category.fillByDict(value)
if "overrides" in data:
for key, value in data["overrides"].items():
setting = self.getSettingByKey(key)
if not setting:
continue
setting.fillByDict(value)
for setting in self.getAllSettings():
setting.valueChanged.connect(self.settingChanged)
self.settingsLoaded.emit() #Emit signal that all settings are loaded (some setting stuff can only be done when all settings are loaded (eg; the conditional stuff)
def createMaterial(self) -> str:
from UM.i18n import i18nCatalog
catalog = i18nCatalog("cura")
# Ensure all settings are saved.
self._application.saveSettings()
machine_manager = self._application.getMachineManager()
extruder_stack = machine_manager.activeStack
approximate_diameter = str(extruder_stack.approximateMaterialDiameter)
root_material_id = "generic_pla"
root_material_id = self.getRootMaterialIDForDiameter(root_material_id, approximate_diameter)
material_group = self.getMaterialGroup(root_material_id)
# Create a new ID & container to hold the data.
new_id = self._container_registry.uniqueName("custom_material")
new_metadata = {"name": catalog.i18nc("@label", "Custom Material"),
"brand": catalog.i18nc("@label", "Custom"),
"GUID": str(uuid.uuid4()),
}
self.duplicateMaterial(material_group.root_material_node,
new_base_id = new_id,
new_metadata = new_metadata)
return new_id
def __init__(self, **kwargs):
plugin_path = ""
if sys.platform == "win32":
if hasattr(sys, "frozen"):
plugin_path = os.path.join(os.path.dirname(os.path.abspath(sys.executable)), "PyQt5", "plugins")
Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path))
QCoreApplication.addLibraryPath(plugin_path)
else:
import site
for dir in site.getsitepackages():
QCoreApplication.addLibraryPath(os.path.join(dir, "PyQt5", "plugins"))
elif sys.platform == "darwin":
plugin_path = os.path.join(Application.getInstallPrefix(), "Resources", "plugins")
if plugin_path:
Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path))
QCoreApplication.addLibraryPath(plugin_path)
os.environ["QSG_RENDER_LOOP"] = "basic"
super().__init__(sys.argv, **kwargs)
self._plugins_loaded = False #Used to determine when it's safe to use the plug-ins.
self._main_qml = "main.qml"
self._engine = None
self._renderer = None
self._main_window = None
self._shutting_down = False
self._qml_import_paths = []
self._qml_import_paths.append(os.path.join(os.path.dirname(sys.executable), "qml"))
self._qml_import_paths.append(os.path.join(Application.getInstallPrefix(), "Resources", "qml"))
self.setAttribute(Qt.AA_UseDesktopOpenGL)
try:
self._splash = self._createSplashScreen()
except FileNotFoundError:
self._splash = None
else:
self._splash.show()
self.processEvents()
signal.signal(signal.SIGINT, signal.SIG_DFL)
# This is done here as a lot of plugins require a correct gl context. If you want to change the framework,
# these checks need to be done in your <framework>Application.py class __init__().
i18n_catalog = i18nCatalog("uranium")
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading plugins..."))
self._loadPlugins()
self.parseCommandLine()
Logger.log("i", "Command line arguments: %s", self._parsed_command_line)
self._plugin_registry.checkRequiredPlugins(self.getRequiredPlugins())
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading preferences..."))
try:
file = Resources.getPath(Resources.Preferences, self.getApplicationName() + ".cfg")
Preferences.getInstance().readFromFile(file)
except FileNotFoundError:
pass
def _update(self) -> None:
if not self._container:
return
# Try and find a translation catalog for the definition
for file_name in self._container.getInheritedFiles():
catalog = i18nCatalog(os.path.basename(file_name))
if catalog.hasTranslationLoaded():
self._i18n_catalog = catalog
if self._root:
new_definitions = self._root.findDefinitions()
else:
new_definitions = self._container.findDefinitions()
# Check if a full reset is required
if len(new_definitions) != len(self._definition_list):
self.beginResetModel()
self._definition_list = new_definitions
self._row_index_list.clear()
self._scheduleUpdateVisibleRows()
self.endResetModel()
else:
# If the length hasn't changed, we can just notify that the data was changed. This will prevent the existing
# QML setting items from being re-created every you switch between machines.
self._definition_list = new_definitions
self._scheduleUpdateVisibleRows()
self.dataChanged.emit(self.index(0, 0), self.index(len(self._definition_list) - 1, 0))
def createMaterial(self) -> str:
from UM.i18n import i18nCatalog
catalog = i18nCatalog("cura")
# Ensure all settings are saved.
self._application.saveSettings()
machine_manager = self._application.getMachineManager()
extruder_stack = machine_manager.activeStack
machine_definition = self._application.getGlobalContainerStack().definition
preferred_material = machine_definition.getMetaDataEntry("preferred_material")
approximate_diameter = str(extruder_stack.approximateMaterialDiameter)
root_material_id = preferred_material if preferred_material else "generic_pla"
root_material_id = self.getRootMaterialIDForDiameter(root_material_id, approximate_diameter)
material_group = self.getMaterialGroup(root_material_id)
if not material_group: # This should never happen
Logger.log("w", "Cannot get the material group of %s.", root_material_id)
return ""
# Create a new ID & container to hold the data.
new_id = self._container_registry.uniqueName("custom_material")
new_metadata = {"name": catalog.i18nc("@label", "Custom Material"),
"brand": catalog.i18nc("@label", "Custom"),
"GUID": str(uuid.uuid4()),
}
self.duplicateMaterial(material_group.root_material_node,
new_base_id = new_id,
new_metadata = new_metadata)
return new_id
def run(self):
self._i18n_catalog = i18nCatalog("cura");
i18nCatalog.setTagReplacements({
"filename": "font color=\"black\"",
"message": "font color=UM.Theme.colors.message_text;",
})
self.showSplashMessage(self._i18n_catalog.i18nc("@info:progress", "Setting up scene..."))
controller = self.getController()
controller.setActiveView("SolidView")
controller.setCameraTool("CameraTool")
controller.setSelectionTool("SelectionTool")
t = controller.getTool("TranslateTool")
if t:
t.setEnabledAxis([ToolHandle.XAxis, ToolHandle.YAxis,ToolHandle.ZAxis])
Selection.selectionChanged.connect(self.onSelectionChanged)
root = controller.getScene().getRoot()
self._platform = Platform(root)
self._volume = BuildVolume.BuildVolume(root)
self.getRenderer().setBackgroundColor(QColor(245, 245, 245))
self._physics = PlatformPhysics.PlatformPhysics(controller, self._volume)
camera = Camera("3d", root)
camera.setPosition(Vector(-80, 250, 700))
camera.setPerspective(True)
camera.lookAt(Vector(0, 0, 0))
controller.getScene().setActiveCamera("3d")
self.getController().getTool("CameraTool").setOrigin(Vector(0, 100, 0))
self._camera_animation = CameraAnimation.CameraAnimation()
self._camera_animation.setCameraTool(self.getController().getTool("CameraTool"))
self.showSplashMessage(self._i18n_catalog.i18nc("@info:progress", "Loading interface..."))
qmlRegisterSingletonType(MachineManagerModel.MachineManagerModel, "Cura", 1, 0, "MachineManager",
MachineManagerModel.createMachineManagerModel)
self.setMainQml(Resources.getPath(self.ResourceTypes.QmlFiles, "Cura.qml"))
self.initializeEngine()
if self._engine.rootObjects:
self.closeSplash()
for file in self.getCommandLineOption("file", []):
self._openFile(file)
for file_name in self._open_file_queue: #Open all the files that were queued up while plug-ins were loading.
self._openFile(file_name)
self.exec_()
def run(self):
self._i18n_catalog = i18nCatalog("cura");
i18nCatalog.setTagReplacements({
"filename": "font color=\"black\"",
"message": "font color=UM.Theme.colors.message_text;",
})
self.showSplashMessage(self._i18n_catalog.i18nc("Splash screen message", "Setting up scene..."))
controller = self.getController()
controller.setActiveView("MeshView")
controller.setCameraTool("CameraTool")
controller.setSelectionTool("SelectionTool")
t = controller.getTool("TranslateTool")
if t:
t.setEnabledAxis([ToolHandle.XAxis, ToolHandle.YAxis,ToolHandle.ZAxis])
Selection.selectionChanged.connect(self.onSelectionChanged)
root = controller.getScene().getRoot()
self._platform = Platform(root)
self._volume = BuildVolume.BuildVolume(root)
self.getRenderer().setLightPosition(Vector(0, 150, 0))
self.getRenderer().setBackgroundColor(QColor(245, 245, 245))
self._physics = PlatformPhysics.PlatformPhysics(controller, self._volume)
camera = Camera("3d", root)
camera.setPosition(Vector(-150, 150, 300))
camera.setPerspective(True)
camera.lookAt(Vector(0, 0, 0))
self._camera_animation = CameraAnimation.CameraAnimation()
self._camera_animation.setCameraTool(self.getController().getTool("CameraTool"))
controller.getScene().setActiveCamera("3d")
self.showSplashMessage(self._i18n_catalog.i18nc("Splash screen message", "Loading interface..."))
self.setMainQml(Resources.getPath(self.ResourceTypes.QmlFiles, "Cura.qml"))
self.initializeEngine()
manager = self.getMachineManager()
if not self.getMachineManager().getMachineInstances():
self.requestAddPrinter.emit()
if self._engine.rootObjects:
self.closeSplash()
for file in self.getCommandLineOption("file", []):
self._openFile(file)
self.exec_()
def run(self):
if "PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION" not in os.environ or os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] != "cpp":
Logger.log("w", "Using Python implementation of Protobuf, expect bad performance!")
self._i18n_catalog = i18nCatalog("cura");
i18nCatalog.setTagReplacements({
"filename": "font color=\"black\"",
"message": "font color=UM.Theme.colors.message_text;",
})
self.showSplashMessage(self._i18n_catalog.i18nc("@info:progress", "Setting up scene..."))
controller = self.getController()
controller.setActiveView("MeshView")
controller.setCameraTool("CameraTool")
controller.setSelectionTool("SelectionTool")
t = controller.getTool("TranslateTool")
if t:
t.setEnabledAxis([ToolHandle.XAxis, ToolHandle.YAxis,ToolHandle.ZAxis])
Selection.selectionChanged.connect(self.onSelectionChanged)
root = controller.getScene().getRoot()
self._platform = Platform(root)
self._volume = BuildVolume.BuildVolume(root)
self.getRenderer().setLightPosition(Vector(0, 150, 0))
self.getRenderer().setBackgroundColor(QColor(245, 245, 245))
self._physics = PlatformPhysics.PlatformPhysics(controller, self._volume)
camera = Camera("3d", root)
camera.setPosition(Vector(-80, 250, 700))
camera.setPerspective(True)
camera.lookAt(Vector(0, 0, 0))
controller.getScene().setActiveCamera("3d")
self.getController().getTool("CameraTool").setOrigin(Vector(0, 100, 0))
self._camera_animation = CameraAnimation.CameraAnimation()
self._camera_animation.setCameraTool(self.getController().getTool("CameraTool"))
self.showSplashMessage(self._i18n_catalog.i18nc("@info:progress", "Loading interface..."))
self.setMainQml(Resources.getPath(self.ResourceTypes.QmlFiles, "Cura.qml"))
self.initializeEngine()
if self._engine.rootObjects:
self.closeSplash()
for file in self.getCommandLineOption("file", []):
self._openFile(file)
self.exec_()
def __init__(self, **kwargs):
plugin_path = ""
if sys.platform == "win32":
plugin_path = os.path.join(os.path.dirname(os.path.abspath(sys.executable)), "PyQt5", "plugins")
Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path))
QCoreApplication.addLibraryPath(plugin_path)
elif sys.platform == "darwin":
plugin_path = os.path.join(Application.getInstallPrefix(), "Resources", "plugins")
if plugin_path:
Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path))
QCoreApplication.addLibraryPath(plugin_path)
os.environ["QSG_RENDER_LOOP"] = "basic"
super().__init__(sys.argv, **kwargs)
self._main_qml = "main.qml"
self._engine = None
self._renderer = None
self.setAttribute(Qt.AA_UseDesktopOpenGL)
try:
self._splash = QSplashScreen(QPixmap(Resources.getPath(Resources.ImagesLocation, self.getApplicationName() + ".png")))
except FileNotFoundError:
self._splash = None
else:
self._splash.show()
self.processEvents()
signal.signal(signal.SIGINT, signal.SIG_DFL)
# This is done here as a lot of plugins require a correct gl context. If you want to change the framework,
# these checks need to be done in your <framework>Application.py class __init__().
i18n_catalog = i18nCatalog("uranium")
self.showSplashMessage(i18n_catalog.i18nc("Splash screen message", "Loading plugins..."))
self._loadPlugins()
self._plugin_registry.checkRequiredPlugins(self.getRequiredPlugins())
self.showSplashMessage(i18n_catalog.i18nc("Splash screen message", "Loading machines..."))
self.loadMachines()
self.showSplashMessage(i18n_catalog.i18nc("Splash screen message", "Loading preferences..."))
try:
file = Resources.getPath(Resources.PreferencesLocation, self.getApplicationName() + ".cfg")
Preferences.getInstance().readFromFile(file)
except FileNotFoundError:
pass
self._translators = {}
self.showSplashMessage(i18n_catalog.i18nc("Splash screen message", "Loading translations..."))
self.loadQtTranslation("uranium_qt")
self.loadQtTranslation(self.getApplicationName() + "_qt")
def run(self):
self._i18n_catalog = i18nCatalog("nk")
i18nCatalog.setTagReplacements({
"filename": "font color=\"black\"",
"message": "font color=UM.Theme.colors.message_text;",
})
self.showSplashMessage(self._i18n_catalog.i18nc("@info:progress", "Setting up scene..."))
controller = self.getController()
controller.setActiveView("SolidView")
controller.setCameraTool("CameraTool")
controller.setSelectionTool("SelectionTool")
t = controller.getTool("TranslateTool")
if t:
t.setEnabledAxis([ToolHandle.XAxis, ToolHandle.ZAxis])
Selection.selectionChanged.connect(self.onSelectionChanged)
root = controller.getScene().getRoot()
self._platform = Platform(root)
self._volume = BuildVolume.BuildVolume(root)
self.getRenderer().setBackgroundColor(QColor(245, 245, 245))
camera = Camera("3d", root)
camera.setPosition(Vector(-80, 950, 700))
camera.setPerspective(True)
camera.lookAt(Vector(0, 0, 0))
controller.getScene().setActiveCamera("3d")
self.getController().getTool("CameraTool").setOrigin(Vector(0, 0, 0))
self._camera_animation = CameraAnimation.CameraAnimation()
self._camera_animation.setCameraTool(self.getController().getTool("CameraTool"))
self.showSplashMessage(self._i18n_catalog.i18nc("@info:progress", "Loading interface..."))
self.setMainQml(Resources.getPath(self.ResourceTypes.QmlFiles, "NinjaKittens.qml"))
self.initializeEngine()
if self._engine.rootObjects:
self.closeSplash()
for file in self.getCommandLineOption("file", []):
self._openFile(file)
self.exec_()
def loadAll(self):
if self._loaded:
return
with open(self._path, "rt", -1, "utf-8") as f:
self._json_data = json.load(f, object_pairs_hook=collections.OrderedDict)
if not self._name:
self.loadMetaData()
self._i18n_catalog = i18nCatalog(os.path.basename(self._path))
self._platform_mesh = self._json_data.get("platform", "")
self._platform_texture = self._json_data.get("platform_texture", "")
if "inherits" in self._json_data:
inherits_from = MachineDefinition(self._machine_manager, Resources.getPath(Resources.MachineDefinitions, self._json_data["inherits"]))
inherits_from.loadAll()
self._machine_settings = inherits_from._machine_settings
self._categories = inherits_from._categories
if "machine_settings" in self._json_data:
for key, value in self._json_data["machine_settings"].items():
setting = self.getSetting(key)
if not setting:
setting = Setting(self._machine_manager, key, self._i18n_catalog)
self._machine_settings.append(setting)
setting.fillByDict(value)
if "categories" in self._json_data:
for key, value in self._json_data["categories"].items():
category = self.getSettingsCategory(key)
if not category:
category = SettingsCategory(self._machine_manager, key, self._i18n_catalog, self)
self._categories.append(category)
category.fillByDict(value)
if "overrides" in self._json_data:
for key, value in self._json_data["overrides"].items():
setting = self.getSetting(key)
if not setting:
continue
setting.fillByDict(value)
self.settingsLoaded.emit()
#self._json_data = None
self._loaded = True
def getFileNameFilters(self, io_type):
from UM.i18n import i18nCatalog
catalog = i18nCatalog("uranium")
#TODO: This function should be in UM.Resources!
filters = []
all_types = []
for plugin_id, meta_data in self._getIOPlugins(io_type):
for io_plugin in meta_data[io_type]:
filters.append(io_plugin["description"] + " (*." + io_plugin["extension"] + ")")
all_types.append("*.{0}".format(io_plugin["extension"]))
if "_reader" in io_type:
# if we're listing readers, add the option to show all supported files as the default option
filters.insert(0, catalog.i18nc("@item:inlistbox", "All Supported Types ({0})", " ".join(all_types)))
filters.append(catalog.i18nc("@item:inlistbox", "All Files (*)")) # Also allow arbitrary files, if the user so prefers.
return filters
def __init__(self, parent = None) -> None:
super().__init__(parent)
self._catalog = i18nCatalog("cura")
self.addRoleName(self.NameRole, "name")
self.addRoleName(self.IdRole, "id")
self.addRoleName(self.HasRemoteConnectionRole, "hasRemoteConnection")
self.addRoleName(self.MetaDataRole, "metadata")
self.addRoleName(self.DiscoverySourceRole, "discoverySource")
self._change_timer = QTimer()
self._change_timer.setInterval(200)
self._change_timer.setSingleShot(True)
self._change_timer.timeout.connect(self._update)
# Listen to changes
CuraContainerRegistry.getInstance().containerAdded.connect(self._onContainerChanged)
CuraContainerRegistry.getInstance().containerMetaDataChanged.connect(self._onContainerChanged)
CuraContainerRegistry.getInstance().containerRemoved.connect(self._onContainerChanged)
self._updateDelayed()
def __init__(self, application: "CuraApplication", parent: Optional["QObject"] = None) -> None:
super().__init__(parent)
self.addRoleName(self.IdRole, "id")
self.addRoleName(self.PageUrlRole, "page_url")
self.addRoleName(self.NextPageIdRole, "next_page_id")
self.addRoleName(self.NextPageButtonTextRole, "next_page_button_text")
self.addRoleName(self.PreviousPageButtonTextRole, "previous_page_button_text")
self._application = application
self._catalog = i18nCatalog("cura")
self._default_next_button_text = self._catalog.i18nc("@action:button", "Next")
self._pages = [] # type: List[Dict[str, Any]]
self._current_page_index = 0
# Store all the previous page indices so it can go back.
self._previous_page_indices_stack = deque() # type: deque
# If the welcome flow should be shown. It can show the complete flow or just the changelog depending on the
# specific case. See initialize() for how this variable is set.
self._should_show_welcome_flow = False
def _update(self):
if not self._container:
return
# Try and find a translation catalog for the definition
for file_name in self._container.getInheritedFiles():
catalog = i18nCatalog(os.path.basename(file_name))
if catalog.hasTranslationLoaded():
self._i18n_catalog = catalog
self.beginResetModel()
self._definition_list.clear()
self._row_index_list.clear()
if self._root:
self._definition_list = self._root.findDefinitions()
else:
self._definition_list = self._container.findDefinitions()
self._updateVisibleRows()
self.endResetModel()
# Copyright (c) 2018 Ghostkeeper
# X3GWriter is released under the terms of the AGPLv3 or higher
from . import X3GWriter
import UM.Mesh.MeshWriter
from UM.i18n import i18nCatalog
catalog = i18nCatalog("x3gwriter")
def getMetaData():
return {
"mesh_writer": {
"output": [{
"extension": "x3g",
"description": catalog.i18nc("X3G Writer File Description", "X3G File"),
"mime_type": "application/x3g",
"mode": UM.Mesh.MeshWriter.MeshWriter.OutputMode.BinaryMode
}]
}
}
def register(app):
return { "mesh_writer": X3GWriter.X3GWriter() }
def _update(self):
if not self._quality_id:
return
items = []
definition_container = Application.getInstance().getGlobalContainerStack().getBottom()
containers = self._container_registry.findInstanceContainers(id = self._quality_id)
if not containers:
Logger.log("w", "Could not find a quality container with id %s", self._quality_id)
return
quality_container = None
quality_changes_container = None
if containers[0].getMetaDataEntry("type") == "quality":
quality_container = containers[0]
else:
quality_changes_container = containers[0]
criteria = {
"type": "quality",
"quality_type": quality_changes_container.getMetaDataEntry("quality_type"),
"definition": quality_changes_container.getDefinition().getId()
}
quality_container = self._container_registry.findInstanceContainers(**criteria)
if not quality_container:
Logger.log("w", "Could not find a quality container matching quality changes %s", quality_changes_container.getId())
return
quality_container = quality_container[0]
quality_type = quality_container.getMetaDataEntry("quality_type")
definition_id = Application.getInstance().getMachineManager().getQualityDefinitionId(quality_container.getDefinition())
definition = quality_container.getDefinition()
# Check if the definition container has a translation file.
definition_suffix = ContainerRegistry.getMimeTypeForContainer(type(definition)).preferredSuffix
catalog = i18nCatalog(os.path.basename(definition_id + "." + definition_suffix))
if catalog.hasTranslationLoaded():
self._i18n_catalog = catalog
for file_name in quality_container.getDefinition().getInheritedFiles():
catalog = i18nCatalog(os.path.basename(file_name))
if catalog.hasTranslationLoaded():
self._i18n_catalog = catalog
criteria = {"type": "quality", "quality_type": quality_type, "definition": definition_id}
if self._material_id and self._material_id != "empty_material":
criteria["material"] = self._material_id
criteria["extruder"] = self._extruder_id
containers = self._container_registry.findInstanceContainers(**criteria)
if not containers:
# Try again, this time without extruder
new_criteria = criteria.copy()
new_criteria.pop("extruder")
containers = self._container_registry.findInstanceContainers(**new_criteria)
if not containers and "material" in criteria:
# Try again, this time without material
criteria.pop("material", None)
containers = self._container_registry.findInstanceContainers(**criteria)
if not containers:
# Try again, this time without material or extruder
criteria.pop("extruder") # "material" has already been popped
containers = self._container_registry.findInstanceContainers(**criteria)
if not containers:
Logger.log("w", "Could not find any quality containers matching the search criteria %s" % str(criteria))
return
if quality_changes_container:
criteria = {"type": "quality_changes", "quality_type": quality_type, "definition": definition_id, "name": quality_changes_container.getName()}
if self._extruder_definition_id != "":
extruder_definitions = self._container_registry.findDefinitionContainers(id = self._extruder_definition_id)
if extruder_definitions:
criteria["extruder"] = Application.getInstance().getMachineManager().getQualityDefinitionId(extruder_definitions[0])
criteria["name"] = quality_changes_container.getName()
else:
criteria["extruder"] = None
changes = self._container_registry.findInstanceContainers(**criteria)
if changes:
containers.extend(changes)
global_container_stack = Application.getInstance().getGlobalContainerStack()
is_multi_extrusion = global_container_stack.getProperty("machine_extruder_count", "value") > 1
current_category = ""
for definition in definition_container.findDefinitions():
if definition.type == "category":
current_category = definition.label
if self._i18n_catalog:
current_category = self._i18n_catalog.i18nc(definition.key + " label", definition.label)
continue
profile_value = None
profile_value_source = ""
for container in containers:
new_value = container.getProperty(definition.key, "value")
if new_value is not None:
profile_value_source = container.getMetaDataEntry("type")
profile_value = new_value
# Global tab should use resolve (if there is one)
if not self._extruder_id:
resolve_value = global_container_stack.getProperty(definition.key, "resolve")
if resolve_value is not None and profile_value is not None and profile_value_source != "quality_changes":
profile_value = resolve_value
user_value = None
if not self._extruder_id:
user_value = global_container_stack.getTop().getProperty(definition.key, "value")
else:
extruder_stack = self._container_registry.findContainerStacks(id = self._extruder_id)
if extruder_stack:
user_value = extruder_stack[0].getTop().getProperty(definition.key, "value")
if profile_value is None and user_value is None:
continue
if is_multi_extrusion:
settable_per_extruder = global_container_stack.getProperty(definition.key, "settable_per_extruder")
# If a setting is not settable per extruder (global) and we're looking at an extruder tab, don't show this value.
if self._extruder_id != "" and not settable_per_extruder:
continue
# If a setting is settable per extruder (not global) and we're looking at global tab, don't show this value.
if self._extruder_id == "" and settable_per_extruder:
continue
label = definition.label
if self._i18n_catalog:
label = self._i18n_catalog.i18nc(definition.key + " label", label)
items.append({
"key": definition.key,
"label": label,
"unit": definition.unit,
"profile_value": "" if profile_value is None else str(profile_value), # it is for display only
"profile_value_source": profile_value_source,
"user_value": "" if user_value is None else str(user_value),
"category": current_category
})
self.setItems(items)
# Copyright (c) 2017 Jerry Kotas
# XYZWriter is released under the terms of the AGPLv3 or higher
from . import XYZWriter
from UM.i18n import i18nCatalog
catalog = i18nCatalog("xyzwriter")
def getMetaData():
return {
"mesh_writer": {
"output": [{
"extension":
"3w",
"description":
catalog.i18nc("XYZ Writer File Description", "3w File"),
"mime_type":
"application/3w"
}]
}
}
def register(app):
return {"mesh_writer": XYZWriter.XYZWriter()}
from cura.CuraVersion import CuraVersion # type: ignore
# from UM.Version import Version
from cura.CuraApplication import CuraApplication
from UM.Logger import Logger
from UM.Message import Message
import os.path
import tempfile
import html
import json
import re
from UM.i18n import i18nCatalog
i18n_cura_catalog = i18nCatalog('cura')
i18n_catalog = i18nCatalog('fdmprinter.def.json')
i18n_extrud_catalog = i18nCatalog('fdmextruder.def.json')
encode = html.escape
class ProfilAnalyser(Extension, QObject):
def __init__(self, parent=None):
QObject.__init__(self, parent)
Extension.__init__(self)
self.addMenuItem('View Profil Analyse', viewCompare)
self.addMenuItem('View Active Configuration', viewAll)
self.addMenuItem('View All Current Printer Profiles',
viewAllQualityChanges)
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)
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("global_inherits_stack", DefinitionPropertyType.Function, default = "-1")
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)
## 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.
self._version_upgrade_manager = UM.VersionUpgradeManager.VersionUpgradeManager(
{
("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")
}
)
self._machine_action_manager = MachineActionManager.MachineActionManager()
self._machine_manager = None # This is initialized on demand.
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)
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_type
support_interface_density
platform_adhesion
adhesion_type
brim_width
raft_airgap
layer_0_z_overlap
raft_surface_layers
dual
adhesion_extruder_nr
support_extruder_nr
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))
from UM.Logger import Logger
from UM.Message import Message
from UM.Extension import Extension # The PluginObject we're going to extend.
from UM.PluginRegistry import PluginRegistry
from UM.Preferences import Preferences
from UM.Mesh.ReadMeshJob import ReadMeshJob # To reload a mesh when its file was changed.
from UM.Application import Application
from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
from UM.Scene.Selection import Selection
from UM.i18n import i18nCatalog
# Imports from Cura.
from cura.Scene.CuraSceneNode import CuraSceneNode
# The catalog used for showing messages.
catalog = i18nCatalog('cura')
# Global variables used by our other modules.
global fs_watcher, verified_blender_path, outdated_blender_version
# A flag that indicates an already checked and confirmed blender version.
verified_blender_path = False
# A flag that indicates an outdated blender version.
outdated_blender_version = False
class CuraBlender(Extension):
"""An Extension subclass and the main class for CuraBlender plugin."""
def __init__(self):
"""The constructor, which calls the super-class-contructor (Extension).
# Copyright (c) 2015 Ultimaker B.V.
# Uranium is released under the terms of the AGPLv3 or higher.
import platform
from UM.i18n import i18nCatalog
catalog = i18nCatalog("uranium")
def getMetaData():
return {
"plugin": {
"name": catalog.i18nc("@label", "Removable Drive Output Device Plugin"),
"author": "Ultimaker B.V.",
"description": catalog.i18nc("@info:whatsthis", "Provides removable drive hotplugging and writing support"),
"version": "1.0",
"api": 2
}
}
def register(app):
if platform.system() == "Windows":
from . import WindowsRemovableDrivePlugin
return { "output_device": WindowsRemovableDrivePlugin.WindowsRemovableDrivePlugin() }
elif platform.system() == "Darwin":
from . import OSXRemovableDrivePlugin
return { "output_device": OSXRemovableDrivePlugin.OSXRemovableDrivePlugin() }
elif platform.system() == "Linux":
from . import LinuxRemovableDrivePlugin
return { "output_device": LinuxRemovableDrivePlugin.LinuxRemovableDrivePlugin() }
else:
Logger.log("e", "Unsupported system %s, no removable device hotplugging support available.", platform.system())
# Copyright (c) 2015 Ultimaker B.V.
# Cura is released under the terms of the AGPLv3 or higher.
from . import GCodeProfileReader
from UM.i18n import i18nCatalog
catalog = i18nCatalog("IntamSuite")
def getMetaData():
return {
"plugin": {
"name":
catalog.i18nc("@label", "GCode Profile Reader"),
"author":
"Ultimaker",
"version":
"1.0",
"description":
catalog.i18nc(
"@info:whatsthis",
"Provides support for importing profiles from g-code files."),
"api":
3
},
"profile_reader": [{
"extension":
"gcode",
"description":
catalog.i18nc("@item:inlistbox", "G-code File")
}]
# The TXT plugin is released under the terms of the AGPLv3 or higher.
# Version 1.0.3 : simplify the source code with WriteTd
# : Export also the meshfix paramater section by extruder and complementary information on extruder for machine definition
# Version 1.0.4 : html cleanup, no jquery dependency thanks to https://github.com/etet100
#
import os
import platform
from datetime import datetime
from cura.CuraApplication import CuraApplication
from UM.Workspace.WorkspaceWriter import WorkspaceWriter
from cura.CuraVersion import CuraVersion # type: ignore
from UM.i18n import i18nCatalog
i18n_cura_catalog = i18nCatalog("cura")
i18n_catalog = i18nCatalog("fdmprinter.def.json")
i18n_extrud_catalog = i18nCatalog("fdmextruder.def.json")
from UM.Logger import Logger
from UM.Message import Message
class TXTCuraSettings(WorkspaceWriter):
def write(self, stream, nodes, mode):
# Current File path
Logger.log("d", "stream = %s", os.path.abspath(stream.name))
machine_manager = CuraApplication.getInstance().getMachineManager()
stack = CuraApplication.getInstance().getGlobalContainerStack()
# Copyright (c) 2018 fieldOfView
# The ZOffsetPlugin is released under the terms of the AGPLv3 or higher.
import os, json, re
from UM.Extension import Extension
from UM.Application import Application
from UM.Settings.SettingDefinition import SettingDefinition
from UM.Settings.DefinitionContainer import DefinitionContainer
from UM.Settings.ContainerRegistry import ContainerRegistry
from UM.Logger import Logger
from UM.i18n import i18nCatalog
i18n_catalog = i18nCatalog("ZOffsetPlugin")
class ZOffsetPlugin(Extension):
def __init__(self):
super().__init__()
self._application = Application.getInstance()
self._i18n_catalog = None
self._setting_key = "adhesion_z_offset"
self._setting_dict = {
"label": "Z Offset",
"description": "An additional distance between the nozzle and the build platform.",
"type": "float",
"unit": "mm",
"default_value": 0,
"minimum_value": "-layer_height_0",
"maximum_value_warning": "layer_height_0",
from UM.Extension import Extension
from UM.Scene.Selection import Selection
from UM.Math.Vector import Vector
from UM.i18n import i18nCatalog
i18n_catalog = i18nCatalog("BarbarianPlugin")
class BarbarianPlugin(Extension):
def __init__(self):
super().__init__()
self.addMenuItem(i18n_catalog.i18n("Convert to metric"), self.convertToMetric)
## Scales all selected objects by 25.4 (inch to mm)
def convertToMetric(self):
selected_nodes = Selection.getAllSelectedObjects()
for node in selected_nodes:
node.scale(Vector(25.4, 25.4, 25.4))
def __init__(self, tray_icon_name = None, **kwargs):
plugin_path = ""
if sys.platform == "win32":
if hasattr(sys, "frozen"):
plugin_path = os.path.join(os.path.dirname(os.path.abspath(sys.executable)), "PyQt5", "plugins")
Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path))
QCoreApplication.addLibraryPath(plugin_path)
else:
import site
for sitepackage_dir in site.getsitepackages():
QCoreApplication.addLibraryPath(os.path.join(sitepackage_dir, "PyQt5", "plugins"))
elif sys.platform == "darwin":
plugin_path = os.path.join(Application.getInstallPrefix(), "Resources", "plugins")
if plugin_path:
Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path))
QCoreApplication.addLibraryPath(plugin_path)
os.environ["QSG_RENDER_LOOP"] = "basic"
super().__init__(sys.argv, **kwargs)
self.setStyle("fusion")
self.setAttribute(Qt.AA_UseDesktopOpenGL)
major_version, minor_version, profile = OpenGLContext.detectBestOpenGLVersion()
if major_version is None and minor_version is None and profile is None:
Logger.log("e", "Startup failed because OpenGL version probing has failed: tried to create a 2.0 and 4.1 context. Exiting")
QMessageBox.critical(None, "Failed to probe OpenGL",
"Could not probe OpenGL. This program requires OpenGL 2.0 or higher. Please check your video card drivers.")
sys.exit(1)
else:
Logger.log("d", "Detected most suitable OpenGL context version: %s" % (
OpenGLContext.versionAsText(major_version, minor_version, profile)))
OpenGLContext.setDefaultFormat(major_version, minor_version, profile = profile)
self._plugins_loaded = False # Used to determine when it's safe to use the plug-ins.
self._main_qml = "main.qml"
self._engine = None
self._renderer = None
self._main_window = None
self._theme = None
self.assertID = 0
self._shutting_down = False
self._qml_import_paths = []
self._qml_import_paths.append(os.path.join(os.path.dirname(sys.executable), "qml"))
self._qml_import_paths.append(os.path.join(Application.getInstallPrefix(), "Resources", "qml"))
self.parseCommandLine()
Logger.log("i", "Command line arguments: %s", self._parsed_command_line)
self._splash = None
signal.signal(signal.SIGINT, signal.SIG_DFL)
# This is done here as a lot of plugins require a correct gl context. If you want to change the framework,
# these checks need to be done in your <framework>Application.py class __init__().
i18n_catalog = i18nCatalog("uranium")
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading plugins..."))
self._loadPlugins()
self._plugin_registry.checkRequiredPlugins(self.getRequiredPlugins())
self.pluginsLoaded.emit()
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Updating configuration..."))
upgraded = UM.VersionUpgradeManager.VersionUpgradeManager.getInstance().upgrade()
if upgraded:
# Preferences might have changed. Load them again.
# Note that the language can't be updated, so that will always revert to English.
preferences = Preferences.getInstance()
try:
preferences.readFromFile(Resources.getPath(Resources.Preferences, self._application_name + ".cfg"))
except FileNotFoundError:
pass
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading preferences..."))
try:
file_name = Resources.getPath(Resources.Preferences, self.getApplicationName() + ".cfg")
Preferences.getInstance().readFromFile(file_name)
except FileNotFoundError:
pass
self.getApplicationName()
Preferences.getInstance().addPreference("%s/recent_files" % self.getApplicationName(), "")
self._recent_files = []
file_names = Preferences.getInstance().getValue("%s/recent_files" % self.getApplicationName()).split(";")
for file_name in file_names:
if not os.path.isfile(file_name):
continue
self._recent_files.append(QUrl.fromLocalFile(file_name))
JobQueue.getInstance().jobFinished.connect(self._onJobFinished)
# Initialize System tray icon and make it invisible because it is used only to show pop up messages
self._tray_icon = None
self._tray_icon_widget = None
if tray_icon_name:
self._tray_icon = QIcon(Resources.getPath(Resources.Images, tray_icon_name))
self._tray_icon_widget = QSystemTrayIcon(self._tray_icon)
self._tray_icon_widget.setVisible(False)
from UM.i18n import i18nCatalog
from UM.Logger import Logger
from cura.CuraApplication import CuraApplication
i18n_catalog = i18nCatalog("python-console")
from . import console
from . import ConsoleExtension
_extension = ConsoleExtension.ConsoleExtension()
def getMetaData():
return {}
def register(app):
console.registerQmlTypes()
CuraApplication.getInstance().initializationFinished.connect(
_extension.applicationInitialized)
return {
"extension": _extension,
}
def _populateMetaData(self, plugin_id: str) -> bool:
plugin = self._findPlugin(plugin_id)
if not plugin:
Logger.log("w", "Could not find plugin %s", plugin_id)
return False
meta_data = None
location = None
for folder in self._plugin_locations:
location = self._locatePlugin(plugin_id, folder)
if location:
break
if not location:
Logger.log("w", "Could not find plugin %s", plugin_id)
return False
location = os.path.join(location, plugin_id)
try:
meta_data = plugin.getMetaData()
metadata_file = os.path.join(location, "plugin.json")
try:
with open(metadata_file, "r") as f:
try:
meta_data["plugin"] = json.loads(f.read())
except json.decoder.JSONDecodeError:
Logger.logException(
"e", "Failed to parse plugin.json for plugin %s",
plugin_id)
raise InvalidMetaDataError(plugin_id)
# Check if metadata is valid;
if "version" not in meta_data["plugin"]:
Logger.log("e", "Version must be set!")
raise InvalidMetaDataError(plugin_id)
if "i18n-catalog" in meta_data["plugin"]:
# A catalog was set, try to translate a few strings
i18n_catalog = i18nCatalog(
meta_data["plugin"]["i18n-catalog"])
if "name" in meta_data["plugin"]:
meta_data["plugin"]["name"] = i18n_catalog.i18n(
meta_data["plugin"]["name"])
if "description" in meta_data["plugin"]:
meta_data["plugin"][
"description"] = i18n_catalog.i18n(
meta_data["plugin"]["description"])
except FileNotFoundError:
Logger.logException(
"e",
"Unable to find the required plugin.json file for plugin %s",
plugin_id)
raise InvalidMetaDataError(plugin_id)
except AttributeError as e:
Logger.log(
"e", "An error occurred getting metadata from plugin %s: %s",
plugin_id, str(e))
raise InvalidMetaDataError(plugin_id)
if not meta_data:
raise InvalidMetaDataError(plugin_id)
meta_data["id"] = plugin_id
meta_data["location"] = location
# Application-specific overrides
appname = self._application.getApplicationName()
if appname in meta_data:
meta_data.update(meta_data[appname])
del meta_data[appname]
self._meta_data[plugin_id] = meta_data
return True
# Copyright (c) 2020 ollyfg
# The PressureAdvanceSettingPlugin is released under the terms of the AGPLv3 or higher.
from UM.Extension import Extension
from cura.CuraApplication import CuraApplication
from UM.Logger import Logger
from UM.Settings.SettingDefinition import SettingDefinition
from UM.Settings.DefinitionContainer import DefinitionContainer
from UM.Settings.ContainerRegistry import ContainerRegistry
from UM.i18n import i18nCatalog
i18n_catalog = i18nCatalog("PressureAdvanceSettingPlugin")
import collections
import json
import os.path
from typing import List, Optional, Any, Dict, TYPE_CHECKING
if TYPE_CHECKING:
from UM.OutputDevice.OutputDevice import OutputDevice
class PressureAdvanceSettingPlugin(Extension):
def __init__(self) -> None:
super().__init__()
self._application = CuraApplication.getInstance()
self._i18n_catalog = None # type: Optional[i18nCatalog]
from . import ConvertToSLA
from UM.i18n import i18nCatalog
catalog = i18nCatalog('cura')
def getMetaData():
return {
'plugin': {
'name': catalog.i18nc('@label', 'Convert To SLA'),
'author': 'pHeX Labs',
'version': '1.0',
'description': catalog.i18nc('@info:whatsthis', 'Automatically converts FDM GCODE to SLA GCODE.'),
'api': 2
}
}
def register(app):
return {'extension': ConvertToSLA.ConvertToSLA()}
# Copyright (c) 2019 Ultimaker B.V.
# Cura is released under the terms of the LGPLv3 or higher.
from datetime import datetime
import json
import random
from hashlib import sha512
from base64 import b64encode
from typing import Optional
import requests
from UM.i18n import i18nCatalog
from UM.Logger import Logger
from cura.OAuth2.Models import AuthenticationResponse, UserProfile, OAuth2Settings
catalog = i18nCatalog("cura")
TOKEN_TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S"
## Class containing several helpers to deal with the authorization flow.
class AuthorizationHelpers:
def __init__(self, settings: "OAuth2Settings") -> None:
self._settings = settings
self._token_url = "{}/token".format(self._settings.OAUTH_SERVER_URL)
@property
## The OAuth2 settings object.
def settings(self) -> "OAuth2Settings":
return self._settings
## Request the access token from the authorization server.
# \param authorization_code: The authorization code from the 1st step.
def setName(self, name):
if name != self._name:
self._catalog = i18nCatalog(name)
self.nameChanged.emit()
from UM.Scene.Selection import Selection
from UM.Scene.SceneNode import SceneNode
from cura.Scene.CuraSceneNode import CuraSceneNode
# QT / QML Imports
from PyQt5.QtCore import Qt, QUrl
from PyQt5.QtQml import QQmlComponent, QQmlContext # @UnresolvedImport
# Local Imports
from ..utils import makeInteractiveMesh
from ..SmartSliceExtension import SmartSliceExtension
from .SmartSliceSelectHandle import SelectionMode
from .SmartSliceSelectHandle import SmartSliceSelectHandle
i18n_catalog = i18nCatalog("smartslice")
## Provides the tool to rotate meshes and groups
#
# The tool exposes a ToolHint to show the rotation angle of the current operation
class SmartSliceSelectTool(Tool):
def __init__(self, extension : SmartSliceExtension):
super().__init__()
self.extension = extension
self._handle = SmartSliceSelectHandle(self.extension)
#self._shortcut_key = Qt.Key_S
self.setExposedProperties("AnchorSelectionActive",
"LoadSelectionActive",
"SelectionMode",
def run(self):
self._i18n_catalog = i18nCatalog("cura")
i18nCatalog.setTagReplacements({
"filename":
"font color=\"black\"",
"message":
"font color=UM.Theme.colors.message_text;",
})
self.showSplashMessage(
self._i18n_catalog.i18nc("Splash screen message",
"Setting up scene..."))
controller = self.getController()
controller.setActiveView("MeshView")
controller.setCameraTool("CameraTool")
controller.setSelectionTool("SelectionTool")
t = controller.getTool("TranslateTool")
if t:
t.setEnabledAxis(
[ToolHandle.XAxis, ToolHandle.YAxis, ToolHandle.ZAxis])
Selection.selectionChanged.connect(self.onSelectionChanged)
root = controller.getScene().getRoot()
self._platform = Platform(root)
self._volume = BuildVolume.BuildVolume(root)
self.getRenderer().setLightPosition(Vector(0, 150, 0))
self.getRenderer().setBackgroundColor(QColor(245, 245, 245))
self._physics = PlatformPhysics.PlatformPhysics(
controller, self._volume)
camera = Camera("3d", root)
camera.setPosition(Vector(-150, 150, 300))
camera.setPerspective(True)
camera.lookAt(Vector(0, 0, 0))
self._camera_animation = CameraAnimation.CameraAnimation()
self._camera_animation.setCameraTool(
self.getController().getTool("CameraTool"))
controller.getScene().setActiveCamera("3d")
self.showSplashMessage(
self._i18n_catalog.i18nc("Splash screen message",
"Loading interface..."))
self.setMainQml(
Resources.getPath(Resources.QmlFilesLocation, "Cura.qml"))
self.initializeEngine()
if self.getMachines():
active_machine_pref = Preferences.getInstance().getValue(
"cura/active_machine")
if active_machine_pref:
for machine in self.getMachines():
if machine.getName() == active_machine_pref:
self.setActiveMachine(machine)
if not self.getActiveMachine():
self.setActiveMachine(self.getMachines()[0])
else:
self.requestAddPrinter.emit()
if self._engine.rootObjects:
self.closeSplash()
for file in self.getCommandLineOption("file", []):
self._openFile(file)
self.exec_()
def __init__(self, **kwargs):
plugin_path = ""
if sys.platform == "win32":
if hasattr(sys, "frozen"):
plugin_path = os.path.join(
os.path.dirname(os.path.abspath(sys.executable)), "PyQt5",
"plugins")
Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path))
QCoreApplication.addLibraryPath(plugin_path)
else:
import site
for dir in site.getsitepackages():
QCoreApplication.addLibraryPath(
os.path.join(dir, "PyQt5", "plugins"))
elif sys.platform == "darwin":
plugin_path = os.path.join(Application.getInstallPrefix(),
"Resources", "plugins")
if plugin_path:
Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path))
QCoreApplication.addLibraryPath(plugin_path)
os.environ["QSG_RENDER_LOOP"] = "basic"
super().__init__(sys.argv, **kwargs)
self._plugins_loaded = False #Used to determine when it's safe to use the plug-ins.
self._main_qml = "main.qml"
self._engine = None
self._renderer = None
self._main_window = None
self.setAttribute(Qt.AA_UseDesktopOpenGL)
try:
self._splash = self._createSplashScreen()
except FileNotFoundError:
self._splash = None
else:
self._splash.show()
self.processEvents()
signal.signal(signal.SIGINT, signal.SIG_DFL)
# This is done here as a lot of plugins require a correct gl context. If you want to change the framework,
# these checks need to be done in your <framework>Application.py class __init__().
i18n_catalog = i18nCatalog("uranium")
self.showSplashMessage(
i18n_catalog.i18nc("@info:progress", "Loading plugins..."))
self._loadPlugins()
self.parseCommandLine()
Logger.log("i", "Command line arguments: %s",
self._parsed_command_line)
self._plugin_registry.checkRequiredPlugins(self.getRequiredPlugins())
self.showSplashMessage(
i18n_catalog.i18nc("@info:progress", "Loading machines..."))
self.getMachineManager().loadAll()
self.showSplashMessage(
i18n_catalog.i18nc("@info:progress", "Loading preferences..."))
try:
file = Resources.getPath(Resources.Preferences,
self.getApplicationName() + ".cfg")
Preferences.getInstance().readFromFile(file)
except FileNotFoundError:
pass
def run(self):
self._i18n_catalog = i18nCatalog("cura")
i18nCatalog.setTagReplacements({
"filename":
"font color=\"black\"",
"message":
"font color=UM.Theme.colors.message_text;",
})
self.showSplashMessage(
self._i18n_catalog.i18nc("@info:progress", "Setting up scene..."))
controller = self.getController()
controller.setActiveView("SolidView")
controller.setCameraTool("CameraTool")
controller.setSelectionTool("SelectionTool")
t = controller.getTool("TranslateTool")
if t:
t.setEnabledAxis(
[ToolHandle.XAxis, ToolHandle.YAxis, ToolHandle.ZAxis])
Selection.selectionChanged.connect(self.onSelectionChanged)
root = controller.getScene().getRoot()
self._platform = Platform(root)
self._volume = BuildVolume.BuildVolume(root)
self.getRenderer().setBackgroundColor(QColor(245, 245, 245))
self._physics = PlatformPhysics.PlatformPhysics(
controller, self._volume)
camera = Camera("3d", root)
camera.setPosition(Vector(-80, 250, 700))
camera.setPerspective(True)
camera.lookAt(Vector(0, 0, 0))
controller.getScene().setActiveCamera("3d")
self.getController().getTool("CameraTool").setOrigin(Vector(0, 100, 0))
self._camera_animation = CameraAnimation.CameraAnimation()
self._camera_animation.setCameraTool(
self.getController().getTool("CameraTool"))
self.showSplashMessage(
self._i18n_catalog.i18nc("@info:progress", "Loading interface..."))
qmlRegisterSingletonType(MachineManagerModel.MachineManagerModel,
"Cura", 1, 0, "MachineManager",
MachineManagerModel.createMachineManagerModel)
self.setMainQml(
Resources.getPath(self.ResourceTypes.QmlFiles, "Cura.qml"))
self.initializeEngine()
if self._engine.rootObjects:
self.closeSplash()
for file in self.getCommandLineOption("file", []):
self._openFile(file)
for file_name in self._open_file_queue: #Open all the files that were queued up while plug-ins were loading.
self._openFile(file_name)
self.exec_()
def setup_method(self, method):
# Called before the first testfunction is executed
self._machine_manager = MachineManager()
self._catalog = i18nCatalog("TestSetting")
# Copyright (c) 2015 Ultimaker B.V.
# Cura is released under the terms of the AGPLv3 or higher.
#Shoopdawoop
from . import NinjaKittensBackend
from UM.i18n import i18nCatalog
catalog = i18nCatalog("nk")
def getMetaData():
return {
"plugin": {
"name": catalog.i18nc("@label", "NinjaKittens Backend"),
"author": "Daid",
"description": catalog.i18nc("@info:whatsthis", "Provides the NinjaKittens backend"),
"api": 2
}
}
def register(app):
return { "backend": NinjaKittensBackend.NinjaKittensBackend() }
from UM.Extension import Extension
from UM.Scene.Selection import Selection
from UM.Math.Vector import Vector
from UM.i18n import i18nCatalog
i18n_catalog = i18nCatalog("ConvertToMetricPlugin")
class ConvertToMetricPlugin(Extension):
def __init__(self):
super().__init__()
self.addMenuItem(i18n_catalog.i18n("Convert Selected Model"), self.convertToMetric)
def convertToMetric(self):
selected_nodes = Selection.getAllSelectedObjects()
for node in selected_nodes:
node.scale(Vector(25.4,25.4,25.4))
# Copyright (c) 2018 Pheneeny
# The ScalableExtraPrime plugin is released under the terms of the AGPLv3 or higher.
from . import ScalableExtraPrime
from UM.i18n import i18nCatalog
i18n_catalog = i18nCatalog('ScalableExtraPrime')
def getMetaData():
return {}
def register(app):
return {'extension': ScalableExtraPrime.ScalableExtraPrime()}
def _update(self):
item_dict = OrderedDict()
item_list = []
global_stack = Application.getInstance().getGlobalContainerStack()
if not global_stack:
return
stacks = ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks()
# Check if the definition container has a translation file and ensure it's loaded.
definition = global_stack.getBottom()
definition_suffix = ContainerRegistry.getMimeTypeForContainer(type(definition)).preferredSuffix
catalog = i18nCatalog(os.path.basename(definition.getId() + "." + definition_suffix))
if catalog.hasTranslationLoaded():
self._i18n_catalog = catalog
for file_name in definition.getInheritedFiles():
catalog = i18nCatalog(os.path.basename(file_name))
if catalog.hasTranslationLoaded():
self._i18n_catalog = catalog
for stack in stacks:
# Make a list of all containers in the stack.
containers = []
latest_stack = stack
while latest_stack:
containers.extend(latest_stack.getContainers())
latest_stack = latest_stack.getNextStack()
# Drop the user container.
user_changes = containers.pop(0)
for setting_key in user_changes.getAllKeys():
original_value = None
# Find the category of the instance by moving up until we find a category.
category = user_changes.getInstance(setting_key).definition
while category.type != "category":
category = category.parent
# Handle translation (and fallback if we weren't able to find any translation files.
if self._i18n_catalog:
category_label = self._i18n_catalog.i18nc(category.key + " label", category.label)
else:
category_label = category.label
if self._i18n_catalog:
label = self._i18n_catalog.i18nc(setting_key + " label", stack.getProperty(setting_key, "label"))
else:
label = stack.getProperty(setting_key, "label")
for container in containers:
if stack == global_stack:
resolve = global_stack.getProperty(setting_key, "resolve")
if resolve is not None:
original_value = resolve
break
original_value = container.getProperty(setting_key, "value")
# If a value is a function, ensure it's called with the stack it's in.
if isinstance(original_value, SettingFunction):
original_value = original_value(stack)
if original_value is not None:
break
item_to_add = {"key": setting_key,
"label": label,
"user_value": str(user_changes.getProperty(setting_key, "value")),
"original_value": str(original_value),
"extruder": "",
"category": category_label}
if stack != global_stack:
item_to_add["extruder"] = stack.getName()
if category_label not in item_dict:
item_dict[category_label] = []
item_dict[category_label].append(item_to_add)
for each_item_list in item_dict.values():
item_list += each_item_list
self.setItems(item_list)
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))
# Since 3.4: Register Mimetypes:
if Version("3.4") <= Version(Application.getInstance().getVersion()):
from UM.MimeTypeDatabase import MimeTypeDatabase, MimeType
from cura.Scene.BuildPlateDecorator import BuildPlateDecorator # @UnresolvedImport
from cura.Scene.CuraSceneNode import CuraSceneNode # @UnresolvedImport
from cura.Scene.SliceableObjectDecorator import SliceableObjectDecorator # @UnresolvedImport
from cura.Settings.SettingOverrideDecorator import SettingOverrideDecorator # @UnresolvedImport
# CIU
from .CadIntegrationUtils.CommonCLIReader import CommonCLIReader # @UnresolvedImport
from .CommentParser import CommentParser
from .OpenSCADDecorator import OpenSCADDecorator
i18n_catalog = i18nCatalog("OpenSCADPlugin")
class OpenSCADReader(CommonCLIReader):
def __init__(self):
super().__init__("OpenSCAD")
if Version("3.4") <= Version(Application.getInstance().getVersion()):
MimeTypeDatabase.addMimeType(
MimeType(name="application/x-extension-scad",
comment="OpenSCAD files",
suffixes=["scad"]))
self._supported_extensions = [
".scad".lower(),
]
# Copyright (c) 2018 Pheneeny
# The ScalableExtraPrime plugin is released under the terms of the AGPLv3 or higher.
from . import ScalableExtraPrime
from UM.i18n import i18nCatalog
i18n_catalog = i18nCatalog("ScalableExtraPrime")
def getMetaData():
return {}
def register(app):
return {"extension": ScalableExtraPrime.ScalableExtraPrime()}
# Copyright (c) 2015 Jaime van Kessel
# PluginCostCalculator is released under the terms of the AGPLv3 or higher.
from . import PrintCostCalculator
from UM.i18n import i18nCatalog
i18n_catalog = i18nCatalog("PrintCostCalculator")
def getMetaData():
return {
"type": "extension",
"plugin":
{
"name": "Print Cost Calculator",
"author": "Jaime van Kessel",
"version": "2.1",
"api": 2,
"description": i18n_catalog.i18nc("Description of plugin","Extension to quickly calculate print costs")
}
}
def register(app):
return { "extension": PrintCostCalculator.PrintCostCalculator()}
def loadSettingsFromFile(self, file_name):
with open(file_name, "rt", -1, "utf-8") as f:
data = json.load(f, object_pairs_hook=collections.OrderedDict)
if "id" not in data or "name" not in data:
raise SettingsError.InvalidFileError(file_name)
if "version" not in data or data[
"version"] != self.MachineDefinitionVersion:
raise SettingsError.InvalidVersionError(file_name)
self._i18n_catalog = i18nCatalog(os.path.basename(file_name))
self._json_file = file_name
self._type_id = data["id"]
self._type_name = data["name"]
if "platform" in data:
self._platform_mesh = data["platform"]
if "platform_texture" in data:
self._platform_texture = data["platform_texture"]
if "version" in data:
self._type_version = str(data["version"])
if "icon" in data:
self._icon = data["icon"]
if "inherits" in data:
inherits_from = MachineSettings()
inherits_from.loadSettingsFromFile(
os.path.dirname(file_name) + "/" + data["inherits"])
self._machine_settings = inherits_from._machine_settings
self._categories = inherits_from._categories
if "machine_settings" in data:
for key, value in data["machine_settings"].items():
setting = self.getSettingByKey(key)
if not setting:
setting = Setting(key, self._i18n_catalog)
self.addSetting(setting)
setting.fillByDict(value)
if "categories" in data:
for key, value in data["categories"].items():
category = self.getSettingsCategory(key)
if not category:
category = SettingsCategory(key, self._i18n_catalog, self)
self.addSettingsCategory(category)
category.fillByDict(value)
if "overrides" in data:
for key, value in data["overrides"].items():
setting = self.getSettingByKey(key)
if not setting:
continue
setting.fillByDict(value)
for setting in self.getAllSettings():
setting.valueChanged.connect(self.settingChanged)
self.settingsLoaded.emit(
) #Emit signal that all settings are loaded (some setting stuff can only be done when all settings are loaded (eg; the conditional stuff)
# Copyright (c) 2017 fieldOfView
# The BlackBeltPlugin is released under the terms of the AGPLv3 or higher.
from . import BlackBeltPlugin
from UM.i18n import i18nCatalog
i18n_catalog = i18nCatalog("BlackBeltPlugin")
def getMetaData():
return {}
def register(app):
return {"extension": BlackBeltPlugin.BlackBeltPlugin()}
# Copyright (c) 2015 Ultimaker B.V.
# Uranium is released under the terms of the AGPLv3 or higher.
from . import STLWriter
from UM.i18n import i18nCatalog
i18n_catalog = i18nCatalog("uranium")
def getMetaData():
return {
"type": "mesh_writer",
"plugin": {
"name": i18n_catalog.i18nc("@label", "STL Writer"),
"author": "Ultimaker",
"version": "1.0",
"description": i18n_catalog.i18nc("@info:whatsthis", "Provides support for writing STL files."),
"api": 2
},
"mesh_writer": {
"output": [
{
"mime_type": "application/x-stl-ascii",
"mode": STLWriter.STLWriter.OutputMode.TextMode,
"extension": "stl",
"description": i18n_catalog.i18nc("@item:inlistbox", "STL File (Ascii)")
},
{
"mime_type": "application/x-stl-binary",
"mode": STLWriter.STLWriter.OutputMode.BinaryMode,
"extension": "stl",
"description": i18n_catalog.i18nc("@item:inlistbox", "STL File (Binary)")
def startSplashWindowPhase(self) -> None:
super().startSplashWindowPhase()
i18n_catalog = i18nCatalog("uranium")
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Initializing package manager..."))
self._package_manager.initialize()
signal.signal(signal.SIGINT, signal.SIG_DFL)
# This is done here as a lot of plugins require a correct gl context. If you want to change the framework,
# these checks need to be done in your <framework>Application.py class __init__().
self._configuration_error_message = ConfigurationErrorMessage(self,
i18n_catalog.i18nc("@info:status", "Your configuration seems to be corrupt."),
lifetime = 0,
title = i18n_catalog.i18nc("@info:title", "Configuration errors")
)
# Remove, install, and then loading plugins
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading plugins..."))
# Remove and install the plugins that have been scheduled
self._plugin_registry.initializeBeforePluginsAreLoaded()
self._loadPlugins()
self._plugin_registry.checkRequiredPlugins(self.getRequiredPlugins())
self.pluginsLoaded.emit()
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Updating configuration..."))
with self._container_registry.lockFile():
VersionUpgradeManager.getInstance().upgrade()
# Load preferences again because before we have loaded the plugins, we don't have the upgrade routine for
# the preferences file. Now that we have, load the preferences file again so it can be upgraded and loaded.
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading preferences..."))
try:
preferences_filename = Resources.getPath(Resources.Preferences, self._app_name + ".cfg")
with open(preferences_filename, "r", encoding = "utf-8") as f:
serialized = f.read()
# This performs the upgrade for Preferences
self._preferences.deserialize(serialized)
self._preferences.setValue("general/plugins_to_remove", "")
self._preferences.writeToFile(preferences_filename)
except (FileNotFoundError, UnicodeDecodeError):
Logger.log("i", "The preferences file cannot be found or it is corrupted, so we will use default values")
self.processEvents()
# Force the configuration file to be written again since the list of plugins to remove maybe changed
try:
self._preferences_filename = Resources.getPath(Resources.Preferences, self._app_name + ".cfg")
self._preferences.readFromFile(self._preferences_filename)
except FileNotFoundError:
Logger.log("i", "The preferences file '%s' cannot be found, will use default values",
self._preferences_filename)
self._preferences_filename = Resources.getStoragePath(Resources.Preferences, self._app_name + ".cfg")
Logger.info("Completed loading preferences.")
# FIXME: This is done here because we now use "plugins.json" to manage plugins instead of the Preferences file,
# but the PluginRegistry will still import data from the Preferences files if present, such as disabled plugins,
# so we need to reset those values AFTER the Preferences file is loaded.
self._plugin_registry.initializeAfterPluginsAreLoaded()
# Check if we have just updated from an older version
self._preferences.addPreference("general/last_run_version", "")
last_run_version_str = self._preferences.getValue("general/last_run_version")
if not last_run_version_str:
last_run_version_str = self._version
last_run_version = Version(last_run_version_str)
current_version = Version(self._version)
if last_run_version < current_version:
self._just_updated_from_old_version = True
self._preferences.setValue("general/last_run_version", str(current_version))
self._preferences.writeToFile(self._preferences_filename)
# Preferences: recent files
self._preferences.addPreference("%s/recent_files" % self._app_name, "")
file_names = self._preferences.getValue("%s/recent_files" % self._app_name).split(";")
for file_name in file_names:
if not os.path.isfile(file_name):
continue
self._recent_files.append(QUrl.fromLocalFile(file_name))
if not self.getIsHeadLess():
# Initialize System tray icon and make it invisible because it is used only to show pop up messages
self._tray_icon = None
if self._tray_icon_name:
try:
self._tray_icon = QIcon(Resources.getPath(Resources.Images, self._tray_icon_name))
self._tray_icon_widget = QSystemTrayIcon(self._tray_icon)
self._tray_icon_widget.setVisible(False)
Logger.info("Created system tray icon.")
except FileNotFoundError:
Logger.log("w", "Could not find the icon %s", self._tray_icon_name)
# Copyright (c) 2022 Aldo Hoeben / fieldOfView
# MeasureTool is released under the terms of the AGPLv3 or higher.
from . import MeasureTool
from UM.Version import Version
from UM.Application import Application
from UM.i18n import i18nCatalog
i18n_catalog = i18nCatalog("measuretool")
def getMetaData():
cura_version = Version(Application.getInstance().getVersion())
tool_icon_path = "resources/icons/tool_icon.svg"
if cura_version < Version("4.11.0") and cura_version.getMajor() > 0:
tool_icon_path = "resources/icons/tool_icon_legacy.svg"
tool_panel_path = "resources/qml/MeasureTool.qml"
if cura_version < Version("5.0.0") and cura_version.getMajor() > 0:
tool_panel_path = "resources/qml_qt5/MeasureTool.qml"
metadata = {
"tool": {
"name":
i18n_catalog.i18nc("@label", "Measure"),
"description":
i18n_catalog.i18nc("@info:tooltip", "Measure parts of objects."),
"icon":
tool_icon_path,
def startSplashWindowPhase(self) -> None:
super().startSplashWindowPhase()
self._package_manager.initialize()
# Read preferences here (upgrade won't work) to get the language in use, so the splash window can be shown in
# the correct language.
try:
preferences_filename = Resources.getPath(Resources.Preferences, self._app_name + ".cfg")
self._preferences.readFromFile(preferences_filename)
except FileNotFoundError:
Logger.log("i", "Preferences file not found, ignore and use default language '%s'", self._default_language)
signal.signal(signal.SIGINT, signal.SIG_DFL)
# This is done here as a lot of plugins require a correct gl context. If you want to change the framework,
# these checks need to be done in your <framework>Application.py class __init__().
i18n_catalog = i18nCatalog("uranium")
self._configuration_error_message = ConfigurationErrorMessage(self,
i18n_catalog.i18nc("@info:status", "Your configuration seems to be corrupt."),
lifetime = 0,
title = i18n_catalog.i18nc("@info:title", "Configuration errors")
)
# Remove, install, and then loading plugins
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading plugins..."))
# Remove and install the plugins that have been scheduled
self._plugin_registry.initializeBeforePluginsAreLoaded()
self._loadPlugins()
self._plugin_registry.checkRequiredPlugins(self.getRequiredPlugins())
self.pluginsLoaded.emit()
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Updating configuration..."))
with self._container_registry.lockFile():
VersionUpgradeManager.getInstance().upgrade()
# Load preferences again because before we have loaded the plugins, we don't have the upgrade routine for
# the preferences file. Now that we have, load the preferences file again so it can be upgraded and loaded.
try:
preferences_filename = Resources.getPath(Resources.Preferences, self._app_name + ".cfg")
with open(preferences_filename, "r", encoding = "utf-8") as f:
serialized = f.read()
# This performs the upgrade for Preferences
self._preferences.deserialize(serialized)
self._preferences.setValue("general/plugins_to_remove", "")
self._preferences.writeToFile(preferences_filename)
except FileNotFoundError:
Logger.log("i", "The preferences file cannot be found, will use default values")
# Force the configuration file to be written again since the list of plugins to remove maybe changed
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading preferences..."))
try:
self._preferences_filename = Resources.getPath(Resources.Preferences, self._app_name + ".cfg")
self._preferences.readFromFile(self._preferences_filename)
except FileNotFoundError:
Logger.log("i", "The preferences file '%s' cannot be found, will use default values",
self._preferences_filename)
self._preferences_filename = Resources.getStoragePath(Resources.Preferences, self._app_name + ".cfg")
# FIXME: This is done here because we now use "plugins.json" to manage plugins instead of the Preferences file,
# but the PluginRegistry will still import data from the Preferences files if present, such as disabled plugins,
# so we need to reset those values AFTER the Preferences file is loaded.
self._plugin_registry.initializeAfterPluginsAreLoaded()
# Check if we have just updated from an older version
self._preferences.addPreference("general/last_run_version", "")
last_run_version_str = self._preferences.getValue("general/last_run_version")
if not last_run_version_str:
last_run_version_str = self._version
last_run_version = Version(last_run_version_str)
current_version = Version(self._version)
if last_run_version < current_version:
self._just_updated_from_old_version = True
self._preferences.setValue("general/last_run_version", str(current_version))
self._preferences.writeToFile(self._preferences_filename)
# Preferences: recent files
self._preferences.addPreference("%s/recent_files" % self._app_name, "")
file_names = self._preferences.getValue("%s/recent_files" % self._app_name).split(";")
for file_name in file_names:
if not os.path.isfile(file_name):
continue
self._recent_files.append(QUrl.fromLocalFile(file_name))
if not self.getIsHeadLess():
# Initialize System tray icon and make it invisible because it is used only to show pop up messages
self._tray_icon = None
if self._tray_icon_name:
self._tray_icon = QIcon(Resources.getPath(Resources.Images, self._tray_icon_name))
self._tray_icon_widget = QSystemTrayIcon(self._tray_icon)
self._tray_icon_widget.setVisible(False)
# Copyright (c) 2015 Jaime van Kessel, Ultimaker B.V.
# The PostProcessingPlugin is released under the terms of the AGPLv3 or higher.
from UM.Settings.SettingsCategory import SettingsCategory
from UM.Logger import Logger
from UM.Qt.Bindings.SettingsFromCategoryModel import SettingsFromCategoryModel
from UM.i18n import i18nCatalog
import re
i18n_catalog = i18nCatalog("PostProcessingPlugin")
## Base class for scripts. All scripts should inherit the script class.
class Script():
def __init__(self):
super().__init__()
self._settings = None
self._settings_model = None
try:
setting_data = self.getSettingData()
if "key" in setting_data:
self._settings = SettingsCategory(setting_data["key"],
i18n_catalog, self)
self._settings.fillByDict(self.getSettingData())
self._settings_model = SettingsFromCategoryModel(
self._settings)
self._settings_model.sort(lambda t: t["key"])
else:
Logger.log("e",
"Script has no key in meta data. Unable to use.")
except NotImplementedError:
def run(self):
self._i18n_catalog = i18nCatalog("cura");
self.addOutputDevice("local_file", {
"id": "local_file",
"function": self._writeToLocalFile,
"description": self._i18n_catalog.i18nc("Save button tooltip", "Save to Disk"),
"shortDescription": self._i18n_catalog.i18nc("Save button tooltip", "Save to Disk"),
"icon": "save",
"priority": 0
})
self.showSplashMessage(self._i18n_catalog.i18nc("Splash screen message", "Setting up scene..."))
controller = self.getController()
controller.setActiveView("MeshView")
controller.setCameraTool("CameraTool")
controller.setSelectionTool("SelectionTool")
t = controller.getTool("TranslateTool")
if t:
t.setEnabledAxis([ToolHandle.XAxis, ToolHandle.ZAxis])
Selection.selectionChanged.connect(self.onSelectionChanged)
root = controller.getScene().getRoot()
self._platform = Platform(root)
self._volume = BuildVolume.BuildVolume(root)
self.getRenderer().setLightPosition(Vector(0, 150, 0))
self.getRenderer().setBackgroundColor(QColor(245, 245, 245))
self._physics = PlatformPhysics.PlatformPhysics(controller, self._volume)
camera = Camera("3d", root)
camera.setPosition(Vector(-150, 150, 300))
camera.setPerspective(True)
camera.lookAt(Vector(0, 0, 0))
self._camera_animation = CameraAnimation.CameraAnimation()
self._camera_animation.setCameraTool(self.getController().getTool("CameraTool"))
controller.getScene().setActiveCamera("3d")
self.showSplashMessage(self._i18n_catalog.i18nc("Splash screen message", "Loading interface..."))
self.setMainQml(Resources.getPath(Resources.QmlFilesLocation, "Cura.qml"))
self.initializeEngine()
self.getStorageDevice("LocalFileStorage").removableDrivesChanged.connect(self._removableDrivesChanged)
if self.getMachines():
active_machine_pref = Preferences.getInstance().getValue("cura/active_machine")
if active_machine_pref:
for machine in self.getMachines():
if machine.getName() == active_machine_pref:
self.setActiveMachine(machine)
if not self.getActiveMachine():
self.setActiveMachine(self.getMachines()[0])
else:
self.requestAddPrinter.emit()
self._removableDrivesChanged()
if self._engine.rootObjects:
self.closeSplash()
for file in self.getCommandLineOption("file", []):
job = ReadMeshJob(os.path.abspath(file))
job.finished.connect(self._onFileLoaded)
job.start()
self.exec_()
# Copyright (c) 2015 Ultimaker B.V.
# Uranium is released under the terms of the LGPLv3 or higher.
from . import PerObjectSettingsTool
from . import PerObjectSettingVisibilityHandler
from PyQt5.QtQml import qmlRegisterType
from UM.i18n import i18nCatalog
i18n_catalog = i18nCatalog("steslicer")
def getMetaData():
return {
"tool": {
"name":
i18n_catalog.i18nc("@label", "Per Model Settings"),
"description":
i18n_catalog.i18nc("@info:tooltip",
"Configure Per Model Settings"),
"icon":
"setting_per_object.svg",
"tool_panel":
"PerObjectSettingsPanel.qml",
"weight":
3
},
}
def register(app):
qmlRegisterType(
from PyQt5.QtQml import QQmlComponent, QQmlContext
from UM.PluginRegistry import PluginRegistry
from UM.Application import Application
from UM.Preferences import Preferences
from UM.Extension import Extension
from UM.Logger import Logger
from pydoc import locate
import os.path
import pkgutil
import sys
from UM.i18n import i18nCatalog
i18n_catalog = i18nCatalog("PostProcessingPlugin")
class PostProcessingPlugin(QObject, Extension):
def __init__(self, parent = None):
super().__init__(parent)
self.addMenuItem(i18n_catalog.i18n("Modify G-Code"), self.showPopup)
self._view = None
# Loaded scripts are all scripts that can be used
self._loaded_scripts = {}
self._script_labels = {}
# Script list contains instances of scripts in loaded_scripts. There can be duplicates and they will be executed in sequence.
self._script_list = []
self._selected_script_index = 0
from UM.FileHandler.FileHandler import FileHandler
from UM.i18n import i18nCatalog
from UM.Scene.SceneNode import SceneNode
from cura.PrinterOutput.NetworkedPrinterOutputDevice import AuthState
from cura.PrinterOutput.PrinterOutputDevice import ConnectionType
from .ClusterApiClient import ClusterApiClient
from ..ExportFileJob import ExportFileJob
from ..SendMaterialJob import SendMaterialJob
from ..UltimakerNetworkedPrinterOutputDevice import UltimakerNetworkedPrinterOutputDevice
from ..Messages.PrintJobUploadBlockedMessage import PrintJobUploadBlockedMessage
from ..Messages.PrintJobUploadErrorMessage import PrintJobUploadErrorMessage
from ..Messages.PrintJobUploadSuccessMessage import PrintJobUploadSuccessMessage
I18N_CATALOG = i18nCatalog("cura")
class LocalClusterOutputDevice(UltimakerNetworkedPrinterOutputDevice):
activeCameraUrlChanged = pyqtSignal()
def __init__(self,
device_id: str,
address: str,
properties: Dict[bytes, bytes],
parent=None) -> None:
super().__init__(device_id=device_id,
address=address,
properties=properties,
# Copyright (c) 2015 Ultimaker B.V.
# Uranium is released under the terms of the AGPLv3 or higher.
from . import CuraProfileWriter
from UM.i18n import i18nCatalog
catalog = i18nCatalog("cura")
def getMetaData():
return {
"plugin": {
"name": catalog.i18nc("@label", "Cura Profile Writer"),
"author": "Ultimaker",
"version": "1.0",
"description": catalog.i18nc("@info:whatsthis", "Provides support for exporting Cura profiles."),
"api": 3
},
"profile_writer": [
{
"extension": "curaprofile",
"description": catalog.i18nc("@item:inlistbox", "Cura Profile")
}
]
}
def register(app):
return { "profile_writer": CuraProfileWriter.CuraProfileWriter() }
def run(self):
if not "PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION" in os.environ or os.environ[
"PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] != "cpp":
Logger.log(
"w",
"Using Python implementation of Protobuf, expect bad performance!"
)
self._i18n_catalog = i18nCatalog("cura")
i18nCatalog.setTagReplacements({
"filename":
"font color=\"black\"",
"message":
"font color=UM.Theme.colors.message_text;",
})
self.showSplashMessage(
self._i18n_catalog.i18nc("@info:progress", "Setting up scene..."))
controller = self.getController()
controller.setActiveView("MeshView")
controller.setCameraTool("CameraTool")
controller.setSelectionTool("SelectionTool")
t = controller.getTool("TranslateTool")
if t:
t.setEnabledAxis(
[ToolHandle.XAxis, ToolHandle.YAxis, ToolHandle.ZAxis])
Selection.selectionChanged.connect(self.onSelectionChanged)
root = controller.getScene().getRoot()
self._platform = Platform(root)
self._volume = BuildVolume.BuildVolume(root)
self.getRenderer().setLightPosition(Vector(0, 150, 0))
self.getRenderer().setBackgroundColor(QColor(245, 245, 245))
self._physics = PlatformPhysics.PlatformPhysics(
controller, self._volume)
camera = Camera("3d", root)
camera.setPosition(Vector(-80, 250, 700))
camera.setPerspective(True)
camera.lookAt(Vector(0, 0, 0))
controller.getScene().setActiveCamera("3d")
self.getController().getTool("CameraTool").setOrigin(Vector(0, 100, 0))
self._camera_animation = CameraAnimation.CameraAnimation()
self._camera_animation.setCameraTool(
self.getController().getTool("CameraTool"))
self.showSplashMessage(
self._i18n_catalog.i18nc("@info:progress", "Loading interface..."))
self.setMainQml(
Resources.getPath(self.ResourceTypes.QmlFiles, "Cura.qml"))
self.initializeEngine()
if self._engine.rootObjects:
self.closeSplash()
for file in self.getCommandLineOption("file", []):
self._openFile(file)
self.exec_()
