def __export(self):
"""Export annotations to a file."""
try:
if conf.PYFORMS_DIALOGS_OPTIONS:
filename, ffilter = QFileDialog.getSaveFileName(
parent=self,
caption="Export annotations file",
directory="untitled.csv",
filter="CSV Files (*.csv);;CSV Matrix Files (*.csv)",
options=conf.PYFORMS_DIALOGS_OPTIONS)
else:
filename, ffilter = QFileDialog.getSaveFileName(
parent=self,
caption="Export annotations file",
directory="untitled.csv",
filter="CSV Files (*.csv);;CSV Matrix Files (*.csv)")
filename = str(filename)
ffilter = str(ffilter)
if filename != "":
with open(filename, 'w') as csvfile:
spamwriter = csv.writer(csvfile, dialect='excel')
if ffilter == 'CSV Files (*.csv)':
self._time.export_events_to_csvwriter(spamwriter)
elif ffilter == 'CSV Matrix Files (*.csv)':
self._time.exportmatrix_events_to_csvwriter(spamwriter)
except Exception as e:
traceback.print_exc()
m = QMessageBox(QMessageBox.Critical, 'Error', str(e))
m.exec_()
def open_report(self):
"""
Present an 'Open report' dialog to the user, load a '.report' file
(as saved by OWReport) and create a new canvas window associated
with the OWReport instance.
"""
settings = QSettings()
KEY = "report/file-dialog-dir"
start_dir = settings.value(KEY, "", type=str)
dlg = QFileDialog(
self,
windowTitle=self.tr("Open Report"),
acceptMode=QFileDialog.AcceptOpen,
fileMode=QFileDialog.ExistingFile,
)
if os.path.isdir(start_dir):
dlg.setDirectory(start_dir)
dlg.setWindowModality(Qt.ApplicationModal)
dlg.setNameFilters(["Report (*.report)"])
def accepted():
directory = dlg.directory().absolutePath()
filename = dlg.selectedFiles()[0]
settings.setValue(KEY, directory)
self._open_report(filename)
dlg.accepted.connect(accepted)
dlg.exec()
def get_save_filename(self): # pragma: no cover
if sys.platform == "darwin":
def remove_star(filt):
return filt.replace(" (*.", " (.")
else:
def remove_star(filt):
return filt
no_ext_filters = {remove_star(f): f for f in self._valid_filters()}
filename = self._initial_start_dir()
while True:
dlg = QFileDialog(
None, "Save File", filename, ";;".join(no_ext_filters))
dlg.setAcceptMode(dlg.AcceptSave)
dlg.selectNameFilter(remove_star(self._default_valid_filter()))
dlg.setOption(QFileDialog.DontConfirmOverwrite)
if dlg.exec() == QFileDialog.Rejected:
return "", ""
filename = dlg.selectedFiles()[0]
selected_filter = no_ext_filters[dlg.selectedNameFilter()]
filename = self._replace_extension(
filename, self._extension_from_filter(selected_filter))
if not os.path.exists(filename) or QMessageBox.question(
self, "Overwrite file?",
f"File {os.path.split(filename)[1]} already exists.\n"
"Overwrite?") == QMessageBox.Yes:
return filename, selected_filter
def get_object(self):
dialog = QFileDialog()
self.response = dialog.getExistingDirectory(
None, "Choose directory", expanduser("~"), QFileDialog.ShowDirsOnly
)
if self.response != "":
self.value = self.response
return self.response != ""
def click(self):
if conf.PYFORMS_DIALOGS_OPTIONS:
value = QFileDialog.getExistingDirectory(
self.parent, self._label, options=conf.PYFORMS_DIALOGS_OPTIONS)
else:
value = QFileDialog.getExistingDirectory(self.parent, self._label)
if value and len(value) > 0:
self.value = value
def save_project(self, project_path=None):
try:
if project_path is None:
dialog = QFileDialog()
dialog.setLabelText(QFileDialog.Accept, 'Save')
project_path = dialog.getExistingDirectory(
self, caption="Select the project directory to save")
if project_path is not None and str(project_path) != '':
project_path = str(project_path)
self.save({}, project_path)
except Exception as e:
traceback.print_exc()
QMessageBox.critical(self, "Error", str(e))
def click(self):
if self.use_save_dialog:
value = QFileDialog.getSaveFileName(self.parent, self._label,
self.value)
else:
value = QFileDialog.getOpenFileName(self.parent, self._label,
self.value)
if conf.PYFORMS_USE_QT5:
value = value[0]
else:
value = str(value)
if value and len(value) > 0: self.value = value
def click(self):
if self.use_save_dialog:
value = QFileDialog.getSaveFileName(self.parent, self._label,
self.value)
else:
value = QFileDialog.getOpenFileName(self.parent, self._label,
self.value)
if _api.USED_API == _api.QT_API_PYQT5:
value = value[0]
elif _api.USED_API == _api.QT_API_PYQT4:
value = str(value)
if value and len(value) > 0: self.value = value
def export_clicked(self):
filename = str(QFileDialog.getSaveFileName(self, 'Choose a file', ''))
if filename != "":
output = open(filename, 'w')
for values in self._polygons.value:
output.write((';'.join(values) + '\n'))
output.close()
def __prompt_browse_file_evt(self):
self._dest_folder.value = QFileDialog.getExistingDirectory()
if self._dest_folder.value:
self._read_btn.enabled = True
else:
self._read_btn.enabled = False
def get_msh_pth_and_set_to_ctrl(self) -> str:
"""
Gets msh path from dialog and sets it to control holding msh path
Returns
-------
str
msh path
"""
msh_pth, _ = \
QFileDialog.getOpenFileName(
self.parent, self.label, self.value)
# print('msh_pth')
# print(msh_pth)
# print(self.msh_fname_tab_key)
# print(self.msh_fname_param_key)
# print(self.param_ctrl_key)
des_msh_pth_ctrl = \
self.su2_cfg_obj.parsed_su2_cfg[self.msh_fname_tab_key]\
[self.msh_fname_param_key][self.param_ctrl_key]
# getting only the relaltive piece of the path for SU2 hangs otherwise
semi_rel_pth = msh_pth.split(os.sep)[-1]
print('### semi_rel_pth ###')
print(semi_rel_pth)
# des_msh_pth_ctrl.value = msh_pth
des_msh_pth_ctrl.value = semi_rel_pth
# des_msh_pth_ctrl.form.lineEdit.setText(msh_pth)
return msh_pth
def open_report(self):
filename, _ = QFileDialog.getOpenFileName(self, "Open Report",
self.open_dir,
"Report (*.report)")
if not filename:
return
self.report_changed = False
self.open_dir = os.path.dirname(filename)
self.saveSettings()
try:
report = self.load(filename)
except (IOError, AttributeError, pickle.UnpicklingError) as e:
message_critical(self.tr("Could not load an Orange Report file"),
title=self.tr("Error"),
informative_text=self.tr(
"Error occurred "
"while loading '{}'.").format(filename),
exc_info=True,
parent=self)
log.error(str(e), exc_info=True)
return
self.set_instance(report)
self = report
self._build_html()
self.table.selectRow(0)
self.show()
self.raise_()
def save_report(self):
"""Save report"""
filename, _ = QFileDialog.getSaveFileName(
self, "Save Report", self.save_dir,
"HTML (*.html);;PDF (*.pdf);;Report (*.report)")
if not filename:
return QDialog.Rejected
self.save_dir = os.path.dirname(filename)
self.saveSettings()
_, extension = os.path.splitext(filename)
if extension == ".pdf":
printer = QPrinter()
printer.setPageSize(QPrinter.A4)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(filename)
self.report_view.print_(printer)
elif extension == ".report":
self.save(filename)
else:
def save_html(contents):
try:
with open(filename, "w", encoding="utf-8") as f:
f.write(contents)
except PermissionError:
self.permission_error(filename)
save_html(self.report_view.html())
self.report_changed = False
return QDialog.Accepted
def init_project(self, directory=None):
if not directory:
directory = str(QFileDialog.getExistingDirectory())
self.dirProjectDir.value = directory
self.repo = Repo.init(directory)
self.rgit = self.repo.git
self.local_proj_name = directory.split(os.sep)[-1]
def export_tracking_file(self):
filename, _ = QFileDialog.getSaveFileName(self,
'Select a file',
selectedFilter='*.csv')
if not filename: return
filename = str(filename)
if not filename.lower().endswith('.csv'): filename += '.csv'
#Export only the selected bounds
lower = 0 if self._boundings.value[0] < 0 else self._boundings.value[0]
higher = len(self._data) if self._boundings.value[1] > (
len(self._data) + 1) else self._boundings.value[1]
self._progress.min = lower
self._progress.max = higher
with open(filename, 'wb') as csvfile:
spamwriter = csv.writer(csvfile, delimiter=',')
for i in range(int(lower), int(higher)):
self._progress.value = i
if self._data[i] != None:
spamwriter.writerow(self._data[i].row)
def browseNetFile(self, browse_demos=False):
"""user pressed the '...' button to manually select a file to load"""
if browse_demos:
from pkg_resources import load_entry_point
startfile = next(load_entry_point("Orange3-Network",
"orange.data.io.search_paths",
"network")())[1]
else:
startfile = self.recentFiles[0] if self.recentFiles else '.'
filename, _ = QFileDialog.getOpenFileName(
self, 'Open a Network File', startfile,
';;'.join(("All network files (*{})".format(
' *'.join(network.readwrite.SUPPORTED_READ_EXTENSIONS)),
"NetworkX graph as Python pickle (*.gpickle)",
"NetworkX edge list (*.edgelist)",
"Pajek files (*.net *.pajek)",
"GML files (*.gml)",
"All files (*)")))
if not filename:
return
try: self.recentFiles.remove(filename)
except ValueError: pass
self.recentFiles.insert(0, filename)
self.populate_comboboxes()
self.net_index = 0
self.selectNetFile()
def save_network(self):
# TODO: this was never reviewed since Orange2
if self.view is None or self.graph is None:
return
filename = QFileDialog.getSaveFileName(
self, 'Save Network', '',
'NetworkX graph as Python pickle (*.gpickle)\n'
'NetworkX edge list (*.edgelist)\n'
'Pajek network (*.net *.pajek)\n'
'GML network (*.gml)')
if filename:
_, ext = os.path.splitext(filename)
if not ext: filename += ".net"
items = self.graph.items()
for i in range(self.graph.number_of_nodes()):
graph_node = self.graph.node[i]
plot_node = self.networkCanvas.networkCurve.nodes()[i]
if items is not None:
ex = items[i]
if 'x' in ex.domain: ex['x'] = plot_node.x()
if 'y' in ex.domain: ex['y'] = plot_node.y()
graph_node['x'] = plot_node.x()
graph_node['y'] = plot_node.y()
network.readwrite.write(self.graph, filename)
def main(argv=sys.argv):
if len(argv) == 1:
filename = None
else:
if argv[1] in ["-h", "--help"]:
usage(argv)
return 0
else:
filename = argv[1]
app = QApplication(argv)
app.setAttribute(Qt.AA_EnableHighDpiScaling)
app.setAttribute(Qt.AA_UseHighDpiPixmaps)
if filename is None:
filename, _ = QFileDialog.getOpenFileName(
None, "Image file", os.path.expanduser("~/Documents"),
"Image (*.png)")
if not filename:
return 1
print(filename)
form = MainForm(filename=filename)
rect = QApplication.desktop().availableGeometry()
form.show()
form.raise_()
return app.exec_()
def browse_files(self, in_demos=False):
if in_demos:
start_file = get_sample_datasets_dir()
if not os.path.exists(start_file):
QMessageBox.information(
None, "File",
"Cannot find the directory with documentation data sets")
return
else:
start_file = self.last_path() or os.path.expanduser("~/")
filenames = QFileDialog.getOpenFileNames(self,
'Open Multiple Data Files',
start_file, self.dlg_formats)
if isinstance(filenames, tuple): # has a file description
filenames = filenames[0]
if not filenames:
return
for f in filenames:
self.add_path(f)
self.lb.addItem(f)
self._update_sheet_combo()
self.load_data()
def import_task(self, filepath=None, with_directory=False):
"""
Import task file to project
Qt5 change:
https://www.reddit.com/r/learnpython/comments/2xhagb/pyqt5_trouble_with_openinggetting_the_name_of_the/
:param filepath:
:return:
"""
if self.path is None or len(self.path) == 0 or not self.is_saved():
self.warning(
'To import a protocol you need to save the project first.',
'Project not saved yet')
else:
if not filepath:
filepath, _ = QFileDialog.getOpenFileName(self, 'OpenFile')
if filepath:
try:
return super(ProjectTreeNode,
self).import_task(filepath, with_directory)
except Exception as e:
self.warning(str(e), 'Import aborted')
return None
def saveScript(self):
index = self.selectedScriptIndex()
if index is not None:
script = self.libraryList[index]
filename = script.filename
else:
filename = os.path.expanduser("~/")
filename, _ = QFileDialog.getSaveFileName(
self, 'Save Python Script',
filename,
'Python files (*.py)\nAll files(*.*)'
)
if filename:
fn = ""
head, tail = os.path.splitext(filename)
if not tail:
fn = head + ".py"
else:
fn = filename
f = open(fn, 'w')
f.write(self.text.toPlainText())
f.close()
def save_report(self):
"""Save report"""
filename, _ = QFileDialog.getSaveFileName(
self, "Save Report", self.save_dir,
"HTML (*.html);;PDF (*.pdf);;Report (*.report)")
if not filename:
return QDialog.Rejected
self.save_dir = os.path.dirname(filename)
self.saveSettings()
_, extension = os.path.splitext(filename)
if extension == ".pdf":
printer = QPrinter()
printer.setPageSize(QPrinter.A4)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(filename)
self.report_view.print_(printer)
elif extension == ".report":
self.save(filename)
else:
def save_html(contents):
try:
with open(filename, "w", encoding="utf-8") as f:
f.write(contents)
except PermissionError:
self.permission_error(filename)
save_html(self.report_view.html())
self.report_changed = False
return QDialog.Accepted
def save_as(self):
folder = QFileDialog.getExistingDirectory(
self,
"Select a directory to save the project: {0}".format(self.name))
if folder:
folder = os.path.join(folder, self.name)
self.save(str(folder))
def open_report(self):
filename, _ = QFileDialog.getOpenFileName(
self, "Open Report", self.open_dir, "Report (*.report)")
if not filename:
return
self.report_changed = False
self.open_dir = os.path.dirname(filename)
self.saveSettings()
try:
report = self.load(filename)
except (IOError, AttributeError, pickle.UnpicklingError) as e:
message_critical(
self.tr("Could not load an Orange Report file"),
title=self.tr("Error"),
informative_text=self.tr("Error occurred "
"while loading '{}'.").format(filename),
exc_info=True,
parent=self)
log.error(str(e), exc_info=True)
return
self.set_instance(report)
self = report
self._build_html()
self.table.selectRow(0)
self.show()
self.raise_()
def save_image_as(self):
img = self.get_selection().toImage()
if img.isNull():
QMessageBox.critical(self, self.tr('Error'), self.tr('No image was selected!'))
return
self.hide()
formats = {
self.tr('Portable Network Graphics (*.png)'): 'png',
self.tr('Joint Photographic Experts Group (*.jpg *.jpeg)'): 'jpg',
self.tr('Graphics Interchange Format (*.gif)'): 'gif',
self.tr('Bitmap (*.bmp)'): 'bmp',
self.tr('All Images (*.png *.jpg *.gif *.bmp)'): 'all'
}
file_format = None
destination = QFileDialog.getSaveFileName(self, 'Save image', '', ';;'.join(formats.keys()))
if isinstance(destination, tuple):
destination, file_format = destination
file_format = formats[file_format]
if file_format == 'all':
file_format = None
if not file_format:
file_format = destination.rsplit('.', 1)[-1]
if destination:
if file_format not in formats.values():
file_format = 'png'
if not destination.endswith('.' + file_format):
destination += '.' + file_format
img.save(destination, file_format, 0 if file_format == 'png' else 90)
self.reject()
def load_project(self, project_path=None):
if project_path is None:
project_path = QFileDialog.getExistingDirectory(
self, caption="Select the project directory to open")
if project_path is not None and str(project_path) != '':
self.load({}, str(project_path))
def browse_file(self):
start_file = self.last_path() or stdpaths.Documents
filename, _ = QFileDialog.getOpenFileName(self, 'Open Distance File',
start_file, self.FILTER)
if not filename:
return
self.add_path(filename)
self.open_file()
def __load(self):
filename, _ = QFileDialog.getOpenFileNames(self, 'Select file')
print(filename)
if filename:
self._coin_list.clear()
self._save_RPC.clear()
self.load_form_filename(str(filename[0]))
self._coin_list.resize_rows_contents()
def click(self):
if self.use_save_dialog:
value, _ = QFileDialog.getSaveFileName(self.parent, self._label,
self.value)
else:
value = QFileDialog.getOpenFileName(
self.parent,
self._label,
self.value,
options=conf.PYFORMS_DIALOGS_OPTIONS)
if _api.USED_API == _api.QT_API_PYQT5:
value = value[0]
elif _api.USED_API == _api.QT_API_PYQT4:
value = str(value)
if value and len(value) > 0: self.value = value
def create_project_remote_repo(self):
out = QFileDialog.getSaveFileName(self, \
'Choose a bare git repository', \
self.local_proj_name+'.git', \
'Bare git repo (*.git)')
remote_loc = self.rgit.polish_url(out[0])
self.repo.clone(remote_loc, bare=True)
self.rgit.remote('add', self.remote_name, remote_loc)
def save_window(self):
allparams = self.controls
data = {}
self.save_form(data)
filename, _ = QFileDialog.getSaveFileName(self, 'Select file')
with open(filename, 'w') as output_file:
json.dump(data, output_file)
def save(self):
fname, _ = QFileDialog.getSaveFileName(
self, "File name", self._start_dir(),
"Variable definitions (*.colors)")
if not fname:
return
QSettings().setValue("colorwidget/last-location",
os.path.split(fname)[0])
self._save_var_defs(fname)
def __prompt_save_file_evt(self):
"""
Opens a window for the user to select where to save the Harp sound file (.bin extension by default)
"""
self._filename.value, _ = QFileDialog.getSaveFileName()
if self._filename.value:
self._gen_btn.enabled = True
else:
self._gen_btn.enabled = False
def browse(self):
start_file = self.last_path() or os.path.expanduser("~/")
formats = ["Text files (*.txt)", "All files (*)"]
file_name, _ = QFileDialog.getOpenFileName(
None, "Open...", start_file, ";;".join(formats), formats[0])
if not file_name:
return
self.add_path(file_name)
self._activate()
def save_project(self, project_path=None):
try:
if project_path is None:
project_path = QFileDialog.getExistingDirectory(self, "Select the project directory")
if project_path is not None and str(project_path)!='':
project_path = str(project_path)
self.save({}, project_path)
except Exception as e:
QMessageBox.critical(self, "Error", str(e))
def save_file_as(self):
file_name = self.filename or self.last_dir or os.path.expanduser("~")
filename, _ = QFileDialog.getSaveFileName(
self, "Select file", file_name, 'Distance files (*.dst)')
if not filename:
return
self.filename = filename
self.unconditional_save_file()
self.last_dir = os.path.split(self.filename)[0]
self.adjust_label()
def onAddScriptFromFile(self, *args):
filename, _ = QFileDialog.getOpenFileName(
self, 'Open Python Script',
os.path.expanduser("~/"),
'Python files (*.py)\nAll files(*.*)'
)
if filename:
name = os.path.basename(filename)
contents = open(filename, "rb").read().decode("utf-8", errors="ignore")
self.libraryList.append(Script(name, contents, 0, filename))
self.setSelectedScript(len(self.libraryList) - 1)
def browse(self):
"""Select a filename using an open file dialog."""
if self.filename is None:
startdir = stdpaths.Documents
else:
startdir = os.path.dirname(self.filename)
filename, _ = QFileDialog.getOpenFileName(
self, self.tr("Open"), directory=startdir, filter=self.FILTER)
if filename:
self.load(filename)
def browse_file(self):
"""
Open the file dialog and open the chosen file.
"""
start_path = self.last_path() or os.path.expanduser("~")
filename, _ = QFileDialog.getOpenFileName(
None, "Open File", start_path, 'All Files (*.*)')
if not filename:
return
self.closeContext()
self.add_path(filename)
self.openContext(filename)
self.open_file()
def onAddScriptFromFile(self, *args):
filename, _ = QFileDialog.getOpenFileName(
self, 'Open Python Script',
os.path.expanduser("~/"),
'Python files (*.py)\nAll files(*.*)'
)
if filename:
name = os.path.basename(filename)
# TODO: use `tokenize.detect_encoding`
with open(filename, encoding="utf-8") as f:
contents = f.read()
self.libraryList.append(Script(name, contents, 0, filename))
self.setSelectedScript(len(self.libraryList) - 1)
def get_file_name(start_dir, start_filter, file_formats):
"""
Get filename for the given possible file formats
The function uses the standard save file dialog with filters from the
given file formats. Extension is added automatically, if missing. If the
user enters file extension that does not match the file format, (s)he is
given a dialog to decide whether to fix the extension or the format.
Function also returns the writer and filter to cover the case where the
same extension appears in multiple filters. Although `file_format` is a
dictionary that associates its extension with one writer, writers can
still have other extensions that are allowed.
Args:
start_dir (str): initial directory, optionally including the filename
start_filter (str): initial filter
file_formats (dict {extension: Orange.data.io.FileFormat}): file formats
Returns:
(filename, writer, filter), or `(None, None, None)` on cancel
"""
writers = sorted(set(file_formats.values()), key=lambda w: w.PRIORITY)
filters = [format_filter(w) for w in writers]
if start_filter not in filters:
start_filter = filters[0]
while True:
filename, filter = QFileDialog.getSaveFileName(
None, 'Save As...', start_dir, ';;'.join(filters), start_filter)
if not filename:
return None, None, None
writer = writers[filters.index(filter)]
base, ext = os.path.splitext(filename)
if not ext:
filename += writer.EXTENSIONS[0]
elif ext not in writer.EXTENSIONS:
format = writer.DESCRIPTION
suggested_ext = writer.EXTENSIONS[0]
suggested_format = \
ext in file_formats and file_formats[ext].DESCRIPTION
res = fix_extension(ext, format, suggested_ext, suggested_format)
if res == fix_extension.CANCEL:
continue
if res == fix_extension.CHANGE_EXT:
filename = base + suggested_ext
elif res == fix_extension.CHANGE_FORMAT:
writer = file_formats[ext]
filter = format_filter(writer)
return filename, writer, filter
def browse(self):
"""Select a filename using a Save file dialog."""
if self.filename is None:
startdir = stdpaths.Documents
else:
startdir = os.path.dirname(self.filename)
filename, _ = QFileDialog.getSaveFileName(self, self.tr("Save"), directory=startdir, filter=self.FILTER)
if filename:
if not filename.endswith(self.FILE_EXT):
filename += self.FILE_EXT
if self.model is not None:
self.save(filename)
else:
self._remember(filename)
def browse_file(self, in_demos=False):
if in_demos:
start_file = get_sample_datasets_dir()
if not os.path.exists(start_file):
QMessageBox.information(
None, "File",
"Cannot find the directory with documentation data sets")
return
else:
start_file = self.last_path() or os.path.expanduser("~/")
filename, _ = QFileDialog.getOpenFileName(
self, 'Open Distance File', start_file, "(*.dst)")
if not filename:
return
self.add_path(filename)
self.open_file()
def browse_file(self, in_demos=False):
if in_demos:
start_file = get_sample_datasets_dir()
if not os.path.exists(start_file):
QMessageBox.information(
None, "File",
"Cannot find the directory with documentation data sets")
return
else:
start_file = self.last_path() or os.path.expanduser("~/")
filename, _ = QFileDialog.getOpenFileName(
self, 'Open Orange Data File', start_file, dialog_formats())
if not filename:
return
self.add_path(filename)
self.source = self.LOCAL_FILE
self.load_data()
def save_report(self):
"""Save report"""
formats = OrderedDict((('HTML (*.html)', '.html'),
('PDF (*.pdf)', '.pdf'),
('Report (*.report)', '.report')))
filename, selected_format = QFileDialog.getSaveFileName(
self, "Save Report", self.save_dir, ';;'.join(formats.keys()))
if not filename:
return QDialog.Rejected
# Set appropriate extension if not set by the user
expect_ext = formats[selected_format]
if not filename.endswith(expect_ext):
filename += expect_ext
self.save_dir = os.path.dirname(filename)
self.saveSettings()
_, extension = os.path.splitext(filename)
if extension == ".pdf":
printer = QPrinter()
printer.setPageSize(QPrinter.A4)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(filename)
self._print_to_printer(printer)
elif extension == ".report":
self.save(filename)
else:
def save_html(contents):
try:
with open(filename, "w", encoding="utf-8") as f:
f.write(contents)
except PermissionError:
self.permission_error(filename)
save_html(self.report_view.html())
self.report_changed = False
return QDialog.Accepted
def __runOpenDialog(self):
startdir = os.path.expanduser("~/")
if self.recent_paths:
startdir = os.path.dirname(self.recent_paths[0].abspath)
if OWImportImages.Modality == Qt.WindowModal:
dlg = QFileDialog(
self, "Select Top Level Directory", startdir,
acceptMode=QFileDialog.AcceptOpen,
modal=True,
)
dlg.setFileMode(QFileDialog.Directory)
dlg.setOption(QFileDialog.ShowDirsOnly)
dlg.setDirectory(startdir)
dlg.setAttribute(Qt.WA_DeleteOnClose)
@dlg.accepted.connect
def on_accepted():
dirpath = dlg.selectedFiles()
if dirpath:
self.setCurrentPath(dirpath[0])
self.start()
dlg.open()
else:
dirpath = QFileDialog.getExistingDirectory(
self, "Select Top Level Directory", startdir
)
if dirpath:
self.setCurrentPath(dirpath)
self.start()
def load_project(self, project_path=None):
if project_path is None:
project_path = QFileDialog.getExistingDirectory(self, "Select the project directory")
if project_path is not None and str(project_path)!='':
self.load({}, str(project_path) )
