def _fileChooser():
fdia = QFileDialog()
fdia.setNameFilter("air apps(*.air)")
if (fdia.exec_()):
fchoosed = fdia.selectedFiles()[0]
self.inp_file.setText(fchoosed)
self.updateScreen()
def import_sql(self):
dialog = QFileDialog()
options = dialog.Options()
options |= dialog.DontUseNativeDialog
dialog.setNameFilter("*.sql")
file_name, _ = dialog.getOpenFileName(self,
"QFileDialog.getOpenFileName()",
"",
"SQL Files (*.sql)",
options=options)
if file_name:
f = open(file_name, 'r')
sql = f.read()
f.close()
sql_commands = sql.split(';')
for command in sql_commands:
command.replace("\n", "")
command.strip()
if command != '' and command[0] != '#' and '/*' not in command:
result = self.main_view.connection_helper.custom_query(
command)
if isinstance(result, str):
# query failed, stop import
QMessageBox.about(self, 'Oops!', result)
return False
def load_obs(self):
load = QFileDialog()
load.setDefaultSuffix(".json")
load.setNameFilter("JSON files (*.json)")
load.setAcceptMode(QFileDialog.AcceptOpen)
load.setOption(QFileDialog.DontUseNativeDialog)
if load.exec_() == QFileDialog.Accepted:
filename = load.selectedFiles()[0]
with open(filename) as json_file:
obs_dict = json.load(json_file)
self.observationList.clear()
for key in obs_dict:
if key in self.targetsDict:
targetName = key
ra = self.targetsDict[targetName]["ra"]
dec = self.targetsDict[targetName]["dec"]
coord = SkyCoord(frame='icrs', ra=ra, dec=dec, obstime="J2000")
target = FixedTarget(coord=coord, name=targetName)
for date in obs_dict[key]['times']:
print(date)
# TODO Te pielikt date parbaudes, vai atkekset ja ir vai iznemt ja nav
data = PlannedObs(target, int(obs_dict[key]['priority']), int(obs_dict[key]['obs_per_week']),
int(obs_dict[key]['scans_per_obs']), obs_dict[key]['times'],
obs_dict[key]['global_time'])
item = QListWidgetItem(str(data), self.observationList)
item.setData(Qt.UserRole, data)
self.observationList.addItem(item)
self.plannedTargets.append(target.name)
else:
self.show_error("Target error", key + " not in targets, skipping it")
else:
print("Something went wrong")
def save_file(self):
try:
save_window = QFileDialog()
save_window.setDefaultSuffix('.png')
save_window.setWindowTitle("Save Image")
filters = "Image files (*.bmp *.dib *.jpeg *.jpg *.jpe *.jp2 *.png *.pgm *.ppm *.sr *.ras *tiff *.tif)"
save_window.setNameFilter(filters)
save_window.setAcceptMode(QFileDialog.AcceptSave)
save_window.exec()
# No file selected
if len(save_window.selectedFiles()) == 0:
return 0
file = save_window.selectedFiles()[0]
extension = file.split('.')[-1]
if extension == 'pgm':
cv2.imwrite(
file,
cv2.cvtColor(self.image_box.filtered_image,
cv2.COLOR_RGB2GRAY))
elif extension == 'png':
cv2.imwrite(file, self.image_box.filtered_image,
[cv2.IMWRITE_PNG_COMPRESSION, 9])
else:
cv2.imwrite(file, self.image_box.filtered_image)
except:
error_message = QMessageBox()
error_message.setWindowTitle("Error")
error_message.setText("Error: file " + file + " failed to save")
error_message.exec()
def open_as_filter(parent, my_filter, path="", multi_files=False):
selected_filter = ""
if path == "":
open_path = os.getcwd()
else:
open_path = path
dialog = QFileDialog(parent, _("Open file"))
dialog.setDirectory(open_path)
dialog.setNameFilter(my_filter)
dialog.setAcceptMode(QFileDialog.AcceptOpen)
if multi_files == True:
dialog.setFileMode(QFileDialog.ExistingFiles)
if dialog.exec_() == QDialog.Accepted:
ret_list = []
s = dialog.selectedNameFilter()
if s.count("(*") == 1:
s = s.split("(*")[1]
s = s[:-1]
filenames = dialog.selectedFiles()
for f in filenames:
if f.endswith(s) == False:
ret_list.append(f + s)
else:
ret_list.append(f)
if multi_files == True:
return ret_list
else:
return ret_list[0]
else:
return None
def get_save_file_name(initial_name: str, wav_only=False, caption="Save signal"):
global RECENT_PATH
if caption == "Save signal":
filter = "Complex files (*.complex);;Complex16 files (2 unsigned int8) (*.complex16u);;Complex16 files (2 signed int8) (*.complex16s);;Compressed complex files (*.coco);;wav files (*.wav);;all files (*)"
if wav_only:
filter = "wav files (*.wav);;all files (*)"
elif caption == "Save fuzz profile":
filter = "Fuzzfiles (*.fuzz);;All files (*)"
elif caption == "Save encoding":
filter = ""
else:
filter = "Protocols (*.proto);;All files (*)"
filename = None
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setNameFilter(filter)
dialog.setViewMode(QFileDialog.Detail)
dialog.setDirectory(RECENT_PATH)
dialog.setLabelText(QFileDialog.Accept, "Save")
dialog.setWindowTitle(caption)
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.selectFile(initial_name)
if dialog.exec():
filename = dialog.selectedFiles()[0]
if filename:
RECENT_PATH = os.path.split(filename)[0]
return filename
def get_save_file_name(initial_name: str,
wav_only=False,
parent=None,
caption="Save signal"):
global RECENT_PATH
if caption == "Save signal":
filter = "Complex files (*.complex);;Compressed complex files (*.coco);;wav files (*.wav);;all files (*)"
if wav_only:
filter = "wav files (*.wav);;all files (*)"
else:
filter = "Textfiles (*.txt);;All files (*)"
filename = None
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setNameFilter(filter)
dialog.setViewMode(QFileDialog.Detail)
dialog.setDirectory(RECENT_PATH)
dialog.setLabelText(QFileDialog.Accept, "Save")
dialog.setWindowTitle(caption)
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.selectFile(initial_name)
if (dialog.exec()):
filename = dialog.selectedFiles()[0]
filter = dialog.selectedNameFilter()
ext = filter[filter.index('*'):filter.index(')')][1:]
if not os.path.exists(
filename) and len(ext) > 0 and not filename.endswith(ext):
filename += ext
if filename:
RECENT_PATH = os.path.split(filename)[0]
return filename
def on_saveButton_clicked(self):
if PATH.IS_SCREEN:
DIR = PATH.SCREENDIR
else:
DIR = PATH.PANELDIR
dialog = QFileDialog(self)
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
dialog.setOptions(options)
dialog.setDirectory(DIR)
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setNameFilter("style files (*.qss *.style);;All files (*.*)")
dialog.setWindowTitle('Save StyleSheet')
dialog.setLabelText(QFileDialog.Accept, "Save")
# sidebar links
urls = []
urls.append(QUrl.fromLocalFile(os.path.expanduser('~')))
urls.append(QUrl.fromLocalFile(DIR))
urls.append(
QUrl.fromLocalFile(
os.path.join(os.getcwd(), 'qtvcp/screens', PATH.BASENAME)))
dialog.setSidebarUrls(urls)
result = dialog.exec_()
if result:
fileName = dialog.selectedFiles()[0]
self.saveStyleSheet(fileName)
def onOpenFile(self):
qset = QSettings("BKR-LAB", "CueMol")
qfdlg = QFileDialog(self)
qset.beginGroup("fileopendlg")
qfdlg.restoreState(qset.value("savestate", qfdlg.saveState()))
qset.endGroup()
qfdlg.setNameFilter(self.tr("CueMol Scene (*.qsc)"))
res = qfdlg.exec_()
qset.beginGroup("fileopendlg")
qset.setValue("savestate", qfdlg.saveState())
qset.endGroup()
if not res:
return
fname = qfdlg.selectedFiles()
#fname = QFileDialog.getOpenFileName(self, 'Open file')
print("get OFN: " + str(fname[0]))
#self.loadPDBFile(fname[0])
self.loadQSCFile(fname[0])
def file_open_pressed(self):
unsaved_decision = None
if self.changes_made:
unsaved_decision = self.ask_if_to_save()
if unsaved_decision == QMessageBox.Save:
self.file_save_pressed()
if not self.changes_made or unsaved_decision == QMessageBox.Discard:
open_dialog = QFileDialog()
open_dialog.setWindowTitle("Open…")
open_dialog.setFileMode(QFileDialog.ExistingFile)
open_dialog.setNameFilter('Text files (*.txt)')
open_dialog.setViewMode(QFileDialog.List)
open_dialog.setDirectory(self.last_path)
open_dialog.setProxyModel(None)
if open_dialog.exec_():
filepaths = open_dialog.selectedFiles()
self.opened_filepath = filepaths[0]
with open(filepaths[0], mode='r',
encoding='utf-8') as opened_file:
opened_text = opened_file.read()
self.ui.textField.setPlainText(opened_text)
base_filename = ntpath.basename(filepaths[0])
self.setWindowTitle(base_filename + ' — Notepad')
self.reset_changes_made()
def get_save_file_name(initial_name: str, wav_only=False, caption="Save signal"):
global RECENT_PATH
if caption == "Save signal":
name_filter = "Complex files (*.complex);;Complex16 files (2 unsigned int8) " \
"(*.complex16u);;Complex16 files (2 signed int8) (*.complex16s);;" \
"Compressed complex files (*.coco);;wav files (*.wav);;all files (*)"
if wav_only:
name_filter = "wav files (*.wav);;all files (*)"
elif caption == "Save fuzz profile":
name_filter = "Fuzzfiles (*.fuzz);;All files (*)"
elif caption == "Save encoding":
name_filter = ""
else:
name_filter = "Protocols (*.proto);;All files (*)"
filename = None
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setNameFilter(name_filter)
dialog.setViewMode(QFileDialog.Detail)
dialog.setDirectory(RECENT_PATH)
dialog.setLabelText(QFileDialog.Accept, "Save")
dialog.setWindowTitle(caption)
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.selectFile(initial_name)
if dialog.exec():
filename = dialog.selectedFiles()[0]
if filename:
RECENT_PATH = os.path.split(filename)[0]
return filename
def seek(self):
fileName = ""
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setNameFilter("Images (*.png *.gif *.jpg)All (*)")
dialog.setWindowTitle("Load Image")
dialog.setOption(QFileDialog.DontUseNativeDialog, True)
dialog.setAcceptMode(QFileDialog.AcceptOpen)
if dialog.exec():
fileName = dialog.selectedFiles()[0]
if not fileName:
return
# copy file to assets dir
info = QFileInfo(fileName)
name = info.fileName().replace(" ", "_")
path = os.path.join(self.site.source_path, "assets", "images", name)
self.source.setText(path)
try:
shutil.copy2(fileName, path)
except shutil.SameFileError:
pass # just ignore
# also copy file to deploy dir for previews
dpath = os.path.join(self.site.source_path, self.site.output, "docs",
"assets", "images", name)
shutil.copy2(fileName, dpath)
self.image.setImage(QImage(path))
self.contentChanged()
def saveAsFile(self):
widget = self.tab_widget.currentWidget()
assert isinstance(widget, NodeEditorSpace)
dialogue = QFileDialog(self, caption="Save Hivemap")
dialogue.setDefaultSuffix(self._hivemapExtension)
dialogue.setNameFilter(dialogue.tr("Hivemaps (*.{})".format(self._hivemapExtension)))
dialogue.setFileMode(QFileDialog.AnyFile)
dialogue.setAcceptMode(QFileDialog.AcceptSave)
if not dialogue.exec_():
return
file_path = dialogue.selectedFiles()[0]
widget.save(file_path=file_path)
widget.setFilePath(file_path)
# Update tab name
name = self._getDisplayName(file_path, allow_untitled=False)
index = self.tab_widget.currentIndex()
self.tab_widget.setTabText(index, name)
# Update save UI elements (filename may have changed) filename
self._updateMenuOptions()
# Refresh hives
if self._projectDirectory is not None:
self.updateLoadedHives()
def importFromZip(self):
logging.debug("MainApp:importFromZip() instantiated")
zip_file = QFileDialog()
zip_file.setWindowTitle("Select File")
zip_file.setFileMode(QtWidgets.QFileDialog.ExistingFile)
zip_file.setNameFilter("Zip Files (*.zip)")
filenames = zip_file.getOpenFileName()
filename = filenames[0]
if filename == "":
logging.debug("File choose cancelled")
return
else:
configname = os.path.basename(filename)
configname = os.path.splitext(configname)[0]
if configname in self.existingconfignames:
QMessageBox.warning(self,
"Name Exists",
"A project with the same name already exists.",
QMessageBox.Ok)
return None
else:
#instance of package manage
pack_mgr = PackageManager()
self.populate_import(pack_mgr, configname, os.path.abspath(filename))
def select_file(self):
dlg = QFileDialog()
dlg.setFileMode(QFileDialog.AnyFile)
dlg.setNameFilter("Config file (*.cfg)")
if dlg.exec_():
filename = dlg.selectedFiles()
filename = filename[0]
self.file_path = filename
path = filename.split('/')
lbl_width = self.statusbar_filepath.width()
for i in range(len(path) - 1, 0, -1):
filename_text = path[-1]
for j, path_elem in enumerate(path[-(i + 1):-1][::-1]):
if j != len(path) - 1:
filename_text = "/" + filename_text
filename_text = path_elem + filename_text
if i != len(path) - 1:
filename_text = ".../" + filename_text
filename_text_width = self.statusbar_filepath.fontMetrics(). \
boundingRect(filename_text).width()
if lbl_width >= filename_text_width:
self.statusbar_filepath.setText(filename_text)
break
self.mainUI.load_data_button.setEnabled(True)
def seek(self):
fileName = ""
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setNameFilter("Images (*.png *.gif *.jpg);;All (*)")
dialog.setWindowTitle(QCoreApplication.translate("SiteSettingsEditor", "Load Image"))
dialog.setOption(QFileDialog.DontUseNativeDialog, True)
dialog.setAcceptMode(QFileDialog.AcceptOpen)
if dialog.exec():
fileName = dialog.selectedFiles()[0]
del dialog
if not fileName:
return
# copy file to assets dir
name = os.path.basename(fileName).replace(" ", "_")
path = os.path.join(self.site.source_path, "assets", "images", name)
self.logo.setText(os.path.basename(path))
shutil.copy(fileName, path)
# also copy file to deploy dir for previews
dpath = os.path.join(self.site.source_path, self.site.output, "assets", "images", name)
shutil.copy(fileName, dpath)
self.image.setImage(QImage(path))
self.contentChanged("logo changed")
def addImage(self):
fileName = ""
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setNameFilter("Image Files(*.png *.jpg *.bmp *.gif);;All (*)")
dialog.setWindowTitle("Load Image")
dialog.setOption(QFileDialog.DontUseNativeDialog, True)
dialog.setAcceptMode(QFileDialog.AcceptOpen)
if dialog.exec_():
fileName = dialog.selectedFiles()[0]
del dialog
if not fileName:
return
base = os.path.basename(fileName)
if not os.path.exists(
os.path.join(self.book.source_path, "images", base)):
copy(fileName, os.path.join(self.book.source_path, "images"))
item = QListWidgetItem()
item.setText(Path(fileName).name)
item.setData(
1,
os.path.join(self.book.source_path, "images",
Path(fileName).name))
self.image_list.addItem(item)
def add_mm_file(self):
filedialog = QFileDialog()
filedialog.setFileMode(QFileDialog.AnyFile)
filedialog.setNameFilter("文本文件(*.txt)")
if filedialog.exec_():
self.filename = filedialog.selectedFiles()
self.label_2.setText(self.filename[0])
def get_open_dialog(directory_mode=False, parent=None, name_filter="full") -> QFileDialog:
fip = FileIconProvider()
dialog = QFileDialog(parent)
dialog.setIconProvider(fip)
dialog.setDirectory(RECENT_PATH)
if directory_mode:
dialog.setFileMode(QFileDialog.Directory)
dialog.setWindowTitle("Open Folder")
else:
dialog.setFileMode(QFileDialog.ExistingFiles)
dialog.setWindowTitle("Open Files")
if name_filter == "full":
name_filter = "All files (*);;Complex (*.complex);;" \
"Complex16 unsigned (*.complex16u);;" \
"Complex16 signed (*.complex16s);;" \
"Wave (*.wav);;" \
"Protocols (*.proto.xml *.proto);;" \
"Fuzzprofiles (*.fuzz.xml *.fuzz);;" \
"Plain bits (*.txt);;" \
"Tar Archives (*.tar *.tar.gz *.tar.bz2);;" \
"Zip Archives (*.zip)"
elif name_filter == "proto":
name_filter = "Protocols (*.proto.xml *.proto);;"
elif name_filter == "fuzz":
name_filter = "Fuzzprofiles (*.fuzz.xml *.fuzz);;"
dialog.setNameFilter(name_filter)
dialog.setOptions(QFileDialog.DontResolveSymlinks)
dialog.setViewMode(QFileDialog.Detail)
return dialog
def get_open_dialog(directory_mode=False,
parent=None,
name_filter="full") -> QFileDialog:
dialog = QFileDialog(parent=parent, directory=RECENT_PATH)
if directory_mode:
dialog.setFileMode(QFileDialog.Directory)
dialog.setWindowTitle("Open Folder")
else:
dialog.setFileMode(QFileDialog.ExistingFiles)
dialog.setWindowTitle("Open Files")
if name_filter == "full":
name_filter = __get__name_filter_for_signals() + ";;" \
+ ";;".join([PROTOCOL_FILE_FILTER, BINARY_PROTOCOL_FILE_FILTER, PLAIN_BITS_FILE_FILTER,
FUZZING_FILE_FILTER, SIMULATOR_FILE_FILTER, TAR_FILE_FILTER, ZIP_FILE_FILTER])
elif name_filter == "signals_only":
name_filter = __get__name_filter_for_signals()
elif name_filter == "proto":
name_filter = ";;".join(
[PROTOCOL_FILE_FILTER, BINARY_PROTOCOL_FILE_FILTER])
elif name_filter == "fuzz":
name_filter = FUZZING_FILE_FILTER
elif name_filter == "simulator":
name_filter = SIMULATOR_FILE_FILTER
dialog.setNameFilter(name_filter)
return dialog
def load_probe_data_dialog(self):
d = QFileDialog(self)
d.setNameFilter("Log data (*.txt *.log);;All files (*.*)")
d.exec_()
fname = d.selectedFiles()[0]
if fname:
self.load_probe_data(fname)
def open_as_filter(parent, my_filter, path=""):
selected_filter = ""
if path == "":
open_path = os.getcwd()
else:
open_path = path
dialog = QFileDialog(parent, _("Open file"))
dialog.setDirectory(open_path)
print(">>>>>", open_path)
dialog.setNameFilter(my_filter)
dialog.setAcceptMode(QFileDialog.AcceptOpen)
if dialog.exec_() == QDialog.Accepted:
filename = dialog.selectedFiles()[0]
s = dialog.selectedNameFilter()
if s.count("(*") == 1:
s = s.split("(*")[1]
s = s[:-1]
if filename.endswith(s) == False:
filename = filename + s
else:
filename = filename
return filename
else:
return None
def make_file_dialog(name_filters, file_mode, directory, parent, native):
dialog = QFileDialog(parent)
dialog.setOption(QFileDialog.DontUseNativeDialog, not native)
dialog.setDirectory(directory)
dialog.setFileMode(file_mode)
dialog.setNameFilter(dialog.tr(name_filters))
return dialog
def export_csv(self):
"""
Creates and saves a csv file with the table data.
"""
file_dialog = QFileDialog()
file_dialog.setWindowTitle('Save File')
file_dialog.setDirectory(os.getcwd())
file_dialog.setAcceptMode(QFileDialog.AcceptSave)
file_dialog.setNameFilter('Csv files (*.csv)')
file_dialog.setDefaultSuffix('csv')
if file_dialog.exec_() == QFileDialog.Accepted:
path = file_dialog.selectedFiles()[0]
if path:
with open(path, mode="w", newline='',
encoding='utf8') as csv_file:
field_names = ["", "Unit", "Vap", "Liq", "Overall"]
writer = csv.DictWriter(csv_file, fieldnames=field_names)
writer.writeheader()
for row in range(self.table.rowCount()):
row_data = {}
row_data[""] = self.table.verticalHeaderItem(
row).text()
for col in range(self.table.columnCount()):
item = self.table.item(row, col)
if item is not None:
row_data[field_names[col + 1]] = item.text()
else:
row_data[field_names[col + 1]] = ''
writer.writerow(row_data)
def openXlsx(self, xlsx=None):
timesheet = self.context.timesheet
if self._exit_confirm_flag:
title = self.context.build_settings['app_name']
text = '上次儲存之後又有新的簽到紀錄。\n仍要重開簽到名單？'
reply = QMessageBox.question(self, title, text)
if reply == QMessageBox.No:
return False
if xlsx is None:
dialog = QFileDialog()
dialog.setAcceptMode(QFileDialog.AcceptOpen)
dialog.setFileMode(QFileDialog.ExistingFile)
dialog.setNameFilter('Spreadsheets (*.xlsx)')
if not dialog.exec_():
return False
xlsx = dialog.selectedFiles()[0]
# xlsx = 'oc13.xlsx'
timesheet.open(xlsx)
# View
self.uiTimesheetFrame.display()
self.uiInputEdit.setDisabled(False)
self.uiInputEdit.setFocus()
self.uiFileSaveBtn.setDisabled(False)
self.updateSpreadSheet()
self.updateProgressBar()
# Spinbox backgrounds
palette = self.uiBarColSpn.palette()
palette.setColor(QPalette.Base, BARCODE_COLOR.lighter())
self.uiBarColSpn.setPalette(palette)
palette = self.uiGrpColSpn.palette()
palette.setColor(QPalette.Base, GRPCODE_COLOR.lighter())
self.uiGrpColSpn.setPalette(palette)
self.statusbar.showMessage('載入 %d 列資料。' % timesheet.rowCount())
def file_select(self):
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setNameFilter("xlsx (*.xlsx)")
if dialog.exec_():
self.filepaths = dialog.selectedFiles()
self.file_upload_label.setText(get_file_name(self.filepaths[0]))
def open_button_clicked(self):
dialog = QFileDialog(self)
dialog.setFileMode(QFileDialog.ExistingFile)
dialog.setNameFilter('Wav File (*.wav)')
if dialog.exec_():
file_name = dialog.selectedFiles()[0]
self.wf = wave.open(file_name, 'rb')
self.open_stream()
def __open_dialog__(title, file_types, dir, setup_dialog, parent=None):
dialog = QFileDialog(parent)
if file_types: dialog.setNameFilter(file_types)
dialog.setDirectory(dir)
dialog.setWindowTitle(title)
setup_dialog(dialog)
dialog.finished.connect(lambda: dialog.deleteLater())
dialog.show()
def __open_dialog__(title, file_types, dir, setup_dialog, parent=None):
dialog = QFileDialog(parent)
if file_types: dialog.setNameFilter(file_types)
dialog.setDirectory(dir)
dialog.setWindowTitle(title)
setup_dialog(dialog)
dialog.finished.connect(lambda: dialog.deleteLater())
dialog.show()
def save(self):
dial = QFileDialog(self, "Save file")
dial.setFileMode(QFileDialog.AnyFile)
dial.setAcceptMode(QFileDialog.AcceptSave)
dial.setNameFilter("restraints (*.npy)")
if dial.exec_():
file_path = str(dial.selectedFiles()[0])
np.save(file_path, self.matrix)
def mousePressEvent(self, mouseEvent):
self.oldPos = QPointF(0, 0)
self.movingItem = None
if mouseEvent.button() != Qt.LeftButton:
return
if self.edit_mode == DesignerScene.SELECT:
handle = None
mousePos = QPointF(
mouseEvent.buttonDownScenePos(Qt.LeftButton).x(),
mouseEvent.buttonDownScenePos(Qt.LeftButton).y())
itemList = self.items(mousePos)
for item in itemList:
if isinstance(item, ItemHandle):
handle = item
break
elif isinstance(item, DesignItem):
if not item.isSceneRect():
self.movingItem = item
self.oldPos = item.pos()
break
if not self.movingItem and not handle:
self.blackSelectionRect = self.addRect(0, 0, 1, 1,
QPen(QColor("#000000")))
self.blackSelectionRect.setPos(mousePos)
self.whiteSelectionRect = self.addRect(1, 1, 1, 1,
QPen(QColor("#ffffff")))
self.whiteSelectionRect.setPos(mousePos)
super().mousePressEvent(mouseEvent)
else:
filter = ""
fileName = ""
if self.edit_mode == DesignerScene.BITMAP:
filter = "Image Files (*.png *.jpeg *.jpg *.gif *.bmp)All Files (*)"
title = "Open Bitmap"
elif self.edit_mode == DesignerScene.SVG:
filter = "SVG Files (*.svg)All Files (*)"
title = "Open SVG"
if filter:
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setNameFilter(filter)
dialog.setWindowTitle(title)
dialog.setOption(QFileDialog.DontUseNativeDialog, True)
dialog.setAcceptMode(QFileDialog.AcceptOpen)
if dialog.exec():
fileName = dialog.selectedFiles()[0]
del dialog
if not fileName:
return
addCommand = AddItemCommand(mouseEvent.scenePos().x(),
mouseEvent.scenePos().y(),
self.edit_mode, fileName, self)
self.undostack.push(addCommand)
def openDialog(name, filter):
""" Create non-native open file dialog. """
qfd = QFileDialog(getWindow(), name)
qfd.setNameFilter(filter)
qfd.setFileMode(QFileDialog.ExistingFile)
qfd.setOptions(QFileDialog.DontUseNativeDialog)
qfd.setAcceptMode(QFileDialog.AcceptOpen)
qfd.setViewMode(QFileDialog.List)
return qfd
def saveDialog(name, filter):
""" Create non-native save file dialog. """
qfd = QFileDialog(getWindow(), name)
qfd.setNameFilter(filter)
qfd.setFileMode(QFileDialog.AnyFile)
qfd.setOptions(QFileDialog.DontUseNativeDialog)
qfd.setAcceptMode(QFileDialog.AcceptSave)
qfd.setViewMode(QFileDialog.List)
return qfd
def save_workspace_dialog(self):
file_ext = "*.workspace"
dialog = QFileDialog(self)
dialog.setDefaultSuffix(".workspace")
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setWindowTitle("Save Workspace")
dialog.setNameFilter("Workspace Files ({})".format(file_ext))
if dialog.exec() == QDialog.Accepted:
Manager.save_workspace(dialog.selectedFiles()[0])
def on_button_clicked(self):
caption = 'Vyberte výstupní soubor'
dialog = QFileDialog(self, caption)
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setNameFilter('CSV soubory (*.csv)')
dialog.setDefaultSuffix('csv')
if dialog.exec_():
self.setFilename(dialog.selectedFiles()[0])
def callback_import(self, widget, data=None):
dialog = QFileDialog(self)
dialog.setWindowTitle(_("Import an old gpvdm simulation"))
dialog.setNameFilter('Simulations - gpvdm (*.gpvdm *.opvdm)')
dialog.setFileMode(QFileDialog.ExistingFile)
if dialog.exec_() == QDialog.Accepted:
filename = dialog.selectedFiles()[0]
import_archive(filename,os.path.join(os.getcwd(),"sim.gpvdm"),False)
self.change_dir_and_refresh_interface(os.getcwd())
def choose_file(self):
"""
Fires up user dialog letting him choose file to be opened.
"""
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.ExistingFile)
dialog.setNameFilter(config.FILE_TYPE)
if dialog.exec():
file_name = dialog.selectedFiles()[0]
self.open_file(file_name)
def export_account(self):
# Testable way of using a QFileDialog
export_dialog = QFileDialog(self)
export_dialog.setObjectName('ExportFileDialog')
export_dialog.setWindowTitle(self.tr("Export an account"))
export_dialog.setNameFilter(self.tr("All account files (*.acc)"))
export_dialog.setLabelText(QFileDialog.Accept, self.tr('Export'))
export_dialog.setOption(QFileDialog.DontUseNativeDialog, True)
export_dialog.accepted.connect(self.export_account_accepted)
export_dialog.show()
def save_as_gpvdm(parent):
dialog = QFileDialog(parent)
dialog.setWindowTitle(_("Save a the simulation as"))
dialog.setNameFilter(_("Directory"))
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setOption(QFileDialog.ShowDirsOnly, True)
if dialog.exec_() == QDialog.Accepted:
filename = dialog.selectedFiles()[0]
return filename
else:
return None
def load_regime_dialog(self):
regime_path = os.path.join(os.curdir)
dialog = QFileDialog(self)
dialog.setFileMode(QFileDialog.ExistingFile)
dialog.setDirectory(regime_path)
dialog.setNameFilter("Simulation Regime files (*.sreg)")
if dialog.exec_():
file = dialog.selectedFiles()[0]
self.load_regimes_from_file(file)
def exportAction(self):
dialog = QFileDialog(self)
dialog.setWindowModality(Qt.WindowModal) # check for mac only
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setWindowTitle(QApplication.translate("MainWindow", "Export Calculation"))
dialog.setDirectory(os.path.expanduser("~"))
dialog.setNameFilter(QApplication.translate("MainWindow",
"PNG files (*.png);;JPG files (*.jpg);;TIFF files (*.tif)"))
if dialog.exec():
filename = dialog.selectedFiles()
self.plotWidget.plotWidget.plotWidget.export(filename.pop())
def _open_radiograph(self):
file_dialog = QFileDialog(self)
file_dialog.setDirectory("./data/Radiographs")
file_dialog.setFileMode(QFileDialog.ExistingFile)
file_dialog.setNameFilter("Radiograph (*.tif)")
if file_dialog.exec_() and len(file_dialog.selectedFiles()) == 1:
radiograph = Radiograph()
radiograph.path_to_img = file_dialog.selectedFiles()[0]
#self.image = radiograph.image
#crop_translation = -Filter.get_cropping_region(radiograph.image).left_top
self.image = Filter.crop_image(radiograph.image)
self.lines = None
self._redraw()
def load_post_result_files(self):
path = self._settings.value("path/processing_results")
dialog = QFileDialog(self)
dialog.setFileMode(QFileDialog.ExistingFiles)
dialog.setDirectory(path)
dialog.setNameFilter("Postprocessing Output files (*.pof)")
if dialog.exec_():
files = dialog.selectedFiles()
for single_file in files:
if single_file:
self._load_post_result_file(single_file)
def load_result_files(self):
path = self._settings.value("path/simulation_results")
dialog = QFileDialog(self)
dialog.setFileMode(QFileDialog.ExistingFiles)
dialog.setDirectory(path)
dialog.setNameFilter("PyMoskito Result files (*.pmr)")
if dialog.exec_():
files = dialog.selectedFiles()
for single_file in files:
if single_file:
self._load_result_file(single_file)
def on_pushButton_PathToApplicationBinary_Select_clicked(self):
# Create file dialog
fileDialog = QFileDialog()
fileDialog.setWindowTitle("Select a Qt application binary...")
fileDialog.setFileMode(QFileDialog.ExistingFile)
fileDialog.setNameFilter("*.exe")
# Open file dialog
wasFileSelected = fileDialog.exec()
if wasFileSelected:
selectedFile = self.getNormalizedPath(fileDialog)
self.lineEdit_PathToApplicationBinary.setText(selectedFile)
self.settings.setValue(keyPathToApplicationBinary, selectedFile)
def _open_radiograph(self):
file_dialog = QFileDialog(self)
file_dialog.setDirectory("./data/Radiographs")
file_dialog.setFileMode(QFileDialog.ExistingFile)
file_dialog.setNameFilter("Radiograph (*.tif)")
if file_dialog.exec_() and len(file_dialog.selectedFiles()) == 1:
if self.animator is not None:
self.animator.stop()
radiograph = Radiograph()
radiograph.path_to_img = file_dialog.selectedFiles()[0]
self.image = radiograph.image
self.radiograph_image = Filter.crop_image(radiograph.image)
self.cached_init_poses = None
self._redraw(self.active_shape_model.current_tooth)
def openAction(self):
# first check save state of the current calculation
if self.checkSaveState():
dialog = QFileDialog(self)
dialog.setWindowModality(Qt.WindowModal) # check for mac only
dialog.setWindowTitle(QApplication.translate("MainWindow", "Open Calculation"))
dialog.setDirectory(os.path.expanduser("~"))
dialog.setNameFilter(QApplication.translate("MainWindow",
"XML files (*.xml);;All Files (*)"))
dialog.exec()
filename = dialog.selectedFiles()
if filename:
self.model.readFile(filename.pop())
def open_file(self):
#filename = QFileDialog.getOpenFileName(self, 'Open schematic file', '/opt/cad/kicad', 'KiCad Schematic Files (*.sch)')
dialog = QFileDialog(self)
dialog.setFileMode(QFileDialog.ExistingFile)
dialog.setNameFilter('KiCad Schematic Files (*.sch)')
filenames = []
if dialog.exec_():
filenames = dialog.selectedFiles()
if len(filenames) == 0:
return
CmpMgr.set_curr_file_path( filenames[0] )
self.CmpTable.load_file( filenames[0] )
def saveAsAction(self):
dialog = QFileDialog(self)
dialog.setWindowModality(Qt.WindowModal) # check for mac only
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setWindowTitle(QApplication.translate("MainWindow", "Save Calculation"))
dialog.setDirectory(os.path.expanduser("~"))
dialog.setNameFilter(QApplication.translate("MainWindow",
"XML files (*.xml);;All Files (*)"))
dialog.exec()
filename = dialog.selectedFiles()
if filename:
self.model.saveFile(filename.pop())
return True
else:
return False
def mousePressEvent(self, event):
fileNames = ''
path, file = os.path.split(self.text())
dialog = QFileDialog(self)
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setNameFilter( self.tr(self.file_type))
dialog.setDirectory(path)
if dialog.exec_():
fileNames = dialog.selectedFiles()
if len(fileNames):
if fileNames[0] != '':
self.setText(fileNames[0])
def callback_open(self, widget, data=None):
dialog = QFileDialog(self)
dialog.setWindowTitle(_("Open an existing gpvdm simulation"))
dialog.setNameFilter('Simulations - gpvdm (*.gpvdm *.opvdm)')
dialog.setFileMode(QFileDialog.ExistingFile)
if dialog.exec_() == QDialog.Accepted:
filename = dialog.selectedFiles()[0]
new_path=os.path.dirname(filename)
if ver_check_compatibility(filename)==True:
self.change_dir_and_refresh_interface(new_path)
else:
reply = yes_no_dlg(self,"The simulation you want to import looks like it was made on an old version of gpvdm, do you want to try to open it anyway?")
if reply == True:
update_simulaton_to_new_ver(dialog.get_filename())
self.change_dir_and_refresh_interface(new_path)
def triggered_load(self):
"""
Used to start the 'load config' dialog.
:return:
"""
fileNames = ''
dialog = QFileDialog(self)
dialog.setFileMode(QFileDialog.ExistingFile)
dialog.setNameFilter( self.tr("PaPI-Cfg (*.xml)"))
dialog.setDirectory(pc.CONFIG_DEFAULT_DIRECTORY)
dialog.setWindowTitle("Load Configuration")
if dialog.exec_():
fileNames = dialog.selectedFiles()
if len(fileNames):
if fileNames[0] != '':
self.last_config = fileNames[0]
self.load_config(fileNames[0])
def save_as_filter(parent,my_filter):
selected_filter = ""
dialog = QFileDialog(parent)
dialog.setWindowTitle(_("Save as"))
dialog.setNameFilter(my_filter)
dialog.setAcceptMode(QFileDialog.AcceptSave)
if dialog.exec_() == QDialog.Accepted:
filename = dialog.selectedFiles()[0]
s=dialog.selectedNameFilter()
if s.count("(*")==1:
s=s.split("(*")[1]
s=s[:-1]
if filename.endswith(s)==False:
filename=filename+s
else:
filename=filename
return filename
else:
return None
def get_open_dialog(directory_mode=False, parent=None, name_filter="full") -> QFileDialog:
fip = FileIconProvider()
dialog = QFileDialog(parent=parent, directory=RECENT_PATH)
dialog.setIconProvider(fip)
if directory_mode:
dialog.setFileMode(QFileDialog.Directory)
dialog.setWindowTitle("Open Folder")
else:
dialog.setFileMode(QFileDialog.ExistingFiles)
dialog.setWindowTitle("Open Files")
if name_filter == "full":
name_filter = "All Files (*);;" \
"Complex (*.complex);;" \
"Complex16 unsigned (*.complex16u *.cu8);;" \
"Complex16 signed (*.complex16s *.cs8);;" \
"WAV (*.wav);;" \
"Protocols (*.proto.xml *.proto);;" \
"Binary Protocols (*.bin);;" \
"Fuzzing Profiles (*.fuzz.xml *.fuzz);;" \
"Simulator (*.sim.xml *.sim)" \
"Plain Bits (*.txt);;" \
"Tar Archives (*.tar *.tar.gz *.tar.bz2);;" \
"Zip Archives (*.zip)"
elif name_filter == "proto":
name_filter = "Protocols (*.proto.xml *.proto);; Binary Protocols (*.bin)"
elif name_filter == "fuzz":
name_filter = "Fuzzprofiles (*.fuzz.xml *.fuzz)"
elif name_filter == "simulator":
name_filter = "Simulator (*.sim.xml *.sim)"
dialog.setNameFilter(name_filter)
dialog.setOptions(QFileDialog.DontResolveSymlinks)
dialog.setViewMode(QFileDialog.Detail)
return dialog
def saveTrace(self,checked):
#diag = QFileDialog.getSaveFileName(self, "Select destination", "./", "Comma Separated Values (*.csv)");
diag = QFileDialog(self);
diag.setAcceptMode(QFileDialog.AcceptSave) #Save file, not open one
diag.setNameFilter("Comma Separated Values (*.csv);;Space separated Values (*.csv)");
diag.setDefaultSuffix("csv"); # Make sure selected files end in .csv
diag.exec();
try:
filename = diag.selectedFiles()[0];
except IndexError:
filename = '';
user_filter = diag.selectedNameFilter();
if (user_filter == "Space separated Values (*.csv)"):
delimiter = " ";
else:
delimiter = ",";
if (filename != '' and not os.path.isdir(filename)):
npzfile = self.last_result;
t = npzfile["t"];
cos2 = npzfile["cos2"];
cos2d = npzfile["cos2d"];
extra_header = [];
extra_columns = [];
if ('Javg' in npzfile.keys()):
Javg = npzfile["Javg"];
std = npzfile["std"];
psi_pulse = npzfile["psi"];
psi_final = psi_pulse[-1];
psi_out=numpy.abs(psi_final)**2;
percentile_999 = npzfile["percentile_999"];
extra_header = ["<J>","std(J)","J_99.9%","Probability coefficients"];
extra_columns = [Javg,std,percentile_999,psi_out];
utils.save_to_csv(filename,t,cos2,cos2d,extra_header,extra_columns,delimiter);
def _save_data(self, file_path=None):
"""
Save the current simulation results.
If *fie_name* is given, the result will be saved to the specified
location, making automated exporting easier.
Args:
file_path(str): Absolute path of the target file. If `None` the
use will be asked for a storage location.
"""
regime_name = self._regimes[self._current_regime_index]["Name"]
if file_path is None:
# get default path
path = self._settings.value("path/simulation_results")
# create canonic file name
suggestion = self._simfile_name(regime_name)
else:
path = os.path.dirname(file_path)
suggestion = os.path.basename(file_path)
# check if path exists otherwise create it
if not os.path.isdir(path):
box = QMessageBox()
box.setText("Export Folder does not exist yet.")
box.setInformativeText("Do you want to create it? \n"
"{}".format(os.path.abspath(path)))
box.setStandardButtons(QMessageBox.Ok | QMessageBox.No)
box.setDefaultButton(QMessageBox.Ok)
ret = box.exec_()
if ret == QMessageBox.Ok:
os.makedirs(path)
else:
path = os.path.abspath(os.path.curdir)
file_path = None
# If no path was given, present the default and let the user choose
if file_path is None:
dialog = QFileDialog(self)
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setDirectory(path)
dialog.setNameFilter("PyMoskito Results (*.pmr)")
dialog.selectFile(suggestion)
if dialog.exec_():
file_path = dialog.selectedFiles()[0]
else:
self._logger.warning("Export Aborted")
return -1
# ask whether this should act as new default
path = os.path.abspath(os.path.dirname(file_path))
if path != self._settings.value("path/simulation_results"):
box = QMessageBox()
box.setText("Use this path as new default?")
box.setInformativeText("{}".format(path))
box.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
box.setDefaultButton(QMessageBox.Yes)
ret = box.exec_()
if ret == QMessageBox.Yes:
self._settings.setValue("path/simulation_results", path)
self.currentDataset.update({"regime name": regime_name})
with open(file_path, "wb") as f:
pickle.dump(self.currentDataset, f, protocol=4)
self.statusLabel.setText("results saved to {}".format(file_path))
self._logger.info("results saved to {}".format(file_path))
class MainController(QMainWindow):
def __init__(self, *args):
super().__init__(*args)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
OptionsController.write_default_options()
self.project_save_timer = QTimer()
self.project_manager = ProjectManager(self)
self.plugin_manager = PluginManager()
self.signal_tab_controller = SignalTabController(self.project_manager,
parent=self.ui.tab_interpretation)
self.ui.tab_interpretation.layout().addWidget(self.signal_tab_controller)
self.compare_frame_controller = CompareFrameController(parent=self.ui.tab_protocol,
plugin_manager=self.plugin_manager,
project_manager=self.project_manager)
self.compare_frame_controller.ui.splitter.setSizes([1, 1000000])
self.ui.tab_protocol.layout().addWidget(self.compare_frame_controller)
self.generator_tab_controller = GeneratorTabController(self.compare_frame_controller,
self.project_manager,
parent=self.ui.tab_generator)
self.undo_group = QUndoGroup()
self.undo_group.addStack(self.signal_tab_controller.signal_undo_stack)
self.undo_group.addStack(self.compare_frame_controller.protocol_undo_stack)
self.undo_group.addStack(self.generator_tab_controller.generator_undo_stack)
self.undo_group.setActiveStack(self.signal_tab_controller.signal_undo_stack)
self.participant_legend_model = ParticipantLegendListModel(self.project_manager.participants)
self.ui.listViewParticipants.setModel(self.participant_legend_model)
gtc = self.generator_tab_controller
gtc.ui.splitter.setSizes([gtc.width() / 0.7, gtc.width() / 0.3])
self.ui.tab_generator.layout().addWidget(self.generator_tab_controller)
self.signal_protocol_dict = {} # type: dict[SignalFrameController, ProtocolAnalyzer]
self.ui.lnEdtTreeFilter.setClearButtonEnabled(True)
group = QActionGroup(self)
self.ui.actionFSK.setActionGroup(group)
self.ui.actionOOK.setActionGroup(group)
self.ui.actionNone.setActionGroup(group)
self.ui.actionPSK.setActionGroup(group)
self.recentFileActionList = []
self.create_connects()
self.init_recent_file_action_list(constants.SETTINGS.value("recentFiles", []))
self.filemodel = FileSystemModel(self)
path = QDir.homePath()
self.filemodel.setIconProvider(FileIconProvider())
self.filemodel.setRootPath(path)
self.file_proxy_model = FileFilterProxyModel(self)
self.file_proxy_model.setSourceModel(self.filemodel)
self.ui.fileTree.setModel(self.file_proxy_model)
self.ui.fileTree.setRootIndex(self.file_proxy_model.mapFromSource(self.filemodel.index(path)))
self.ui.fileTree.setToolTip(path)
self.ui.fileTree.header().setSectionResizeMode(0, QHeaderView.ResizeToContents)
self.ui.fileTree.header().setSectionResizeMode(1, QHeaderView.Stretch)
self.ui.fileTree.setFocus()
self.generator_tab_controller.table_model.cfc = self.compare_frame_controller
self.ui.actionConvert_Folder_to_Project.setEnabled(False)
undo_action = self.undo_group.createUndoAction(self)
undo_action.setIcon(QIcon.fromTheme("edit-undo"))
undo_action.setShortcut(QKeySequence.Undo)
self.ui.menuEdit.insertAction(self.ui.actionDecoding, undo_action)
redo_action = self.undo_group.createRedoAction(self)
redo_action.setIcon(QIcon.fromTheme("edit-redo"))
redo_action.setShortcut(QKeySequence.Redo)
self.ui.menuEdit.insertAction(self.ui.actionDecoding, redo_action)
self.ui.menuEdit.insertSeparator(self.ui.actionDecoding)
self.ui.actionAbout_Qt.setIcon(QIcon(":/qt-project.org/qmessagebox/images/qtlogo-64.png"))
self.ui.splitter.setSizes([0, 1])
self.refresh_main_menu()
self.apply_default_view(constants.SETTINGS.value('default_view', type=int))
self.project_save_timer.start(ProjectManager.AUTOSAVE_INTERVAL_MINUTES * 60 * 1000)
self.ui.actionProject_settings.setVisible(False)
self.ui.actionSave_project.setVisible(False)
def create_connects(self):
self.ui.actionFullscreen_mode.setShortcut(QKeySequence.FullScreen)
self.ui.actionOpen.setShortcut(QKeySequence(QKeySequence.Open))
self.ui.actionOpen_directory.setShortcut(QKeySequence("Ctrl+Shift+O"))
self.ui.menuEdit.aboutToShow.connect(self.on_edit_menu_about_to_show)
self.ui.actionNew_Project.triggered.connect(self.on_new_project_action_triggered)
self.ui.actionNew_Project.setShortcut(QKeySequence.New)
self.ui.actionProject_settings.triggered.connect(self.on_project_settings_action_triggered)
self.ui.actionSave_project.triggered.connect(self.project_manager.saveProject)
self.ui.actionAbout_AutomaticHacker.triggered.connect(self.on_show_about_clicked)
self.ui.actionRecord.triggered.connect(self.on_show_record_dialog_action_triggered)
self.ui.actionFullscreen_mode.triggered.connect(self.on_fullscreen_action_triggered)
self.ui.actionSaveAllSignals.triggered.connect(self.signal_tab_controller.save_all)
self.ui.actionClose_all.triggered.connect(self.on_close_all_action_triggered)
self.ui.actionOpen.triggered.connect(self.on_open_file_action_triggered)
self.ui.actionOpen_directory.triggered.connect(self.on_open_directory_action_triggered)
self.ui.actionDecoding.triggered.connect(self.on_show_decoding_dialog_triggered)
self.ui.actionSpectrum_Analyzer.triggered.connect(self.on_show_spectrum_dialog_action_triggered)
self.ui.actionOptions.triggered.connect(self.show_options_dialog_action_triggered)
self.ui.actionSniff_protocol.triggered.connect(self.show_proto_sniff_dialog)
self.ui.actionAbout_Qt.triggered.connect(QApplication.instance().aboutQt)
self.ui.btnFileTreeGoUp.clicked.connect(self.on_btn_file_tree_go_up_clicked)
self.ui.fileTree.directory_open_wanted.connect(self.project_manager.set_project_folder)
self.signal_tab_controller.frame_closed.connect(self.close_signal_frame)
self.signal_tab_controller.signal_created.connect(self.add_signal)
self.signal_tab_controller.ui.scrollArea.files_dropped.connect(self.on_files_dropped)
self.signal_tab_controller.files_dropped.connect(self.on_files_dropped)
self.signal_tab_controller.frame_was_dropped.connect(self.set_frame_numbers)
self.compare_frame_controller.show_interpretation_clicked.connect(
self.show_protocol_selection_in_interpretation)
self.compare_frame_controller.files_dropped.connect(self.on_files_dropped)
self.compare_frame_controller.show_decoding_clicked.connect(self.on_show_decoding_dialog_triggered)
self.compare_frame_controller.ui.treeViewProtocols.files_dropped_on_group.connect(
self.on_files_dropped_on_group)
self.compare_frame_controller.participant_changed.connect(self.signal_tab_controller.on_participant_changed)
self.compare_frame_controller.ui.treeViewProtocols.close_wanted.connect(self.on_cfc_close_wanted)
self.compare_frame_controller.show_config_field_types_triggered.connect(
self.on_show_field_types_config_action_triggered)
self.ui.lnEdtTreeFilter.textChanged.connect(self.on_file_tree_filter_text_changed)
self.ui.tabWidget.currentChanged.connect(self.on_selected_tab_changed)
self.project_save_timer.timeout.connect(self.project_manager.saveProject)
self.ui.actionConvert_Folder_to_Project.triggered.connect(self.project_manager.convert_folder_to_project)
self.project_manager.project_loaded_status_changed.connect(self.ui.actionProject_settings.setVisible)
self.project_manager.project_loaded_status_changed.connect(self.ui.actionSave_project.setVisible)
self.project_manager.project_loaded_status_changed.connect(self.ui.actionConvert_Folder_to_Project.setDisabled)
self.project_manager.project_updated.connect(self.on_project_updated)
self.ui.textEditProjectDescription.textChanged.connect(self.on_text_edit_project_description_text_changed)
self.ui.tabWidget_Project.tabBarDoubleClicked.connect(self.on_project_tab_bar_double_clicked)
self.ui.listViewParticipants.doubleClicked.connect(self.on_project_settings_action_triggered)
self.ui.actionShowFileTree.triggered.connect(self.on_action_show_filetree_triggered)
self.ui.actionShowFileTree.setShortcut(QKeySequence("F10"))
self.ui.menuFile.addSeparator()
for i in range(constants.MAX_RECENT_FILE_NR):
recent_file_action = QAction(self)
recent_file_action.setVisible(False)
recent_file_action.triggered.connect(self.on_open_recent_action_triggered)
self.recentFileActionList.append(recent_file_action)
self.ui.menuFile.addAction(self.recentFileActionList[i])
def add_plain_bits_from_txt(self, filename: str):
protocol = ProtocolAnalyzer(None)
protocol.filename = filename
with open(filename) as f:
for line in f:
protocol.messages.append(Message.from_plain_bits_str(line.strip()))
self.compare_frame_controller.add_protocol(protocol)
self.compare_frame_controller.refresh()
self.__add_empty_frame_for_filename(protocol, filename)
def __add_empty_frame_for_filename(self, protocol: ProtocolAnalyzer, filename: str):
sf = self.signal_tab_controller.add_empty_frame(filename, protocol)
self.signal_protocol_dict[sf] = protocol
self.set_frame_numbers()
self.file_proxy_model.open_files.add(filename)
def add_protocol_file(self, filename):
proto = self.compare_frame_controller.add_protocol_from_file(filename)
if proto:
self.__add_empty_frame_for_filename(proto, filename)
def add_fuzz_profile(self, filename):
self.ui.tabWidget.setCurrentIndex(2)
self.generator_tab_controller.load_from_file(filename)
def add_signalfile(self, filename: str, group_id=0):
if not os.path.exists(filename):
QMessageBox.critical(self, self.tr("File not Found"),
self.tr("The file {0} could not be found. Was it moved or renamed?").format(
filename))
return
already_qad_demodulated = False
if filename.endswith(".wav"):
cb = QCheckBox("Signal in file is already quadrature demodulated")
msg = self.tr("You selected a .wav file as signal.\n"
"Universal Radio Hacker (URH) will interpret it as real part of the signal.\n"
"Protocol results may be bad due to missing imaginary part.\n\n"
"Load a complex file if you experience problems.\n"
"You have been warned.")
msg_box = QMessageBox(QMessageBox.Information, "WAV file selected", msg)
msg_box.addButton(QMessageBox.Ok)
msg_box.addButton(QMessageBox.Abort)
msg_box.setCheckBox(cb)
reply = msg_box.exec()
if reply != QMessageBox.Ok:
return
already_qad_demodulated = cb.isChecked()
sig_name = os.path.splitext(os.path.basename(filename))[0]
# Use default sample rate for signal
# Sample rate will be overriden in case of a project later
signal = Signal(filename, sig_name, wav_is_qad_demod=already_qad_demodulated,
sample_rate=self.project_manager.device_conf["sample_rate"])
if self.project_manager.project_file is None:
self.adjust_for_current_file(signal.filename)
self.file_proxy_model.open_files.add(filename)
self.add_signal(signal, group_id)
def add_signal(self, signal, group_id=0):
self.setCursor(Qt.WaitCursor)
pa = ProtocolAnalyzer(signal)
sig_frame = self.signal_tab_controller.add_signal_frame(pa)
pa = self.compare_frame_controller.add_protocol(pa, group_id)
signal.blockSignals(True)
has_entry = self.project_manager.read_project_file_for_signal(signal)
if not has_entry:
signal.auto_detect()
signal.blockSignals(False)
self.signal_protocol_dict[sig_frame] = pa
sig_frame.refresh(draw_full_signal=True) # Hier wird das Protokoll ausgelesen
if self.project_manager.read_participants_for_signal(signal, pa.messages):
sig_frame.ui.gvSignal.redraw_view()
sig_frame.ui.gvSignal.auto_fit_view()
self.set_frame_numbers()
self.compare_frame_controller.filter_search_results()
self.refresh_main_menu()
self.unsetCursor()
def close_protocol(self, protocol):
self.compare_frame_controller.remove_protocol(protocol)
# Needs to be removed in generator also, otherwise program crashes,
# if item from tree in generator is selected and corresponding signal is closed
self.generator_tab_controller.tree_model.remove_protocol(protocol)
protocol.eliminate()
def close_signal_frame(self, signal_frame: SignalFrameController):
try:
self.project_manager.write_signal_information_to_project_file(signal_frame.signal)
try:
proto = self.signal_protocol_dict[signal_frame]
except KeyError:
proto = None
if proto is not None:
self.close_protocol(proto)
del self.signal_protocol_dict[signal_frame]
if self.signal_tab_controller.ui.scrlAreaSignals.minimumHeight() > signal_frame.height():
self.signal_tab_controller.ui.scrlAreaSignals.setMinimumHeight(
self.signal_tab_controller.ui.scrlAreaSignals.minimumHeight() - signal_frame.height())
if signal_frame.signal is not None:
# Non-Empty Frame (when a signal and not a protocol is opened)
self.file_proxy_model.open_files.discard(signal_frame.signal.filename)
signal_frame.eliminate()
self.compare_frame_controller.ui.treeViewProtocols.expandAll()
self.set_frame_numbers()
self.refresh_main_menu()
except Exception as e:
Errors.generic_error(self.tr("Failed to close"), str(e), traceback.format_exc())
self.unsetCursor()
def add_files(self, filepaths, group_id=0):
num_files = len(filepaths)
if num_files == 0:
return
for i, file in enumerate(filepaths):
if not os.path.exists(file):
continue
if os.path.isdir(file):
for f in self.signal_tab_controller.signal_frames:
self.close_signal_frame(f)
FileOperator.RECENT_PATH = file
self.project_manager.set_project_folder(file)
return
_, file_extension = os.path.splitext(file)
FileOperator.RECENT_PATH = os.path.split(file)[0]
if file_extension == ".complex":
self.add_signalfile(file, group_id)
elif file_extension == ".coco":
self.add_signalfile(file, group_id)
elif file_extension == ".proto":
self.add_protocol_file(file)
elif file_extension == ".wav":
self.add_signalfile(file, group_id)
elif file_extension == ".fuzz":
self.add_fuzz_profile(file)
elif file_extension == ".txt":
self.add_plain_bits_from_txt(file)
else:
self.add_signalfile(file, group_id)
def set_frame_numbers(self):
self.signal_tab_controller.set_frame_numbers()
def closeEvent(self, event: QCloseEvent):
self.project_manager.saveProject()
super().closeEvent(event)
def close_all(self):
self.filemodel.setRootPath(QDir.homePath())
self.ui.fileTree.setRootIndex(self.file_proxy_model.mapFromSource(self.filemodel.index(QDir.homePath())))
self.project_manager.saveProject()
self.signal_tab_controller.close_all()
self.compare_frame_controller.reset()
self.generator_tab_controller.table_model.protocol.clear()
self.generator_tab_controller.refresh_tree()
self.generator_tab_controller.refresh_table()
self.generator_tab_controller.refresh_label_list()
self.project_manager.project_path = ""
self.project_manager.project_file = None
self.signal_tab_controller.signal_undo_stack.clear()
self.compare_frame_controller.protocol_undo_stack.clear()
self.generator_tab_controller.generator_undo_stack.clear()
def show_options_dialog_specific_tab(self, tab_index: int):
op = OptionsController(self.plugin_manager.installed_plugins, parent=self)
op.values_changed.connect(self.on_options_changed)
op.ui.tabWidget.setCurrentIndex(tab_index)
op.show()
def refresh_main_menu(self):
enable = len(self.signal_protocol_dict) > 0
self.ui.actionSaveAllSignals.setEnabled(enable)
self.ui.actionClose_all.setEnabled(enable)
def apply_default_view(self, view_index: int):
self.compare_frame_controller.ui.cbProtoView.setCurrentIndex(view_index)
self.generator_tab_controller.ui.cbViewType.setCurrentIndex(view_index)
for sig_frame in self.signal_tab_controller.signal_frames:
sig_frame.ui.cbProtoView.setCurrentIndex(view_index)
def show_project_settings(self):
pdc = ProjectDialogController(new_project=False, project_manager=self.project_manager, parent=self)
pdc.finished.connect(self.on_project_dialog_finished)
pdc.show()
def collapse_project_tab_bar(self):
self.ui.tabParticipants.hide()
self.ui.tabDescription.hide()
self.ui.tabWidget_Project.setMaximumHeight(self.ui.tabWidget_Project.tabBar().height())
def expand_project_tab_bar(self):
self.ui.tabDescription.show()
self.ui.tabParticipants.show()
self.ui.tabWidget_Project.setMaximumHeight(9000)
@pyqtSlot()
def on_project_tab_bar_double_clicked(self):
if self.ui.tabParticipants.isVisible():
self.collapse_project_tab_bar()
else:
self.expand_project_tab_bar()
@pyqtSlot()
def on_project_updated(self):
self.participant_legend_model.participants = self.project_manager.participants
self.participant_legend_model.update()
self.compare_frame_controller.refresh()
self.ui.textEditProjectDescription.setText(self.project_manager.description)
@pyqtSlot()
def on_fullscreen_action_triggered(self):
if self.ui.actionFullscreen_mode.isChecked():
self.showFullScreen()
else:
self.showMaximized()
@pyqtSlot(str)
def adjust_for_current_file(self, file_path):
if file_path is None:
return
if file_path in FileOperator.archives.keys():
file_path = copy.copy(FileOperator.archives[file_path])
settings = constants.SETTINGS
recent_file_paths = settings.value("recentFiles", [])
recent_file_paths = [] if recent_file_paths is None else recent_file_paths # check None for OSX
recent_file_paths = [p for p in recent_file_paths if p != file_path and p is not None and os.path.exists(p)]
recent_file_paths.insert(0, file_path)
recent_file_paths = recent_file_paths[:constants.MAX_RECENT_FILE_NR]
self.init_recent_file_action_list(recent_file_paths)
settings.setValue("recentFiles", recent_file_paths)
def init_recent_file_action_list(self, recent_file_paths: list):
for i in range(len(self.recentFileActionList)):
self.recentFileActionList[i].setVisible(False)
if recent_file_paths is None:
return
for i, file_path in enumerate(recent_file_paths):
if os.path.isfile(file_path):
display_text = os.path.basename(file_path)
self.recentFileActionList[i].setIcon(QIcon())
elif os.path.isdir(file_path):
head, tail = os.path.split(file_path)
display_text = tail
head, tail = os.path.split(head)
if tail:
display_text = tail + "/" + display_text
self.recentFileActionList[i].setIcon(QIcon.fromTheme("folder"))
else:
continue
self.recentFileActionList[i].setText(display_text)
self.recentFileActionList[i].setData(file_path)
self.recentFileActionList[i].setVisible(True)
@pyqtSlot()
def on_show_field_types_config_action_triggered(self):
self.show_options_dialog_specific_tab(tab_index=2)
@pyqtSlot()
def on_open_recent_action_triggered(self):
action = self.sender()
try:
if os.path.isdir(action.data()):
self.project_manager.set_project_folder(action.data())
elif os.path.isfile(action.data()):
self.setCursor(Qt.WaitCursor)
self.add_files(FileOperator.uncompress_archives([action.data()], QDir.tempPath()))
self.unsetCursor()
except Exception as e:
Errors.generic_error(self.tr("Failed to open"), str(e), traceback.format_exc())
self.unsetCursor()
@pyqtSlot()
def on_show_about_clicked(self):
descr = "<b><h2>Universal Radio Hacker</h2></b>Version: {0}<br />" \
"GitHub: <a href='https://github.com/jopohl/urh'>https://github.com/jopohl/urh</a><br /><br />" \
"Creators:<i><ul><li>" \
"Johannes Pohl <<a href='mailto:[email protected]'>[email protected]</a>></li>" \
"<li>Andreas Noack <<a href='mailto:[email protected]'>[email protected]</a>></li>" \
"</ul></i>".format(version.VERSION)
QMessageBox.about(self, self.tr("About"), self.tr(descr))
@pyqtSlot(int, int, int, int)
def show_protocol_selection_in_interpretation(self, start_message, start, end_message, end):
cfc = self.compare_frame_controller
msg_total = 0
last_sig_frame = None
for protocol in cfc.protocol_list:
if not protocol.show:
continue
n = protocol.num_messages
view_type = cfc.ui.cbProtoView.currentIndex()
messages = [i - msg_total for i in range(msg_total, msg_total + n) if start_message <= i <= end_message]
if len(messages) > 0:
try:
signal_frame = next((sf for sf, pf in self.signal_protocol_dict.items() if pf == protocol))
except StopIteration:
QMessageBox.critical(self, self.tr("Error"),
self.tr("Could not find corresponding signal frame."))
return
signal_frame.set_roi_from_protocol_analysis(min(messages), start, max(messages), end + 1, view_type)
last_sig_frame = signal_frame
msg_total += n
focus_frame = last_sig_frame
if last_sig_frame is not None:
self.signal_tab_controller.ui.scrollArea.ensureWidgetVisible(last_sig_frame, 0, 0)
QApplication.instance().processEvents()
self.ui.tabWidget.setCurrentIndex(0)
if focus_frame is not None:
focus_frame.ui.txtEdProto.setFocus()
@pyqtSlot(str)
def on_file_tree_filter_text_changed(self, text: str):
if len(text) > 0:
self.filemodel.setNameFilters(["*" + text + "*"])
else:
self.filemodel.setNameFilters(["*"])
@pyqtSlot()
def on_show_decoding_dialog_triggered(self):
signals = [sf.signal for sf in self.signal_tab_controller.signal_frames]
decoding_controller = DecoderWidgetController(
self.compare_frame_controller.decodings, signals,
self.project_manager, parent=self)
decoding_controller.finished.connect(self.update_decodings)
decoding_controller.show()
decoding_controller.decoder_update()
@pyqtSlot()
def update_decodings(self):
self.compare_frame_controller.load_decodings()
self.compare_frame_controller.fill_decoding_combobox()
self.compare_frame_controller.refresh_existing_encodings()
self.generator_tab_controller.refresh_existing_encodings(self.compare_frame_controller.decodings)
@pyqtSlot(int)
def on_selected_tab_changed(self, index: int):
if index == 0:
self.undo_group.setActiveStack(self.signal_tab_controller.signal_undo_stack)
elif index == 1:
self.undo_group.setActiveStack(self.compare_frame_controller.protocol_undo_stack)
self.compare_frame_controller.ui.tblViewProtocol.resize_columns()
self.compare_frame_controller.ui.tblViewProtocol.resize_vertical_header()
h = max(self.compare_frame_controller.ui.btnSaveProto.height(),
self.generator_tab_controller.ui.btnSave.height())
self.compare_frame_controller.ui.btnSaveProto.setMinimumHeight(h)
th = self.compare_frame_controller.ui.tabWidget.tabBar().height()
for i in range(self.compare_frame_controller.ui.tabWidget.count()):
self.compare_frame_controller.ui.tabWidget.widget(i).layout().setContentsMargins(0, 7 + h - th, 0, 0)
elif index == 2:
self.undo_group.setActiveStack(self.generator_tab_controller.generator_undo_stack)
h = max(self.compare_frame_controller.ui.btnSaveProto.height(),
self.generator_tab_controller.ui.btnSave.height())
self.generator_tab_controller.ui.btnSave.setMinimumHeight(h)
th = self.generator_tab_controller.ui.tabWidget.tabBar().height()
for i in range(self.generator_tab_controller.ui.tabWidget.count()):
self.generator_tab_controller.ui.tabWidget.widget(i).layout().setContentsMargins(0, 7 + h - th, 0, 0)
@pyqtSlot()
def on_show_record_dialog_action_triggered(self):
pm = self.project_manager
try:
r = ReceiveDialogController(pm, parent=self)
except OSError as e:
logger.error(repr(e))
return
if r.has_empty_device_list:
Errors.no_device()
r.close()
return
r.recording_parameters.connect(pm.set_recording_parameters)
r.files_recorded.connect(self.on_signals_recorded)
r.show()
@pyqtSlot()
def show_proto_sniff_dialog(self):
pm = self.project_manager
signal = next((proto.signal for proto in self.compare_frame_controller.protocol_list), None)
bit_len = signal.bit_len if signal else 100
mod_type = signal.modulation_type if signal else 1
tolerance = signal.tolerance if signal else 5
noise = signal.noise_threshold if signal else 0.001
center = signal.qad_center if signal else 0.02
psd = ProtocolSniffDialogController(pm, noise, center, bit_len, tolerance, mod_type,
self.compare_frame_controller.decodings,
encoding_index=self.compare_frame_controller.ui.cbDecoding.currentIndex(),
parent=self)
if psd.has_empty_device_list:
Errors.no_device()
psd.close()
else:
psd.recording_parameters.connect(pm.set_recording_parameters)
psd.protocol_accepted.connect(self.compare_frame_controller.add_sniffed_protocol_messages)
psd.show()
@pyqtSlot()
def on_show_spectrum_dialog_action_triggered(self):
pm = self.project_manager
r = SpectrumDialogController(pm, parent=self)
if r.has_empty_device_list:
Errors.no_device()
r.close()
return
r.recording_parameters.connect(pm.set_recording_parameters)
r.show()
@pyqtSlot(list)
def on_signals_recorded(self, file_names: list):
QApplication.instance().setOverrideCursor(Qt.WaitCursor)
for filename in file_names:
self.add_signalfile(filename)
QApplication.instance().restoreOverrideCursor()
@pyqtSlot()
def show_options_dialog_action_triggered(self):
self.show_options_dialog_specific_tab(tab_index=0)
@pyqtSlot()
def on_new_project_action_triggered(self):
pdc = ProjectDialogController(parent=self)
pdc.finished.connect(self.on_project_dialog_finished)
pdc.show()
@pyqtSlot()
def on_project_settings_action_triggered(self):
self.show_project_settings()
@pyqtSlot()
def on_edit_menu_about_to_show(self):
self.ui.actionShowFileTree.setChecked(self.ui.splitter.sizes()[0] > 0)
@pyqtSlot()
def on_action_show_filetree_triggered(self):
if self.ui.splitter.sizes()[0] > 0:
self.ui.splitter.setSizes([0, 1])
else:
self.ui.splitter.setSizes([1, 1])
@pyqtSlot()
def on_project_dialog_finished(self):
if self.sender().committed:
if self.sender().new_project:
for f in self.signal_tab_controller.signal_frames:
self.close_signal_frame(f)
self.project_manager.from_dialog(self.sender())
@pyqtSlot()
def on_open_file_action_triggered(self):
self.show_open_dialog(directory=False)
@pyqtSlot()
def on_open_directory_action_triggered(self):
self.show_open_dialog(directory=True)
def show_open_dialog(self, directory=False):
fip = FileIconProvider()
self.dialog = QFileDialog(self)
self.dialog.setIconProvider(fip)
self.dialog.setDirectory(FileOperator.RECENT_PATH)
self.dialog.setWindowTitle("Open Folder")
if directory:
self.dialog.setFileMode(QFileDialog.Directory)
else:
self.dialog.setFileMode(QFileDialog.ExistingFiles)
self.dialog.setNameFilter(
"All files (*);;Complex (*.complex);;Complex16 unsigned (*.complex16u);;Complex16 signed (*.complex16s);;Wave (*.wav);;Protocols (*.proto);;"
"Fuzzprofiles (*.fuzz);;Tar Archives (*.tar *.tar.gz *.tar.bz2);;Zip Archives (*.zip)")
self.dialog.setOptions(QFileDialog.DontResolveSymlinks)
self.dialog.setViewMode(QFileDialog.Detail)
if self.dialog.exec_():
try:
file_names = self.dialog.selectedFiles()
folders = [folder for folder in file_names if os.path.isdir(folder)]
if len(folders) > 0:
folder = folders[0]
for f in self.signal_tab_controller.signal_frames:
self.close_signal_frame(f)
self.project_manager.set_project_folder(folder)
else:
self.setCursor(Qt.WaitCursor)
file_names = FileOperator.uncompress_archives(file_names, QDir.tempPath())
self.add_files(file_names)
self.unsetCursor()
except Exception as e:
Errors.generic_error(self.tr("Failed to open"), str(e), traceback.format_exc())
QApplication.instance().restoreOverrideCursor()
@pyqtSlot()
def on_close_all_action_triggered(self):
self.close_all()
@pyqtSlot(list)
def on_files_dropped(self, files):
"""
:type files: list of QtCore.QUrl
"""
self.__add_urls_to_group(files, group_id=0)
@pyqtSlot(list, int)
def on_files_dropped_on_group(self, files, group_id: int):
"""
:param group_id:
:type files: list of QtCore.QUrl
"""
self.__add_urls_to_group(files, group_id=group_id)
def __add_urls_to_group(self, file_urls, group_id=0):
local_files = [file_url.toLocalFile() for file_url in file_urls if file_url.isLocalFile()]
if len(local_files) > 0:
self.setCursor(Qt.WaitCursor)
self.add_files(FileOperator.uncompress_archives(local_files, QDir.tempPath()), group_id=group_id)
self.unsetCursor()
@pyqtSlot(list)
def on_cfc_close_wanted(self, protocols: list):
frame_protos = {sframe: protocol for sframe, protocol in self.signal_protocol_dict.items() if protocol in protocols}
for frame in frame_protos:
self.close_signal_frame(frame)
for proto in (proto for proto in protocols if proto not in frame_protos.values()):
# close protocols without associated signal frame
self.close_protocol(proto)
@pyqtSlot(dict)
def on_options_changed(self, changed_options: dict):
refresh_protocol_needed = "show_pause_as_time" in changed_options
if refresh_protocol_needed:
for sf in self.signal_tab_controller.signal_frames:
sf.refresh_protocol()
self.compare_frame_controller.refresh_field_types_for_labels()
self.compare_frame_controller.set_shown_protocols()
self.generator_tab_controller.set_network_sdr_send_button_visibility()
self.generator_tab_controller.init_rfcat_plugin()
if "default_view" in changed_options:
self.apply_default_view(int(changed_options["default_view"]))
@pyqtSlot()
def on_text_edit_project_description_text_changed(self):
self.project_manager.description = self.ui.textEditProjectDescription.toPlainText()
@pyqtSlot()
def on_btn_file_tree_go_up_clicked(self):
cur_dir = self.filemodel.rootDirectory()
if cur_dir.cdUp():
path = cur_dir.path()
self.filemodel.setRootPath(path)
self.ui.fileTree.setRootIndex(self.file_proxy_model.mapFromSource(self.filemodel.index(path)))
class MainWindow(QMainWindow, Ui_MainWindow):
'''
classdocs
'''
def __init__(self, app):
"""
Init
:param cutecoin.core.app.Application app: application
:type: cutecoin.core.app.Application
"""
# Set up the user interface from Designer.
super().__init__()
self.setupUi(self)
QApplication.setWindowIcon(QIcon(":/icons/cutecoin_logo"))
self.app = app
logging.debug(app.thread())
logging.debug(self.thread())
self.password_asker = None
self.initialized = False
self.busybar = QProgressBar(self.statusbar)
self.busybar.setMinimum(0)
self.busybar.setMaximum(0)
self.busybar.setValue(-1)
self.statusbar.addWidget(self.busybar)
self.busybar.hide()
self.app.version_requested.connect(self.latest_version_requested)
self.app.get_last_version()
self.combo_referential = QComboBox(self)
self.combo_referential.setEnabled(False)
self.combo_referential.currentIndexChanged.connect(self.referential_changed)
self.status_label = QLabel("", self)
self.status_label.setTextFormat(Qt.RichText)
self.label_time = QLabel("", self)
self.statusbar.addPermanentWidget(self.status_label, 1)
self.statusbar.addPermanentWidget(self.label_time)
self.statusbar.addPermanentWidget(self.combo_referential)
self.update_time()
self.loader = Loader(self.app)
self.loader.loaded.connect(self.loader_finished)
self.loader.connection_error.connect(self.display_error)
self.homescreen = HomeScreenWidget(self.app)
self.centralWidget().layout().addWidget(self.homescreen)
self.homescreen.button_new.clicked.connect(self.open_add_account_dialog)
self.homescreen.button_import.clicked.connect(self.import_account)
self.open_ucoin_info = lambda: QDesktopServices.openUrl(QUrl("http://ucoin.io/theoretical/"))
self.homescreen.button_info.clicked.connect(self.open_ucoin_info)
self.import_dialog = None
self.export_dialog = None
# TODO: There are too much refresh() calls on startup
self.refresh()
def open_add_account_dialog(self):
dialog = ProcessConfigureAccount(self.app, None)
result = dialog.exec_()
if result == QDialog.Accepted:
self.action_change_account(self.app.current_account.name)
@pyqtSlot(str)
def display_error(self, error):
QMessageBox.critical(self, ":(",
error,
QMessageBox.Ok)
@pyqtSlot(str)
def referential_changed(self, index):
if self.app.current_account:
self.app.current_account.set_display_referential(index)
if self.currencies_tabwidget.currentWidget():
self.currencies_tabwidget.currentWidget().referential_changed()
@pyqtSlot()
def update_time(self):
date = QDate.currentDate()
self.label_time.setText("{0}".format(date.toString("dd/MM/yyyy")))
next_day = date.addDays(1)
current_time = QDateTime().currentDateTime().toMSecsSinceEpoch()
next_time = QDateTime(next_day).toMSecsSinceEpoch()
timer = QTimer()
timer.timeout.connect(self.update_time)
timer.start(next_time - current_time)
@pyqtSlot()
def delete_contact(self):
contact = self.sender().data()
self.app.current_account.contacts.remove(contact)
self.refresh_contacts()
@pyqtSlot()
def edit_contact(self):
index = self.sender().data()
dialog = ConfigureContactDialog(self.app.current_account, self, None, index)
result = dialog.exec_()
if result == QDialog.Accepted:
self.window().refresh_contacts()
def action_change_account(self, account_name):
def loading_progressed(value, maximum):
logging.debug("Busybar : {:} : {:}".format(value, maximum))
self.busybar.setValue(value)
self.busybar.setMaximum(maximum)
QApplication.processEvents()
if self.app.current_account:
self.app.save_cache(self.app.current_account)
self.app.current_account = None
self.refresh()
QApplication.setOverrideCursor(Qt.BusyCursor)
self.app.loading_progressed.connect(loading_progressed)
self.busybar.setMinimum(0)
self.busybar.setMaximum(0)
self.busybar.setValue(-1)
self.busybar.show()
self.status_label.setText(self.tr("Loading account {0}").format(account_name))
self.loader.set_account_name(account_name)
QTimer.singleShot(10, self.loader.load)
self.homescreen.button_new.hide()
self.homescreen.button_import.hide()
@pyqtSlot()
def loader_finished(self):
logging.debug("Finished loading")
self.refresh()
self.busybar.hide()
QApplication.setOverrideCursor(Qt.ArrowCursor)
try:
self.app.disconnect()
except:
logging.debug("Disconnect of app failed")
self.app.monitor.start_network_watchers()
QApplication.processEvents()
def open_transfer_money_dialog(self):
dialog = TransferMoneyDialog(self.app.current_account,
self.password_asker)
dialog.accepted.connect(self.refresh_wallets)
if dialog.exec_() == QDialog.Accepted:
currency_tab = self.currencies_tabwidget.currentWidget()
currency_tab.tab_history.table_history.model().sourceModel().refresh_transfers()
def open_certification_dialog(self):
dialog = CertificationDialog(self.app.current_account,
self.password_asker)
dialog.exec_()
def open_add_contact_dialog(self):
dialog = ConfigureContactDialog(self.app.current_account, self)
result = dialog.exec_()
if result == QDialog.Accepted:
self.window().refresh_contacts()
def open_configure_account_dialog(self):
dialog = ProcessConfigureAccount(self.app, self.app.current_account)
result = dialog.exec_()
if result == QDialog.Accepted:
if self.app.current_account:
self.action_change_account(self.app.current_account.name)
else:
self.refresh()
def open_preferences_dialog(self):
dialog = PreferencesDialog(self.app)
result = dialog.exec_()
def open_about_popup(self):
"""
Open about popup window
"""
aboutDialog = QDialog(self)
aboutUi = Ui_AboutPopup()
aboutUi.setupUi(aboutDialog)
latest = self.app.available_version
version_info = ""
version_url = ""
if not latest[0]:
version_info = self.tr("Latest release : {version}") \
.format(version=latest[1])
version_url = latest[2]
new_version_text = """
<p><b>{version_info}</b></p>
<p><a href="{version_url}">{link_text}</a></p>
""".format(version_info=version_info,
version_url=version_url,
link_text=self.tr("Download link"))
else:
new_version_text = ""
text = self.tr("""
<h1>Cutecoin</h1>
<p>Python/Qt uCoin client</p>
<p>Version : {:}</p>
{new_version_text}
<p>License : MIT</p>
<p><b>Authors</b></p>
<p>inso</p>
<p>vit</p>
<p>canercandan</p>
""").format(__version__, new_version_text=new_version_text)
aboutUi.label.setText(text)
aboutDialog.show()
@pyqtSlot()
def latest_version_requested(self):
latest = self.app.available_version
logging.debug("Latest version requested")
if not latest[0]:
version_info = self.tr("Please get the latest release {version}") \
.format(version=latest[1])
version_url = latest[2]
toast.display("Cutecoin", """<p>{version_info}</br>
<a href={version_url}>Download link</a></p>""".format(
version_info=version_info,
version_url=version_url))
def refresh_wallets(self):
currency_tab = self.currencies_tabwidget.currentWidget()
if currency_tab:
currency_tab.refresh_wallets()
def refresh_communities(self):
logging.debug("CLEAR")
self.currencies_tabwidget.clear()
if self.app.current_account:
for community in self.app.current_account.communities:
tab_currency = CurrencyTabWidget(self.app, community,
self.password_asker,
self.status_label)
tab_currency.refresh()
self.currencies_tabwidget.addTab(tab_currency,
QIcon(":/icons/currency_icon"),
community.name)
def refresh_accounts(self):
self.menu_change_account.clear()
signal_mapper = QSignalMapper(self)
for account_name in sorted(self.app.accounts.keys()):
action = QAction(account_name, self)
self.menu_change_account.addAction(action)
signal_mapper.setMapping(action, account_name)
action.triggered.connect(signal_mapper.map)
signal_mapper.mapped[str].connect(self.action_change_account)
def refresh_contacts(self):
self.menu_contacts_list.clear()
if self.app.current_account:
for index, contact in enumerate(self.app.current_account.contacts):
contact_menu = self.menu_contacts_list.addMenu(contact['name'])
edit_action = contact_menu.addAction(self.tr("Edit"))
edit_action.triggered.connect(self.edit_contact)
edit_action.setData(index)
delete_action = contact_menu.addAction(self.tr("Delete"))
delete_action.setData(contact)
delete_action.triggered.connect(self.delete_contact)
def refresh(self):
'''
Refresh main window
When the selected account changes, all the widgets
in the window have to be refreshed
'''
logging.debug("Refresh started")
self.refresh_accounts()
if self.app.current_account is None:
self.currencies_tabwidget.hide()
self.homescreen.show()
self.setWindowTitle(self.tr("CuteCoin {0}").format(__version__))
self.menu_account.setEnabled(False)
self.action_configure_parameters.setEnabled(False)
self.action_set_as_default.setEnabled(False)
self.combo_referential.setEnabled(False)
self.status_label.setText(self.tr(""))
self.password_asker = None
else:
logging.debug("Show currencies loading")
self.currencies_tabwidget.show()
logging.debug("Hide homescreen")
self.homescreen.hide()
self.password_asker = PasswordAskerDialog(self.app.current_account)
self.combo_referential.blockSignals(True)
self.combo_referential.clear()
for ref in self.app.current_account.referentials:
self.combo_referential.addItem(QCoreApplication.translate('Account', ref[4]))
self.combo_referential.setEnabled(True)
self.combo_referential.blockSignals(False)
logging.debug(self.app.preferences)
self.combo_referential.setCurrentIndex(self.app.preferences['ref'])
self.menu_account.setEnabled(True)
self.action_configure_parameters.setEnabled(True)
self.setWindowTitle(self.tr("CuteCoin {0} - Account : {1}").format(__version__,
self.app.current_account.name))
self.refresh_communities()
self.refresh_wallets()
self.refresh_contacts()
def import_account(self):
self.import_dialog = ImportAccountDialog(self.app, self)
self.import_dialog.accepted.connect(self.import_account_accepted)
self.import_dialog.exec_()
def import_account_accepted(self):
# open account after import
self.action_change_account(self.import_dialog.edit_name.text())
def export_account(self):
# Testable way of using a QFileDialog
self.export_dialog = QFileDialog(self)
self.export_dialog.setObjectName('ExportFileDialog')
self.export_dialog.setWindowTitle(self.tr("Export an account"))
self.export_dialog.setNameFilter(self.tr("All account files (*.acc)"))
self.export_dialog.setLabelText(QFileDialog.Accept, self.tr('Export'))
self.export_dialog.accepted.connect(self.export_account_accepted)
self.export_dialog.show()
def export_account_accepted(self):
selected_file = self.export_dialog.selectedFiles()
if selected_file:
if selected_file[0][-4:] == ".acc":
path = selected_file[0]
else:
path = selected_file[0] + ".acc"
self.app.export_account(path, self.app.current_account)
def closeEvent(self, event):
if self.app.current_account:
self.app.save_cache(self.app.current_account)
self.app.save_persons()
super().closeEvent(event)
def showEvent(self, event):
super().showEvent(event)
if not self.initialized:
# if default account in preferences...
if self.app.preferences['account'] != "":
logging.debug("Loading default account")
self.action_change_account(self.app.preferences['account'])
# no default account...
else:
# if at least one account exists, set it as default...
if len(self.app.accounts) > 0:
# capture names sorted alphabetically
names = list(self.app.accounts.keys())
names.sort()
# set first name in list as default in preferences
self.app.preferences['account'] = names[0]
self.app.save_preferences(self.app.preferences)
# open it
logging.debug("No default account in preferences. Set %s as default account." % names[0])
self.action_change_account(self.app.preferences['account'])
self.initialized = True
def _openFile(self, path=None, openFile=True, importFile=False):
if not path:
# formats
fileFormats = []
supportedFiles = ""
if openFile:
packageAsFile = platformSpecific.treatPackageAsFile()
if packageAsFile:
ufoFormat = "*.ufo"
tfExtFormat = "*.tfExt"
else:
ufoFormat = "metainfo.plist"
tfExtFormat = "info.plist"
fileFormats.extend([
self.tr("UFO Fonts {}").format("(%s)" % ufoFormat),
self.tr("TruFont Extension {}").format(
"(%s)" % tfExtFormat)
])
supportedFiles += "{} {} ".format(ufoFormat, tfExtFormat)
if importFile:
# TODO: systematize this
fileFormats.extend([
self.tr("OpenType Font file {}").format("(*.otf *.ttf)"),
self.tr("Type1 Font file {}").format("(*.pfa *.pfb)"),
self.tr("ttx Font file {}").format("(*.ttx)"),
self.tr("WOFF Font file {}").format("(*.woff)"),
])
supportedFiles += "*.otf *.pfa *.pfb *.ttf *.ttx *.woff"
fileFormats.extend([
self.tr("All supported files {}").format(
"(%s)" % supportedFiles.rstrip()),
self.tr("All files {}").format("(*.*)"),
])
# dialog
importKey = importFile and not openFile
state = settings.openFileDialogState(
) if not importKey else settings.importFileDialogState()
directory = None if state else QStandardPaths.standardLocations(
QStandardPaths.DocumentsLocation)[0]
title = self.tr(
"Open File") if openFile else self.tr("Import File")
dialog = QFileDialog(
self.activeWindow(), title, directory, ";;".join(fileFormats))
if state:
dialog.restoreState(state)
dialog.setAcceptMode(QFileDialog.AcceptOpen)
dialog.setFileMode(QFileDialog.ExistingFile)
dialog.setNameFilter(fileFormats[-2])
ret = dialog.exec_()
# save current directory
# TODO: should open w/o file chooser also update current dir?
state = dialog.saveState()
if importKey:
settings.setImportFileDialogState(directory)
else:
settings.setOpenFileDialogState(directory)
# cancelled?
if not ret:
return
path = dialog.selectedFiles()[0]
# sanitize
path = os.path.normpath(path)
if ".plist" in path:
path = os.path.dirname(path)
ext = os.path.splitext(path)[1]
if ext == ".ufo":
self._loadUFO(path)
elif ext == ".tfExt":
self._loadExt(path)
else:
self._loadBinary(path)
