def setExpandedCategories(self, categories):
categories = list(set(categories))
categories.sort()
joined = ";".join(categories)
if joined != Preferences.getInstance().getValue("cura/categories_expanded"):
Preferences.getInstance().setValue("cura/categories_expanded", joined)
self.expandedCategoriesChanged.emit()
def __init__(self):
super().__init__()
self._scene = Application.getInstance().getController().getScene()
self._yaw = 0
self._pitch = 0
self._origin = Vector(0, 0, 0)
self._min_zoom = 1
self._max_zoom = 2000.0
self._manual_zoom = 200
self._rotate = False
self._move = False
self._dragged = False
self._shift_is_active = None
self._ctrl_is_active = None
self._space_is_active = None
self._start_drag = None
self._start_y = None
self._drag_distance = 0.05
Preferences.getInstance().addPreference("view/invert_zoom", False)
self._invert_zoom = Preferences.getInstance().getValue("view/invert_zoom")
Preferences.getInstance().preferenceChanged.connect(self._onPreferencesChanged)
def __init__(self, parent = None, *args, **kwargs):
super().__init__(parent = parent, *args, **kwargs)
Preferences.getInstance().preferenceChanged.connect(self._onPreferencesChanged)
self._onPreferencesChanged("general/visible_settings")
self.visibilityChanged.connect(self._onVisibilityChanged)
def __init__(self):
Resources.addResourcePath(os.path.join(QtApplication.getInstallPrefix(), "share", "cura"))
if not hasattr(sys, "frozen"):
Resources.addResourcePath(os.path.join(os.path.abspath(os.path.dirname(__file__)), ".."))
super().__init__(name = "cura", version = "master")
self.setRequiredPlugins([
"CuraEngineBackend",
"MeshView",
"LayerView",
"STLReader",
"SelectionTool",
"CameraTool",
"GCodeWriter",
"LocalFileStorage"
])
self._physics = None
self._volume = None
self._platform = None
self._output_devices = {}
self._print_information = None
self._i18n_catalog = None
self.activeMachineChanged.connect(self._onActiveMachineChanged)
Preferences.getInstance().addPreference("cura/active_machine", "")
Preferences.getInstance().addPreference("cura/active_mode", "simple")
def _onActiveMachineChanged(self):
machine = self.getActiveMachine()
if machine:
Preferences.getInstance().setValue("cura/active_machine", machine.getName())
self._volume.setWidth(machine.getSettingValueByKey("machine_width"))
self._volume.setHeight(machine.getSettingValueByKey("machine_height"))
self._volume.setDepth(machine.getSettingValueByKey("machine_depth"))
disallowed_areas = machine.getSettingValueByKey("machine_disallowed_areas")
areas = []
if disallowed_areas:
for area in disallowed_areas:
polygon = []
polygon.append(Vector(area[0][0], 0.2, area[0][1]))
polygon.append(Vector(area[1][0], 0.2, area[1][1]))
polygon.append(Vector(area[2][0], 0.2, area[2][1]))
polygon.append(Vector(area[3][0], 0.2, area[3][1]))
areas.append(polygon)
self._volume.setDisallowedAreas(areas)
self._volume.rebuild()
if self.getController().getTool("ScaleTool"):
self.getController().getTool("ScaleTool").setMaximumBounds(self._volume.getBoundingBox())
offset = machine.getSettingValueByKey("machine_platform_offset")
if offset:
self._platform.setPosition(Vector(offset[0], offset[1], offset[2]))
else:
self._platform.setPosition(Vector(0.0, 0.0, 0.0))
def _onGlobalContainerChanged(self):
if self._global_container_stack:
self._global_container_stack.nameChanged.disconnect(self._onMachineNameChanged)
self._global_container_stack.containersChanged.disconnect(self._onInstanceContainersChanged)
self._global_container_stack.propertyChanged.disconnect(self._onPropertyChanged)
material = self._global_container_stack.findContainer({"type": "material"})
material.nameChanged.disconnect(self._onMaterialNameChanged)
quality = self._global_container_stack.findContainer({"type": "quality"})
quality.nameChanged.disconnect(self._onQualityNameChanged)
self._global_container_stack = Application.getInstance().getGlobalContainerStack()
self._active_container_stack = self._global_container_stack
self.globalContainerChanged.emit()
if self._global_container_stack:
Preferences.getInstance().setValue("cura/active_machine", self._global_container_stack.getId())
self._global_container_stack.nameChanged.connect(self._onMachineNameChanged)
self._global_container_stack.containersChanged.connect(self._onInstanceContainersChanged)
self._global_container_stack.propertyChanged.connect(self._onPropertyChanged)
material = self._global_container_stack.findContainer({"type": "material"})
material.nameChanged.connect(self._onMaterialNameChanged)
quality = self._global_container_stack.findContainer({"type": "quality"})
quality.nameChanged.connect(self._onQualityNameChanged)
def __init__(self):
super().__init__()
Preferences.getInstance().addPreference("view/show_overhang", True)
self._enabled_shader = None
self._disabled_shader = None
def __init__(self, parent = None):
super().__init__(parent)
self._current_print_time = Duration(None, self)
self._material_lengths = []
self._material_weights = []
self._material_costs = []
self._pre_sliced = False
self._backend = Application.getInstance().getBackend()
if self._backend:
self._backend.printDurationMessage.connect(self._onPrintDurationMessage)
self._job_name = ""
self._abbr_machine = ""
Application.getInstance().globalContainerStackChanged.connect(self._setAbbreviatedMachineName)
Application.getInstance().fileLoaded.connect(self.setJobName)
Preferences.getInstance().preferenceChanged.connect(self._onPreferencesChanged)
self._active_material_container = None
Application.getInstance().getMachineManager().activeMaterialChanged.connect(self._onActiveMaterialChanged)
self._onActiveMaterialChanged()
self._material_amounts = []
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 saveMachineInstances(self):
if self._active_machine:
Preferences.getInstance().setValue("machines/active_instance", self._active_machine.getName())
for instance in self._machine_instances:
file_name = urllib.parse.quote_plus(instance.getName()) + ".cfg"
instance.saveToFile(Resources.getStoragePath(Resources.MachineInstances, file_name))
def __init__(self, parent = None):
super().__init__(parent)
self._global_container_stack = None
Application.getInstance().globalContainerStackChanged.connect(self._onGlobalContainerChanged)
self._global_stack_valid = None
self._onGlobalContainerChanged()
## When the global container is changed, active material probably needs to be updated.
self.globalContainerChanged.connect(self.activeMaterialChanged)
self.globalContainerChanged.connect(self.activeVariantChanged)
self.globalContainerChanged.connect(self.activeQualityChanged)
self._empty_variant_container = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(id = "empty_variant")[0]
self._empty_material_container = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(id = "empty_material")[0]
self._empty_quality_container = UM.Settings.ContainerRegistry.getInstance().findInstanceContainers(id = "empty_quality")[0]
Preferences.getInstance().addPreference("cura/active_machine", "")
active_machine_id = Preferences.getInstance().getValue("cura/active_machine")
if active_machine_id != "":
# An active machine was saved, so restore it.
self.setActiveMachine(active_machine_id)
pass
def __init__(self, engine, parent = None):
super().__init__(parent)
self._engine = engine
self._styles = None
self._path = ""
self._icons = {}
self._images = {}
# Workaround for incorrect default font on Windows
if sys.platform == "win32":
default_font = QFont()
default_font.setPointSize(9)
QCoreApplication.instance().setFont(default_font)
self._em_height = int(QFontMetrics(QCoreApplication.instance().font()).ascent())
self._em_width = self._em_height;
self._initializeDefaults()
Preferences.getInstance().addPreference("general/theme", Application.getInstance().getApplicationName())
try:
theme_path = Resources.getPath(Resources.Themes, Preferences.getInstance().getValue("general/theme"))
self.load(theme_path)
except FileNotFoundError:
Logger.log("e", "Could not find theme file.")
def __init__(self):
super().__init__()
self.addMenuItem(i18n_catalog.i18nc("@item:inmenu", "Check for Updates"), self.checkNewVersion)
Preferences.getInstance().addPreference("info/automatic_update_check", True)
if Preferences.getInstance().getValue("info/automatic_update_check"):
self.checkNewVersion(True)
def __init__(self):
super().__init__()
self._shader = None
self._selection_shader = None
self._num_layers = 0
self._layer_percentage = 0 # what percentage of layers need to be shown (SLider gives value between 0 - 100)
self._proxy = LayerViewProxy.LayerViewProxy()
self._controller.getScene().getRoot().childrenChanged.connect(self._onSceneChanged)
self._max_layers = 0
self._current_layer_num = 0
self._current_layer_mesh = None
self._current_layer_jumps = None
self._top_layers_job = None
self._activity = False
Preferences.getInstance().addPreference("view/top_layer_count", 1)
Preferences.getInstance().preferenceChanged.connect(self._onPreferencesChanged)
self._solid_layers = int(Preferences.getInstance().getValue("view/top_layer_count"))
self._top_layer_timer = QTimer()
self._top_layer_timer.setInterval(50)
self._top_layer_timer.setSingleShot(True)
self._top_layer_timer.timeout.connect(self._startUpdateTopLayers)
self._busy = False
def _onPreferencesChanged(self, preference):
if preference != "view/top_layer_count" and preference != "view/only_show_top_layers":
return
self._solid_layers = int(Preferences.getInstance().getValue("view/top_layer_count"))
self._only_show_top_layers = bool(Preferences.getInstance().getValue("view/only_show_top_layers"))
self._startUpdateTopLayers()
def __init__(self):
super().__init__()
Preferences.getInstance().addPreference("view/show_overhang", False)
Preferences.getInstance().preferenceChanged.connect(self._onPreferenceChanged)
self._enabled_material = None
self._disabled_material = None
def __init__(self):
super().__init__()
self._model = None
self.setExposedProperties("Model", "SelectedIndex")
Preferences.getInstance().preferenceChanged.connect(self._onPreferenceChanged)
self._onPreferenceChanged("cura/active_mode")
def _onTimeout(self):
self._saving = True # To prevent the save process from triggering another autosave.
Logger.log("d", "Autosaving preferences, instances and profiles")
Application.getInstance().saveSettings()
Preferences.getInstance().writeToFile(Resources.getStoragePath(Resources.Preferences, Application.getInstance().getApplicationName() + ".cfg"))
self._saving = False
def __init__(self):
super().__init__()
self._model = None
self.setExposedProperties("SelectedObjectId","ContainerID")
Preferences.getInstance().preferenceChanged.connect(self._onPreferenceChanged)
Selection.selectionChanged.connect(self.propertyChanged)
self._onPreferenceChanged("cura/active_mode")
def __init__(self):
super().__init__()
# Find out where the engine is located, and how it is called. This depends on how Cura is packaged and which OS we are running on.
default_engine_location = os.path.join(Application.getInstallPrefix(), "bin", "CuraEngine")
if hasattr(sys, "frozen"):
default_engine_location = os.path.join(os.path.dirname(os.path.abspath(sys.executable)), "CuraEngine")
if sys.platform == "win32":
default_engine_location += ".exe"
default_engine_location = os.path.abspath(default_engine_location)
Preferences.getInstance().addPreference("backend/location", default_engine_location)
self._scene = Application.getInstance().getController().getScene()
self._scene.sceneChanged.connect(self._onSceneChanged)
# Workaround to disable layer view processing if layer view is not active.
self._layer_view_active = False
Application.getInstance().getController().activeViewChanged.connect(self._onActiveViewChanged)
self._onActiveViewChanged()
self._stored_layer_data = []
#Triggers for when to (re)start slicing:
self._global_container_stack = None
Application.getInstance().globalContainerStackChanged.connect(self._onGlobalStackChanged)
self._onGlobalStackChanged()
#When you update a setting and other settings get changed through inheritance, many propertyChanged signals are fired.
#This timer will group them up, and only slice for the last setting changed signal.
#TODO: Properly group propertyChanged signals by whether they are triggered by the same user interaction.
self._change_timer = QTimer()
self._change_timer.setInterval(500)
self._change_timer.setSingleShot(True)
self._change_timer.timeout.connect(self.slice)
#Listeners for receiving messages from the back-end.
self._message_handlers["cura.proto.Layer"] = self._onLayerMessage
self._message_handlers["cura.proto.Progress"] = self._onProgressMessage
self._message_handlers["cura.proto.GCodeLayer"] = self._onGCodeLayerMessage
self._message_handlers["cura.proto.GCodePrefix"] = self._onGCodePrefixMessage
self._message_handlers["cura.proto.ObjectPrintTime"] = self._onObjectPrintTimeMessage
self._message_handlers["cura.proto.SlicingFinished"] = self._onSlicingFinishedMessage
self._start_slice_job = None
self._slicing = False #Are we currently slicing?
self._restart = False #Back-end is currently restarting?
self._enabled = True #Should we be slicing? Slicing might be paused when, for instance, the user is dragging the mesh around.
self._always_restart = True #Always restart the engine when starting a new slice. Don't keep the process running. TODO: Fix engine statelessness.
self._process_layers_job = None #The currently active job to process layers, or None if it is not processing layers.
self._error_message = None #Pop-up message that shows errors.
self.backendQuit.connect(self._onBackendQuit)
self.backendConnected.connect(self._onBackendConnected)
#When a tool operation is in progress, don't slice. So we need to listen for tool operations.
Application.getInstance().getController().toolOperationStarted.connect(self._onToolOperationStarted)
Application.getInstance().getController().toolOperationStopped.connect(self._onToolOperationStopped)
def __init__(self):
super().__init__()
Preferences.getInstance().addPreference("view/show_overhang", True)
self._enabled_shader = None
self._disabled_shader = None
self._extruders_model = cura.Settings.ExtrudersModel()
def __init__(self):
super().__init__()
# Find out where the engine is located, and how it is called. This depends on how Cura is packaged and which OS we are running on.
default_engine_location = os.path.join(Application.getInstallPrefix(), "bin", "CuraEngine")
if hasattr(sys, "frozen"):
default_engine_location = os.path.join(os.path.dirname(os.path.abspath(sys.executable)), "CuraEngine")
if sys.platform == "win32":
default_engine_location += ".exe"
default_engine_location = os.path.abspath(default_engine_location)
Preferences.getInstance().addPreference("backend/location", default_engine_location)
self._scene = Application.getInstance().getController().getScene()
self._scene.sceneChanged.connect(self._onSceneChanged)
# Workaround to disable layer view processing if layer view is not active.
self._layer_view_active = False
Application.getInstance().getController().activeViewChanged.connect(self._onActiveViewChanged)
self._onActiveViewChanged()
self._stored_layer_data = []
# When there are current settings and machine instance is changed, there is no profile changed event. We should
# pretend there is though.
Application.getInstance().getMachineManager().activeMachineInstanceChanged.connect(self._onActiveProfileChanged)
self._profile = None
Application.getInstance().getMachineManager().activeProfileChanged.connect(self._onActiveProfileChanged)
self._onActiveProfileChanged()
self._change_timer = QTimer()
self._change_timer.setInterval(500)
self._change_timer.setSingleShot(True)
self._change_timer.timeout.connect(self.slice)
self._message_handlers["cura.proto.Layer"] = self._onLayerMessage
self._message_handlers["cura.proto.Progress"] = self._onProgressMessage
self._message_handlers["cura.proto.GCodeLayer"] = self._onGCodeLayerMessage
self._message_handlers["cura.proto.GCodePrefix"] = self._onGCodePrefixMessage
self._message_handlers["cura.proto.ObjectPrintTime"] = self._onObjectPrintTimeMessage
self._message_handlers["cura.proto.SlicingFinished"] = self._onSlicingFinishedMessage
self._slicing = False
self._start_slice_job = None
self._restart = False
self._enabled = True
self._always_restart = True
self._process_layers_job = None #The currently active job to process layers, or None if it is not processing layers.
self._message = None
self.backendQuit.connect(self._onBackendQuit)
self.backendConnected.connect(self._onBackendConnected)
Application.getInstance().getController().toolOperationStarted.connect(self._onToolOperationStarted)
Application.getInstance().getController().toolOperationStopped.connect(self._onToolOperationStopped)
Application.getInstance().getMachineManager().activeMachineInstanceChanged.connect(self._onInstanceChanged)
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 __init__(self):
super().__init__()
self.addMenuItem(i18n_catalog.i18nc("@item:inmenu", "Check for Updates"), self.checkNewVersion)
self._url = None
Preferences.getInstance().addPreference("info/automatic_update_check", True)
if Preferences.getInstance().getValue("info/automatic_update_check"):
thread = Thread(target = self.checkNewVersion, args = (True,))
thread.daemon = True
thread.start()
def _onGlobalContainerChanged(self):
if self._global_container_stack:
self._global_container_stack.containersChanged.disconnect(self._onInstanceContainersChanged)
self._global_container_stack = Application.getInstance().getGlobalContainerStack()
self.globalContainerChanged.emit()
if self._global_container_stack:
Preferences.getInstance().setValue("cura/active_machine", self._global_container_stack.getId())
self._global_container_stack.containersChanged.connect(self._onInstanceContainersChanged)
def saveVisibility(self):
if not self._active_machine:
Logger.log("w", "No active machine found when trying to save setting visibility")
return
visible_settings = self._active_machine.getMachineDefinition().getAllSettings(visible_only = True)
visible_settings = map(lambda s: s.getKey(), visible_settings)
preference = ",".join(visible_settings)
Preferences.getInstance().setValue("machines/setting_visibility", preference)
def didAgree(self, user_choice):
if user_choice:
Logger.log("i", "User agreed to the user agreement")
Preferences.getInstance().setValue("general/accepted_user_agreement", True)
self._user_agreement_window.hide()
else:
Logger.log("i", "User did NOT agree to the user agreement")
Preferences.getInstance().setValue("general/accepted_user_agreement", False)
CuraApplication.getInstance().quit()
CuraApplication.getInstance().setNeedToShowUserAgreement(False)
def __init__(self):
super().__init__()
Application.getInstance().getOutputDeviceManager().writeStarted.connect(self._onWriteStarted)
Preferences.getInstance().addPreference("info/send_slice_info", True)
Preferences.getInstance().addPreference("info/asked_send_slice_info", False)
if not Preferences.getInstance().getValue("info/asked_send_slice_info"):
self.send_slice_info_message = Message(catalog.i18nc("@info", "Cura automatically sends slice info. You can disable this in preferences"), lifetime = 0, dismissable = False)
self.send_slice_info_message.addAction("Dismiss", catalog.i18nc("@action:button", "Dismiss"), None, "")
self.send_slice_info_message.actionTriggered.connect(self.messageActionTriggered)
self.send_slice_info_message.show()
def __init__(self):
super().__init__()
Preferences.getInstance().addPreference("view/show_overhang", True)
self._enabled_shader = None
self._disabled_shader = None
self._non_printing_shader = None
self._extruders_model = ExtrudersModel()
self._theme = None
def _onEngineCreated(self):
if not self._version:
return #We're on dev branch.
if Preferences.getInstance().getValue("general/latest_version_changelog_shown") == "master":
latest_version_shown = Version("0.0.0")
else:
latest_version_shown = Version(Preferences.getInstance().getValue("general/latest_version_changelog_shown"))
if self._version > latest_version_shown:
self.showChangelog()
def createJobName(self, base_name):
if base_name == "":
return ""
base_name = self._stripAccents(base_name)
self._setAbbreviatedMachineName()
if self._pre_sliced:
return catalog.i18nc("@label", "Pre-sliced file {0}", base_name)
elif Preferences.getInstance().getValue("cura/jobname_prefix"):
# Don't add abbreviation if it already has the exact same abbreviation.
if base_name.startswith(self._abbr_machine + "_"):
return base_name
return self._abbr_machine + "_" + base_name
else:
return base_name
def onSelectionChanged(self):
if Selection.hasSelection():
if not self.getController().getActiveTool():
if self._previous_active_tool:
self.getController().setActiveTool(self._previous_active_tool)
self._previous_active_tool = None
else:
self.getController().setActiveTool("TranslateTool")
if Preferences.getInstance().getValue("view/center_on_select"):
self._center_after_select = True
else:
if self.getController().getActiveTool():
self._previous_active_tool = self.getController().getActiveTool().getPluginId()
self.getController().setActiveTool(None)
def __init__(self, app_name):
super().__init__()
self._application_name = app_name
self._machine_definitions = []
self._machine_instances = []
self._profiles = [
] # All the profiles that are loaded from disk, for any machine instance
self._active_machine = None
self._active_profile = None
self._protect_working_profile = False
self._profile_readers = {} # Plugins that read profiles from file.
self._profile_writers = {} # Plugins that write profiles to file.
PluginRegistry.addType("profile_reader", self.addProfileReader)
PluginRegistry.addType("profile_writer", self.addProfileWriter)
Preferences.getInstance().addPreference("machines/setting_visibility",
"")
Preferences.getInstance().addPreference("machines/active_instance", "")
def __init__(self):
super().__init__()
Preferences.getInstance().preferenceChanged.connect(self._triggerTimer)
self._global_stack = None
Preferences.getInstance().addPreference("cura/autosave_delay", 1000 * 10)
self._change_timer = QTimer()
self._change_timer.setInterval(Preferences.getInstance().getValue("cura/autosave_delay"))
self._change_timer.setSingleShot(True)
self._saving = False
# At this point, the Application instance has not finished its constructor call yet, so directly using something
# like Application.getInstance() is not correct. The initialisation now will only gets triggered after the
# application finishes its start up successfully.
self._init_timer = QTimer()
self._init_timer.setInterval(1000)
self._init_timer.setSingleShot(True)
self._init_timer.timeout.connect(self.initialize)
self._init_timer.start()
def getEngineCommand(self):
active_machine = Application.getInstance().getMachineManager(
).getActiveMachineInstance()
json_path = ""
if not active_machine:
json_path = Resources.getPath(Resources.MachineDefinitions,
"fdmprinter.json")
else:
json_path = active_machine.getMachineDefinition().getPath()
return [
Preferences.getInstance().getValue("backend/location"), "connect",
"127.0.0.1:{0}".format(self._port), "-j", json_path, "-vv"
]
def __init__(self, controller, volume):
super().__init__()
self._controller = controller
self._controller.getScene().sceneChanged.connect(self._onSceneChanged)
self._controller.toolOperationStarted.connect(
self._onToolOperationStarted)
self._controller.toolOperationStopped.connect(
self._onToolOperationStopped)
self._build_volume = volume
self._enabled = True
self._change_timer = QTimer()
self._change_timer.setInterval(100)
self._change_timer.setSingleShot(True)
self._change_timer.timeout.connect(self._onChangeTimerFinished)
self._move_factor = 1.1 # By how much should we multiply overlap to calculate a new spot?
self._max_overlap_checks = 10 # How many times should we try to find a new spot per tick?
self._minimum_gap = 2 # It is a minimum distance (in mm) between two models, applicable for small models
Preferences.getInstance().addPreference("physics/automatic_push_free",
True)
Preferences.getInstance().addPreference("physics/automatic_drop_down",
True)
def showConfigUI(self):
self._ui_lock.acquire()
preference = Preferences.getInstance().getValue("cura_solidworks/choice_on_exporting_stl_quality")
if preference != "always_ask":
if preference == "always_use_fine":
self.quality = "fine"
elif preference == "always_use_coarse":
self.quality = "coarse"
else:
self.quality = "fine"
self._ui_lock.release()
return
self._cancelled = False
self.show_config_ui_trigger.emit()
def _getDefaultLanguage(self, file):
# If we have a language override set in the environment, try and use that.
lang = os.getenv("URANIUM_LANGUAGE")
if lang:
try:
return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES",
file + ".qm")
except FileNotFoundError:
pass
# Else, try and get the current language from preferences
lang = Preferences.getInstance().getValue("general/language")
if lang:
try:
return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES",
file + ".qm")
except FileNotFoundError:
pass
# If none of those are set, try to use the environment's LANGUAGE variable.
lang = os.getenv("LANGUAGE")
if lang:
try:
return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES",
file + ".qm")
except FileNotFoundError:
pass
# If looking up the language from the enviroment or preferences fails, try and use Qt's system locale instead.
locale = QLocale.system()
# First, try and find a directory for any of the provided languages
for lang in locale.uiLanguages():
try:
return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES",
file + ".qm")
except FileNotFoundError:
pass
# If that fails, see if we can extract a language "class" from the
# preferred language. This will turn "en-GB" into "en" for example.
lang = locale.uiLanguages()[0]
lang = lang[0:lang.find("-")]
try:
return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES",
file + ".qm")
except FileNotFoundError:
pass
return None
def windowClosed(self):
Logger.log("d", "Shutting down %s", self.getApplicationName())
self._shutting_down = True
try:
Preferences.getInstance().writeToFile(
Resources.getStoragePath(Resources.Preferences,
self.getApplicationName() + ".cfg"))
except Exception as e:
Logger.log("e", "Exception while saving preferences: %s", repr(e))
try:
self.applicationShuttingDown.emit()
except Exception as e:
Logger.log("e", "Exception while emitting shutdown signal: %s",
repr(e))
try:
self.getBackend().close()
except Exception as e:
Logger.log("e", "Exception while closing backend: %s", repr(e))
self.quit()
def getApplicationLanguage(self):
override_lang = os.getenv("URANIUM_LANGUAGE")
if override_lang:
return override_lang
preflang = Preferences.getInstance().getValue("general/language")
if preflang:
return preflang
env_lang = os.getenv("LANGUAGE")
if env_lang:
return env_lang
return "en"
def __init__(self):
Application.getInstance().hideMessageSignal.connect(
self._onHideMessage)
self._cancelled = False
self._message = None
self._layer_number = 0
self._extruder_number = 0
self._clearValues()
self._scene_node = None
# X, Y, Z position, F feedrate and E extruder values are stored
self._position = namedtuple('Position', ['x', 'y', 'z', 'f', 'e'])
self._is_layers_in_file = False # Does the Gcode have the layers comment?
self._extruder_offsets = {
} # Offsets for multi extruders. key is index, value is [x-offset, y-offset]
self._current_layer_thickness = 0.2 # default
self._total_move_length = 0
self._extrusion_retraction_length = 0
self._extrusion_max_amounts = [0]
self._extrusion_saved_value = [0]
Preferences.getInstance().addPreference("gcodereader/show_caution",
True)
def __init__(self):
super().__init__()
self._max_layers = 0
self._current_layer_num = 0
self._minimum_layer_num = 0
self._current_layer_mesh = None
self._current_layer_jumps = None
self._top_layers_job = None
self._activity = False
self._old_max_layers = 0
self._busy = False
self._ghost_shader = None
self._layer_pass = None
self._composite_pass = None
self._old_layer_bindings = None
self._layerview_composite_shader = None
self._old_composite_shader = None
self._global_container_stack = None
self._proxy = LayerViewProxy.LayerViewProxy()
self._controller.getScene().getRoot().childrenChanged.connect(
self._onSceneChanged)
self._resetSettings()
self._legend_items = None
Preferences.getInstance().addPreference("view/top_layer_count", 5)
Preferences.getInstance().addPreference("view/only_show_top_layers",
False)
Preferences.getInstance().preferenceChanged.connect(
self._onPreferencesChanged)
self._solid_layers = int(
Preferences.getInstance().getValue("view/top_layer_count"))
self._only_show_top_layers = bool(
Preferences.getInstance().getValue("view/only_show_top_layers"))
self._compatibility_mode = True # for safety
self._wireprint_warning_message = Message(
catalog.i18nc(
"@info:status",
"Cura does not accurately display layers when Wire Printing is enabled"
))
def __init__(self):
super().__init__()
Application.getInstance().getOutputDeviceManager(
).writeStarted.connect(self._onWriteStarted)
Preferences.getInstance().addPreference("info/send_slice_info", True)
Preferences.getInstance().addPreference("info/asked_send_slice_info",
False)
if not Preferences.getInstance().getValue(
"info/asked_send_slice_info"):
self.send_slice_info_message = Message(
catalog.i18nc("@info",
"Cura collects anonymized usage statistics."),
lifetime=0,
dismissable=False,
title=catalog.i18nc("@info:title", "Collecting Data"))
self.send_slice_info_message.addAction(
"Dismiss",
name=catalog.i18nc("@action:button", "Allow"),
icon=None,
description=catalog.i18nc(
"@action:tooltip",
"Allow Cura to send anonymized usage statistics to help prioritize future improvements to Cura. Some of your preferences and settings are sent, the Cura version and a hash of the models you're slicing."
))
self.send_slice_info_message.addAction(
"Disable",
name=catalog.i18nc("@action:button", "Disable"),
icon=None,
description=catalog.i18nc(
"@action:tooltip",
"Don't allow Cura to send anonymized usage statistics. You can enable it again in the preferences."
),
button_style=Message.ActionButtonStyle.LINK)
self.send_slice_info_message.actionTriggered.connect(
self.messageActionTriggered)
self.send_slice_info_message.show()
def __init__(self):
super().__init__()
self._zero_conf = None
self._browser = None
self._printers = {}
self._cluster_printers_seen = {
} # do not forget a cluster printer when we have seen one, to not 'downgrade' from Connect to legacy printer
self._api_version = "1"
self._api_prefix = "/api/v" + self._api_version + "/"
self._cluster_api_version = "1"
self._cluster_api_prefix = "/cluster-api/v" + self._cluster_api_version + "/"
self._network_manager = QNetworkAccessManager()
self._network_manager.finished.connect(self._onNetworkRequestFinished)
# List of old printer names. This is used to ensure that a refresh of zeroconf does not needlessly forces
# authentication requests.
self._old_printers = []
self._excluded_addresses = [
"127.0.0.1"
] # Adding a list of not allowed IP addresses. At this moment, just localhost
# Because the model needs to be created in the same thread as the QMLEngine, we use a signal.
self.addPrinterSignal.connect(self.addPrinter)
self.removePrinterSignal.connect(self.removePrinter)
Application.getInstance().globalContainerStackChanged.connect(
self.reCheckConnections)
# Get list of manual printers from preferences
self._preferences = Preferences.getInstance()
self._preferences.addPreference(
"um3networkprinting/manual_instances",
"") # A comma-separated list of ip adresses or hostnames
self._manual_instances = self._preferences.getValue(
"um3networkprinting/manual_instances").split(",")
self._network_requests_buffer = {
} # store api responses until data is complete
# The zeroconf service changed requests are handled in a separate thread, so we can re-schedule the requests
# which fail to get detailed service info.
# Any new or re-scheduled requests will be appended to the request queue, and the handling thread will pick
# them up and process them.
self._service_changed_request_queue = Queue()
self._service_changed_request_event = Event()
self._service_changed_request_thread = Thread(
target=self._handleOnServiceChangedRequests, daemon=True)
self._service_changed_request_thread.start()
def setActiveQuality(self, quality_id):
containers = UM.Settings.ContainerRegistry.getInstance(
).findInstanceContainers(id=quality_id)
if not containers or not self._active_container_stack:
return
old_quality = self._active_container_stack.findContainer(
{"type": "quality"})
if old_quality and old_quality != containers[0]:
old_quality.nameChanged.disconnect(self._onQualityNameChanged)
quality_index = self._active_container_stack.getContainerIndex(
old_quality)
self._active_container_stack.replaceContainer(
quality_index, containers[0])
containers[0].nameChanged.connect(self._onQualityNameChanged)
if self.hasUserSettings and Preferences.getInstance().getValue(
"cura/active_mode") == 1:
# Ask the user if the user profile should be cleared or not (discarding the current settings)
# In Simple Mode we assume the user always wants to keep the (limited) current settings
details = catalog.i18nc(
"@label", "You made changes to the following setting(s):")
user_settings = self._active_container_stack.getTop(
).findInstances(**{})
for setting in user_settings:
details = details + "\n " + setting.definition.label
Application.getInstance().messageBox(
catalog.i18nc("@window:title", "Switched profiles"),
catalog.i18nc(
"@label",
"Do you want to transfer your changed settings to this profile?"
),
catalog.i18nc(
"@label",
"If you transfer your settings they will override settings in the profile."
),
details,
buttons=QMessageBox.Yes + QMessageBox.No,
icon=QMessageBox.Question,
callback=self._keepUserSettingsDialogCallback)
else:
Logger.log(
"w",
"While trying to set the active quality, no quality was found to replace."
)
def _getDefaultLanguage(self, file_name):
# If we have a language override set in the environment, try and use that.
lang = os.getenv("URANIUM_LANGUAGE")
if lang:
try:
return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file_name + ".qm")
except FileNotFoundError:
pass
# Else, try and get the current language from preferences
lang = Preferences.getInstance().getValue("general/language")
if lang:
try:
return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file_name + ".qm")
except FileNotFoundError:
pass
# If none of those are set, try to use the environment's LANGUAGE variable.
lang = os.getenv("LANGUAGE")
if lang:
try:
return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file_name + ".qm")
except FileNotFoundError:
pass
# If looking up the language from the enviroment or preferences fails, try and use Qt's system locale instead.
locale = QLocale.system()
# First, try and find a directory for any of the provided languages
for lang in locale.uiLanguages():
try:
return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file_name + ".qm")
except FileNotFoundError:
pass
# If that fails, see if we can extract a language code from the
# preferred language, regardless of the country code. This will turn
# "en-GB" into "en" for example.
lang = locale.uiLanguages()[0]
lang = lang[0:lang.find("-")]
for subdirectory in os.path.listdir(Resources.getPath(Resources.i18n)):
if subdirectory == "en_7S": #Never automatically go to Pirate.
continue
if not os.path.isdir(Resources.getPath(Resources.i18n, subdirectory)):
continue
if subdirectory.startswith(lang + "_"): #Only match the language code, not the country code.
return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file_name + ".qm")
return None
def _onActiveMachineChanged(self):
machine = self.getActiveMachine()
if machine:
Preferences.getInstance().setValue("cura/active_machine", machine.getName())
self._volume.setWidth(machine.getSettingValueByKey("machine_width"))
self._volume.setHeight(machine.getSettingValueByKey("machine_height"))
self._volume.setDepth(machine.getSettingValueByKey("machine_depth"))
disallowed_areas = machine.getSettingValueByKey("machine_disallowed_areas")
areas = []
if disallowed_areas:
for area in disallowed_areas:
areas.append(Polygon(numpy.array(area, numpy.float32)))
self._volume.setDisallowedAreas(areas)
self._volume.rebuild()
offset = machine.getSettingValueByKey("machine_platform_offset")
if offset:
self._platform.setPosition(Vector(offset[0], offset[1], offset[2]))
else:
self._platform.setPosition(Vector(0.0, 0.0, 0.0))
def stopSlicing(self):
self.backendStateChange.emit(BackendState.NotStarted)
if self._slicing: # We were already slicing. Stop the old job.
self._terminate()
self._createSocket()
if not Preferences.getInstance().getValue("general/auto_slice"):
self.needsSlicing()
if self._process_layers_job: # We were processing layers. Stop that, the layers are going to change soon.
Logger.log("d", "Aborting process layers job...")
self._process_layers_job.abort()
self._process_layers_job = None
if self._error_message:
self._error_message.hide()
def __init__(self, parent = None):
super().__init__(parent)
self.initializeCuraMessagePrintTimeProperties()
self._material_lengths = {} # indexed by build plate number
self._material_weights = {}
self._material_costs = {}
self._material_names = {}
self._pre_sliced = False
self._backend = Application.getInstance().getBackend()
if self._backend:
self._backend.printDurationMessage.connect(self._onPrintDurationMessage)
Application.getInstance().getController().getScene().sceneChanged.connect(self._onSceneChanged)
self._base_name = ""
self._abbr_machine = ""
self._job_name = ""
self._project_name = ""
self._active_build_plate = 0
self._initVariablesWithBuildPlate(self._active_build_plate)
Application.getInstance().globalContainerStackChanged.connect(self._updateJobName)
Application.getInstance().fileLoaded.connect(self.setBaseName)
Application.getInstance().getBuildPlateModel().activeBuildPlateChanged.connect(self._onActiveBuildPlateChanged)
Application.getInstance().workspaceLoaded.connect(self.setProjectName)
Preferences.getInstance().preferenceChanged.connect(self._onPreferencesChanged)
self._active_material_container = None
Application.getInstance().getMachineManager().activeMaterialChanged.connect(self._onActiveMaterialChanged)
self._onActiveMaterialChanged()
self._material_amounts = []
def __init__(self):
super().__init__()
self._shader = None
self._selection_shader = None
self._num_layers = 0
self._layer_percentage = 0 # what percentage of layers need to be shown (SLider gives value between 0 - 100)
self._proxy = LayerViewProxy.LayerViewProxy()
self._controller.getScene().getRoot().childrenChanged.connect(
self._onSceneChanged)
self._max_layers = 0
self._current_layer_num = 0
self._current_layer_mesh = None
self._current_layer_jumps = None
self._top_layers_job = None
self._activity = False
Preferences.getInstance().addPreference("view/top_layer_count", 5)
Preferences.getInstance().preferenceChanged.connect(
self._onPreferencesChanged)
self._solid_layers = int(
Preferences.getInstance().getValue("view/top_layer_count"))
self._busy = False
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self._background_color = QColor(204, 204, 204, 255)
self.setClearBeforeRendering(False)
self.beforeRendering.connect(self._render, type=Qt.DirectConnection)
self._mouse_device = QtMouseDevice(self)
self._mouse_device.setPluginId("qt_mouse")
self._key_device = QtKeyDevice()
self._key_device.setPluginId("qt_key")
self._previous_focus = None
self._app = QCoreApplication.instance()
self._app.getController().addInputDevice(self._mouse_device)
self._app.getController().addInputDevice(self._key_device)
self._app.getController().getScene().sceneChanged.connect(
self._onSceneChanged)
self._preferences = Preferences.getInstance()
self._preferences.addPreference("general/window_width", 1280)
self._preferences.addPreference("general/window_height", 720)
self._preferences.addPreference("general/window_left", 50)
self._preferences.addPreference("general/window_top", 50)
self._preferences.addPreference("general/window_state",
Qt.WindowNoState)
# Restore window geometry
self.setWidth(int(self._preferences.getValue("general/window_width")))
self.setHeight(int(
self._preferences.getValue("general/window_height")))
self.setPosition(
int(self._preferences.getValue("general/window_left")),
int(self._preferences.getValue("general/window_top")))
# Make sure restored geometry is not outside the currently available screens
if not self.geometry().intersects(self.screen().availableGeometry()):
self.setPosition(50, 50)
self.setWindowState(
int(self._preferences.getValue("general/window_state")))
self._mouse_x = 0
self._mouse_y = 0
self._viewport_rect = QRectF(0, 0, 1.0, 1.0)
Application.getInstance().setMainWindow(self)
self._fullscreen = False
def beginRendering(self):
scene = self.getController().getScene()
renderer = self.getRenderer()
if not self._enabled_shader:
self._enabled_shader = OpenGL.getInstance().createShaderProgram(
Resources.getPath(Resources.Shaders, "overhang.shader"))
if not self._disabled_shader:
self._disabled_shader = OpenGL.getInstance().createShaderProgram(
Resources.getPath(Resources.Shaders, "overhang.shader"))
self._disabled_shader.setUniformValue("u_diffuseColor",
[0.68, 0.68, 0.68, 1.0])
if Application.getInstance().getMachineManager().getActiveProfile():
profile = Application.getInstance().getMachineManager(
).getActiveProfile()
if profile.getSettingValue(
"support_enable"
) or not Preferences.getInstance().getValue("view/show_overhang"):
angle = profile.getSettingValue("support_angle")
if angle != None:
self._enabled_shader.setUniformValue(
"u_overhangAngle", math.cos(math.radians(90 - angle)))
else:
self._enabled_shader.setUniformValue("u_overhangAngle",
math.cos(math.radians(0)))
for node in DepthFirstIterator(scene.getRoot()):
if not node.render(renderer):
if node.getMeshData() and node.isVisible():
# TODO: Find a better way to handle this
#if node.getBoundingBoxMesh():
# renderer.queueNode(scene.getRoot(), mesh = node.getBoundingBoxMesh(),mode = Renderer.RenderLines)
if hasattr(node, "_outside_buildarea"):
if node._outside_buildarea:
renderer.queueNode(node,
shader=self._disabled_shader)
else:
renderer.queueNode(node,
shader=self._enabled_shader)
else:
renderer.queueNode(node, material=self._enabled_shader)
if node.callDecoration("isGroup"):
renderer.queueNode(scene.getRoot(),
mesh=node.getBoundingBoxMesh(),
mode=Renderer.RenderLines)
def _update(self, *args):
nodes = []
filter_current_build_plate = Preferences.getInstance().getValue(
"view/filter_current_build_plate")
active_build_plate_number = self._build_plate_number
group_nr = 1
for node in DepthFirstIterator(Application.getInstance().getController(
).getScene().getRoot()):
if not isinstance(node, SceneNode):
continue
if (not node.getMeshData()
and not node.callDecoration("getLayerData")
) and not node.callDecoration("isGroup"):
continue
if node.getParent() and node.getParent().callDecoration("isGroup"):
continue # Grouped nodes don't need resetting as their parent (the group) is resetted)
if not node.callDecoration(
"isSliceable") and not node.callDecoration("isGroup"):
continue
node_build_plate_number = node.callDecoration(
"getBuildPlateNumber")
if filter_current_build_plate and node_build_plate_number != active_build_plate_number:
continue
if not node.callDecoration("isGroup"):
name = node.getName()
else:
name = catalog.i18nc(
"@label",
"Group #{group_nr}").format(group_nr=str(group_nr))
group_nr += 1
if hasattr(node, "isOutsideBuildArea"):
is_outside_build_area = node.isOutsideBuildArea()
else:
is_outside_build_area = False
nodes.append({
"name": name,
"isSelected": Selection.isSelected(node),
"isOutsideBuildArea": is_outside_build_area,
"buildPlateNumber": node_build_plate_number,
"node": node
})
nodes = sorted(nodes, key=lambda n: n["name"])
self.setItems(nodes)
self.itemsChanged.emit()
def loadPlugin(self, plugin_id: str):
if plugin_id in self._plugins:
# Already loaded, do not load again
Logger.log("w", "Plugin %s was already loaded", plugin_id)
return
if not self._disabled_plugins:
self._disabled_plugins = Preferences.getInstance().getValue("general/disabled_plugins").split(",")
if plugin_id in self._disabled_plugins:
Logger.log("d", "Plugin %s was disabled", plugin_id)
return
plugin = self._findPlugin(plugin_id)
if not plugin:
raise PluginNotFoundError(plugin_id)
if plugin_id not in self._meta_data:
try:
self._populateMetaData(plugin_id)
except InvalidMetaDataError:
return
if self._meta_data[plugin_id].get("plugin", {}).get("api", 0) != self.APIVersion:
Logger.log("i", "Plugin %s uses an incompatible API version, ignoring", plugin_id)
return
try:
to_register = plugin.register(self._application)
if not to_register:
Logger.log("e", "Plugin %s did not return any objects to register", plugin_id)
return
for plugin_type, plugin_object in to_register.items():
if type(plugin_object) == list:
for nested_plugin_object in plugin_object:
self._addPluginObject(nested_plugin_object, plugin_id, plugin_type)
else:
self._addPluginObject(plugin_object, plugin_id, plugin_type)
self._plugins[plugin_id] = plugin
self.addActivePlugin(plugin_id)
Logger.log("i", "Loaded plugin %s", plugin_id)
except KeyError as e:
Logger.log("e", "Error loading plugin %s:", plugin_id)
Logger.log("e", "Unknown plugin type: %s", str(e))
except Exception as e:
Logger.logException("e", "Error loading plugin %s:", plugin_id)
def showConfigUI(self, blocking=False):
self._ui_lock.acquire()
preference = Preferences.getInstance().getValue(
"cura_solidworks/show_export_settings_always")
Logger.log(
"d", "Showing wizard {} needed.. (preference = {})".format(
["is", "is not"][preference], repr(preference)))
if not preference:
self._ui_lock.release()
return
self._cancelled = False
self.show_config_ui_trigger.emit()
if blocking:
Logger.log("d", "Waiting for UI to close..")
self.waitForUIToClose()
def getChangeLogString(self):
logs = self.getChangeLogs()
latest_version = Version(Preferences.getInstance().getValue(
"general/latest_version_changelog_shown"))
result = ""
for version in logs:
result += "<h1>" + str(version) + "</h1><br>"
result += ""
for change in logs[version]:
result += "<b>" + str(change) + "</b><br>"
for line in logs[version][change]:
result += str(line) + "<br>"
result += "<br>"
pass
return result
def __init__(self, parent=None):
super().__init__(parent)
self._plugins = {} # type: Dict[str, types.ModuleType]
self._plugin_objects = {} # type: Dict[str, PluginObject]
self._meta_data = {} # type: Dict[str, Dict[str, any]]
self._plugin_locations = [] # type: List[str]
self._folder_cache = {} # type: Dict[str, str]
self._application = None
self._active_plugins = [] # type: List[str]
self._supported_file_types = {"umplugin": "Uranium Plugin"}
preferences = Preferences.getInstance()
preferences.addPreference("general/disabled_plugins", "")
# The disabled_plugins is explicitly set to None. When actually loading the preferences, it's set to a list.
# This way we can see the difference between no list and an empty one.
self._disabled_plugins = None # type: Optional[List[str]]
def _prefered_app_name(self):
installation_code = Preferences.getInstance().getValue(
"cura_solidworks/preferred_installation")
if isinstance(installation_code, str):
installation_code = eval(installation_code)
if isinstance(installation_code, float):
installation_code = int(installation_code)
if installation_code is -1:
return None # We have no preference
elif installation_code is -2:
return self._default_app_name # Use system default service
elif installation_code in self.operational_versions:
return self.getVersionedServiceName(
installation_code) # Use chosen version
return None
def _updateWithPreferences(self):
self._solid_layers = int(Preferences.getInstance().getValue("view/top_layer_count"))
self._only_show_top_layers = bool(Preferences.getInstance().getValue("view/only_show_top_layers"))
self._compatibility_mode = OpenGLContext.isLegacyOpenGL() or bool(
Preferences.getInstance().getValue("view/force_layer_view_compatibility_mode"))
self.setSimulationViewType(int(float(Preferences.getInstance().getValue("layerview/layer_view_type"))));
for extruder_nr, extruder_opacity in enumerate(Preferences.getInstance().getValue("layerview/extruder_opacities").split("|")):
try:
opacity = float(extruder_opacity)
except ValueError:
opacity = 1.0
self.setExtruderOpacity(extruder_nr, opacity)
self.setShowTravelMoves(bool(Preferences.getInstance().getValue("layerview/show_travel_moves")))
self.setShowHelpers(bool(Preferences.getInstance().getValue("layerview/show_helpers")))
self.setShowSkin(bool(Preferences.getInstance().getValue("layerview/show_skin")))
self.setShowInfill(bool(Preferences.getInstance().getValue("layerview/show_infill")))
self._startUpdateTopLayers()
self.preferencesChanged.emit()
def create(cls, scene_root=None, fixed_nodes=None, scale=1.0):
global_stack = Application.getInstance().getGlobalContainerStack()
machine_width = int(global_stack.getProperty("machine_width", "value"))
machine_depth = int(global_stack.getProperty("machine_depth", "value"))
arranger = Arrange(machine_depth,
machine_width,
int(machine_width / 2),
int(machine_depth / 2),
scale=scale)
arranger.centerFirst()
if fixed_nodes is None:
fixed_nodes = []
for node_ in DepthFirstIterator(scene_root):
# Only count sliceable objects
if node_.callDecoration("isSliceable") and not isinstance(
node_, DuplicatedNode):
fixed_nodes.append(node_)
# Place all objects fixed nodes
for fixed_node in fixed_nodes:
arrange_align = Preferences.getInstance().getValue(
"mesh/arrange_align")
if arrange_align:
bb = fixed_node.getBoundingBox()
points = numpy.array(
[[bb.right, bb.back], [bb.left, bb.back],
[bb.left, bb.front], [bb.right, bb.front]],
dtype=numpy.float32)
else:
vertices = fixed_node.callDecoration("getConvexHull")
if not vertices:
continue
points = copy.deepcopy(vertices._points)
shape_arr = ShapeArray.fromPolygon(points, scale=scale)
arranger.place(0, 0, shape_arr)
# If a build volume was set, add the disallowed areas
if Arrange.build_volume:
disallowed_areas = Arrange.build_volume.getDisallowedAreas()
for area in disallowed_areas:
points = copy.deepcopy(area._points)
shape_arr = ShapeArray.fromPolygon(points, scale=scale)
arranger.place(0, 0, shape_arr, update_empty=False)
return arranger