def requestWrite(self,
nodes,
file_name=None,
limit_mimetypes=None,
file_handler=None):
if self._writing:
raise OutputDeviceError.DeviceBusyError()
dialog = QFileDialog()
dialog.setWindowTitle(catalog.i18nc("@title:window", "Save to File"))
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setAcceptMode(QFileDialog.AcceptSave)
# Ensure platform never ask for overwrite confirmation since we do this ourselves
dialog.setOption(QFileDialog.DontConfirmOverwrite)
if sys.platform == "linux" and "KDE_FULL_SESSION" in os.environ:
dialog.setOption(QFileDialog.DontUseNativeDialog)
filters = []
mime_types = []
selected_filter = None
last_used_type = Preferences.getInstance().getValue(
"local_file/last_used_type")
if not file_handler:
file_handler = Application.getInstance().getMeshFileHandler()
file_types = file_handler.getSupportedFileTypesWrite()
file_types.sort(key=lambda k: k["description"])
if limit_mimetypes:
file_types = list(
filter(lambda i: i["mime_type"] in limit_mimetypes,
file_types))
if len(file_types) == 0:
Logger.log("e", "There are no file types available to write with!")
raise OutputDeviceError.WriteRequestFailedError()
for item in file_types:
type_filter = "{0} (*.{1})".format(item["description"],
item["extension"])
filters.append(type_filter)
mime_types.append(item["mime_type"])
if last_used_type == item["mime_type"]:
selected_filter = type_filter
if file_name:
file_name += "." + item["extension"]
dialog.setNameFilters(filters)
if selected_filter is not None:
dialog.selectNameFilter(selected_filter)
if file_name is not None:
dialog.selectFile(file_name)
stored_directory = Preferences.getInstance().getValue(
"local_file/dialog_save_path")
dialog.setDirectory(stored_directory)
if not dialog.exec_():
raise OutputDeviceError.UserCanceledError()
save_path = dialog.directory().absolutePath()
Preferences.getInstance().setValue("local_file/dialog_save_path",
save_path)
selected_type = file_types[filters.index(dialog.selectedNameFilter())]
Preferences.getInstance().setValue("local_file/last_used_type",
selected_type["mime_type"])
file_name = dialog.selectedFiles()[0]
if os.path.exists(file_name):
result = QMessageBox.question(
None, catalog.i18nc("@title:window", "File Already Exists"),
catalog.i18nc(
"@label",
"The file <filename>{0}</filename> already exists. Are you sure you want to overwrite it?"
).format(file_name))
if result == QMessageBox.No:
raise OutputDeviceError.UserCanceledError()
self.writeStarted.emit(self)
if file_handler:
file_writer = file_handler.getWriter(selected_type["id"])
else:
file_writer = Application.getInstance().getMeshFileHandler(
).getWriter(selected_type["id"])
try:
mode = selected_type["mode"]
if mode == MeshWriter.OutputMode.TextMode:
Logger.log("d", "Writing to Local File %s in text mode",
file_name)
stream = open(file_name, "wt", encoding="utf-8")
elif mode == MeshWriter.OutputMode.BinaryMode:
Logger.log("d", "Writing to Local File %s in binary mode",
file_name)
stream = open(file_name, "wb")
job = WriteFileJob(file_writer, stream, nodes, mode)
job.setFileName(file_name)
job.progress.connect(self._onJobProgress)
job.finished.connect(self._onWriteJobFinished)
message = Message(
catalog.i18nc(
"@info:progress",
"Saving to <filename>{0}</filename>").format(file_name), 0,
False, -1)
message.show()
job._message = message
self._writing = True
job.start()
except PermissionError as e:
Logger.log("e", "Permission denied when trying to write to %s: %s",
file_name, str(e))
raise OutputDeviceError.PermissionDeniedError(
catalog.i18nc(
"@info:status",
"Permission denied when trying to save <filename>{0}</filename>"
).format(file_name)) from e
except OSError as e:
Logger.log("e",
"Operating system would not let us write to %s: %s",
file_name, str(e))
raise OutputDeviceError.WriteRequestFailedError(
catalog.i18nc(
"@info:status",
"Could not save to <filename>{0}</filename>: <message>{1}</message>"
).format()) from e
def requestWrite(self, nodes, file_name = None, filter_by_machine = False, file_handler = None):
filter_by_machine = True # This plugin is indended to be used by machine (regardless of what it was told to do)
if self._writing:
raise OutputDeviceError.DeviceBusyError()
# Formats supported by this application (File types that we can actually write)
if file_handler:
file_formats = file_handler.getSupportedFileTypesWrite()
else:
file_formats = Application.getInstance().getMeshFileHandler().getSupportedFileTypesWrite()
if filter_by_machine:
container = Application.getInstance().getGlobalContainerStack().findContainer({"file_formats": "*"})
# Create a list from supported file formats string
machine_file_formats = [file_type.strip() for file_type in container.getMetaDataEntry("file_formats").split(";")]
# Take the intersection between file_formats and machine_file_formats.
file_formats = list(filter(lambda file_format: file_format["mime_type"] in machine_file_formats, file_formats))
if len(file_formats) == 0:
Logger.log("e", "There are no file formats available to write with!")
raise OutputDeviceError.WriteRequestFailedError()
# Just take the first file format available.
if file_handler is not None:
writer = file_handler.getWriterByMimeType(file_formats[0]["mime_type"])
else:
writer = Application.getInstance().getMeshFileHandler().getWriterByMimeType(file_formats[0]["mime_type"])
extension = file_formats[0]["extension"]
if file_name is None:
file_name = self._automaticFileName(nodes)
if extension: # Not empty string.
extension = "." + extension
file_name = os.path.join(self.getId(), os.path.splitext(file_name)[0] + extension)
try:
Logger.log("d", "Writing to %s", file_name)
# Using buffering greatly reduces the write time for many lines of gcode
self._stream = open(file_name, "wt", buffering = 1, encoding = "utf-8")
job = WriteFileJob(writer, self._stream, nodes, MeshWriter.OutputMode.TextMode)
job.setFileName(file_name)
job.progress.connect(self._onProgress)
job.finished.connect(self._onFinished)
message = Message(catalog.i18nc("@info:progress", "Saving to Removable Drive <filename>{0}</filename>").format(self.getName()), 0, False, -1)
message.show()
self.writeStarted.emit(self)
job._message = message
self._writing = True
job.start()
except PermissionError as e:
Logger.log("e", "Permission denied when trying to write to %s: %s", file_name, str(e))
raise OutputDeviceError.PermissionDeniedError(catalog.i18nc("@info:status", "Could not save to <filename>{0}</filename>: <message>{1}</message>").format(file_name, str(e))) from e
except OSError as e:
Logger.log("e", "Operating system would not let us write to %s: %s", file_name, str(e))
raise OutputDeviceError.WriteRequestFailedError(catalog.i18nc("@info:status", "Could not save to <filename>{0}</filename>: <message>{1}</message>").format(file_name, str(e))) from e
