def handlebuttonbrowse(self): dlg = QFileDialog() dlg.setFileMode(QFileDialog.AnyFile) dlg.setAcceptMode(QFileDialog.AcceptSave) dlg.setLabelText(QFileDialog.Accept, "Save comparison") dlg.setDefaultSuffix(self.expected_extension.strip('.')) inputfilename = self.settings.get_object('inputfilename') dirname = os.path.dirname(inputfilename) suggested_filename = os.path.splitext( os.path.basename(inputfilename))[0] + self.expected_extension dlg.setDirectory(dirname) dlg.selectFile(suggested_filename) filternames = [ "%s files (*%s)" % (ext.strip('.'), ext) for ext in [self.expected_extension] ] filternames += ["all files (*)"] dlg.setNameFilters(filternames) if dlg.exec_(): self.outputfilename = str(dlg.selectedFiles()[0]) self.settings.register('outputfilename', self) self.outputfile.setText(shorten_path(self.outputfilename)) if self.outputfilename: self.compare() self.issaved = True print('Complete!') self.buttonshow.setEnabled(True)
def exportContours(self): """Export defined contours.""" itab = self.itabs.currentIndex() ic0 = self.ici[itab] ih0 = self.ihi[itab] if ic0.contour is not None: if ic0.title in ['Flux', 'Coverage map', 'Flux [no atm. corr.]']: source = self.specCube.instrument else: source = ic0.title info = [('source', source), ('levels', ih0.levels)] data = OrderedDict(info) # Open a dialog fd = QFileDialog() fd.setLabelText(QFileDialog.Accept, "Export as") fd.setNameFilters(["Json Files (*.json)", "All Files (*)"]) fd.setOptions(QFileDialog.DontUseNativeDialog) fd.setViewMode(QFileDialog.List) if (fd.exec()): filenames = fd.selectedFiles() filename = filenames[0] if filename[-5:] != '.json': filename += '.json' print("Exporting contour levels to file: ", filename) with io.open(filename, mode='w') as f: str_ = json.dumps(data, indent=2, separators=(',', ': '), ensure_ascii=False, cls=MyEncoder) f.write(str_) self.sb.showMessage("Aperture exported in file " + filename, 3000) else: return
def download(self): if not empty(self.subtitle.url): if self.subtitle.url.endswith('.rar'): ext = '.rar' elif self.subtitle.url.endswith('.srt'): ext = '.srt' else: ext = '.zip' fileDial = QFileDialog(self, 'Save "%s" subtitle file' % self.subtitle.name, '%s%s' % (self.subtitle.name, ext), 'all files (*)') fileDial.setAcceptMode(QFileDialog.AcceptSave) fileDial.setLabelText(QFileDialog.Accept, 'Save subtitle file') fileDial.setLabelText(QFileDialog.FileName, 'Subtitle file name') ok = (fileDial.exec_() == 1) if not ok: return result = fileDial.selectedFiles() if len(result) > 0: dest = result[0] data = self.backend.get_subtitle_file(self.subtitle.id) try: with open(dest, 'w') as f: f.write(data) except IOError as e: print('Unable to write subtitle file in "%s": %s' % (dest, e), file=self.stderr) return 1 return
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 saveRotatedFits(self, name_orig): """ Save the downloaded FITS image """ filename, file_extension = os.path.splitext(name_orig) #fileroot = os.path.basename(filename) #print('file root is ', fileroot) print('Saving ',filename+'_NE.fits') # Dialog to save file fd = QFileDialog() fd.setLabelText(QFileDialog.Accept, "Save as") fd.setNameFilters(["Fits Files (*.fits)","All Files (*)"]) fd.setOptions(QFileDialog.DontUseNativeDialog) fd.setViewMode(QFileDialog.List) fd.selectFile(filename+'_NE.fits') if (fd.exec()): fileName = fd.selectedFiles() outfile = fileName[0] filename, file_extension = os.path.splitext(outfile) # basename = os.path.basename(filename) # Primary header image = self.data wcs = self.wcs header = wcs.to_header() header.remove('WCSAXES') header['INSTRUME'] = (self.source, 'Instrument') hdu = fits.PrimaryHDU(image) hdu.header.extend(header) hdul = fits.HDUList([hdu]) hdul.writeto(outfile,overwrite=True) # clobber true allows rewriting hdul.close()
def writeSct(sctPars, sctfile): """ Write a *.sct file from a dictionary. """ fd = QFileDialog(None, "Save updated .sct file") fd.setLabelText(QFileDialog.Accept, "Export as") fd.setNameFilters(["Scan description (*.sct)", "All Files (*)"]) fd.setOptions(QFileDialog.DontUseNativeDialog) fd.setViewMode(QFileDialog.List) fd.selectFile(sctfile) if fd.exec(): #fd.getSaveFileName(directory=sctfile) filenames = fd.selectedFiles() filename = filenames[0] if filename[-4:] != '.sct': filename += '.sct' print("Exporting scan description to file: ", filename) with io.open(filename, mode='w') as f: for key in sctPars.keys(): if sctPars[key] != "": #print(sctPars[key]) f.write("{0:25s} #{1:s}\n".format(sctPars[key], key.upper())) print('File ' + filename + ' exported.') msg = "File " + filename + ' exported.\n' else: msg = 'Updated .sct file not saved.\n' return msg
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 openLocalCube(self): """ Open local spectral cube.""" # Open a dialog fd = QFileDialog() fd.setLabelText(QFileDialog.Accept, "Import") fd.setNameFilters(["Fits Files (*.fits)", "All Files (*)"]) fd.setOptions(QFileDialog.DontUseNativeDialog) fd.setViewMode(QFileDialog.List) fd.setFileMode(QFileDialog.ExistingFile) if (fd.exec()): filenames = fd.selectedFiles() cube_file = filenames[0] print("File selected is: ", filenames[0]) try: print('opening ', cube_file) self.data = specCube(cube_file) self.wcs = self.data.wcs # Check if coordinates are inside the image x, y = self.wcs.wcs_world2pix(self.lon, self.lat, 0) print('x y ', x, y) if x >= 0 and x <= self.data.nx and y >= 0 and y <= self.data.ny: print('Source inside the FITS cube') else: self.data = None self.wcs = None print('The selected FITS is not a valid file') except: self.data = None self.wcs = None print('The selected FITS is not a valid file')
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 showOpenFile(self): dlg = QFileDialog(self) dlg.setWindowTitle(self.tr("Open Video Files")) dlg.setWindowModality(Qt.WindowModal) mimeFilters = [ "video/mp4", "video/quicktime", "video/x-msvideo", "video/x-ms-wmv" ] globPatterns = [] db = QMimeDatabase() for m in mimeFilters: mimeType = db.mimeTypeForName(m) if not mimeType.isValid(): logger.warn("Invalid MIME type: {}".format(m)) continue globPatterns.extend(mimeType.globPatterns()) globText = ' '.join(globPatterns) logger.debug("Video glob patterns: {}".format(globText)) dlg.setNameFilters([ self.tr("Video Files ({})").format(globText), self.tr("All Files (*)") ]) dlg.setAcceptMode(QFileDialog.AcceptOpen) dlg.setOption(QFileDialog.ReadOnly, True) dlg.setOption(QFileDialog.DontUseCustomDirectoryIcons, True) dlg.setLabelText(QFileDialog.Accept, self.tr("Open Movie")) dlg.setFileMode(QFileDialog.ExistingFiles) if dlg.exec_(): filenames = dlg.selectedFiles() self.processVideoFiles(filenames)
def export(self): fileDial = QFileDialog( self, 'Export "%s" recipe' % self.recipe.title, '%s.kreml' % self.recipe.title.replace('/', ','), 'Krecipe file (*.kreml);;all files (*)') fileDial.setAcceptMode(QFileDialog.AcceptSave) fileDial.setLabelText(QFileDialog.Accept, 'Export recipe') fileDial.setLabelText(QFileDialog.FileName, 'Recipe file name') ok = (fileDial.exec_() == 1) if not ok: return result = fileDial.selectedFiles() if len(result) > 0: dest = result[0] if not dest.endswith('.kreml'): dest += '.kreml' data = self.recipe.toKrecipesXml(author=self.backend.name) try: with codecs.open(dest, 'w', 'utf-8') as f: f.write(data) except IOError as e: print('Unable to write Krecipe file in "%s": %s' % (dest, e), file=self.stderr) return 1 return
def readMap(filename=None): """ Import alternate map file. """ if filename is None: fd = QFileDialog(None, "Load map file") fd.setLabelText(QFileDialog.Accept, "Import") fd.setNameFilters(["Map Files (*.txt)", "All Files (*)"]) fd.setOptions(QFileDialog.DontUseNativeDialog) fd.setViewMode(QFileDialog.List) fd.setFileMode(QFileDialog.ExistingFile) if fd.exec(): fileNames = fd.selectedFiles() filename = fileNames[0] else: pass numlines = sum(1 for line in open(filename)) if numlines < 2: print('Map file is empty.') return else: print('Map has ', numlines, ' lines.') # read the first line - target coords in HH:MM:SS.SS, DD:MM:SS.SS file = open(filename) line = file.readline() if len(line.split()) != 6: print('File is not a map file.') return file.close() mapListPath = filename numMapPoints = numlines - 1 return numMapPoints, mapListPath
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 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 export_account(self): # Testable way of using a QFileDialog export_dialog = QFileDialog(self.widget) 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 showDlg_path(self): dir_path = ".." dlg_files = QFileDialog() dlg_files.setFileMode(QFileDialog.Directory) dlg_files.setLabelText(QFileDialog.LookIn, 'Открыть каталог с демультиплексированными файлами ...') dlg_files.setAcceptMode(QFileDialog.AcceptOpen) dlg_files.setDirectory(dir_path) dlg_files.setOption(QFileDialog.ShowDirsOnly) if dlg_files.exec_(): self.fnames = dlg_files.selectedFiles() self.lbl_path.setText(self.fnames[0]) self.btn_start.setEnabled(True)
def selectFile(self, label): fd = QFileDialog() fd.setWindowTitle('Open ' + label + ' File') fd.setLabelText(QFileDialog.Accept, "Select " + label) fd.setNameFilters(["Fits Files (*.fit* *.FIT*)"]) fd.setOptions(QFileDialog.DontUseNativeDialog) fd.setViewMode(QFileDialog.List) if (fd.exec()): fileNames = fd.selectedFiles() return fileNames[0] else: return None print("No file selected")
def show_dlg_path(self): index = self.btn_open_files.index(self.sender()) dir_path = '..' dlg_files = QFileDialog() dlg_files.setFileMode(QFileDialog.AnyFile) dlg_files.setLabelText(QFileDialog.LookIn, 'Выберите файл ТМП ...') dlg_files.setAcceptMode(QFileDialog.AcceptOpen) dlg_files.setDirectory(dir_path) if dlg_files.exec_(): dir_, self.fnames[index] = os.path.split( dlg_files.selectedFiles()[0]) self.lbl_path[index].setText(self.fnames[index]) self.fpath[index] = dlg_files.selectedFiles()[0] self.update_set_graph()
def openLocalCube(self): """ Open local spectral cube.""" # Open a dialog fd = QFileDialog() fd.setLabelText(QFileDialog.Accept, "Import") fd.setNameFilters([ "Fits Files (*.fit*)", "WXY fits files (*WXY*.fits*)", "All Files (*)" ]) fd.setOptions(QFileDialog.DontUseNativeDialog) fd.setViewMode(QFileDialog.List) fd.setFileMode(QFileDialog.ExistingFile) if (fd.exec()): filenames = fd.selectedFiles() cube_file = filenames[0] print("File selected is: ", filenames[0]) try: print('opening ', cube_file) try: self.data = specCube(cube_file) except: self.data = specCubeAstro(cube_file) self.wcs = self.data.wcs newpixel = self.data.pixscale pixel = self.pixscale ratio = (pixel / newpixel)**2 print('area ratio: ', ratio) self.data.flux *= ratio # Check if coordinates are inside the image # This should be modified to check if the cube is inside the axes #x, y = self.wcs.wcs_world2pix(self.lon, self.lat, 0) #print('x y ', x, y) #if x >= 0 and x <= self.data.nx and y >= 0 and y <= self.data.ny: # print('Source inside the FITS cube') # # At this point the fluxes are rescaled to the pixel size # # of the original cube # newpixel = self.data.pixscale # pixel = self.specCube.pixscale # ratio = (newpixel/pixel)**2 # self.data.flux *= ratio #else: # self.data = None # self.wcs = None # print('The selected FITS is not a valid file') except: self.data = None self.wcs = None print('The selected FITS is not a valid file')
def get_save_file_name(initial_name: str, wav_only=False, caption="Save signal", selected_name_filter=None): global RECENT_PATH if caption == "Save signal": name_filter = "Complex (*.complex);;" \ "Complex16 unsigned (*.complex16u *.cu8);;" \ "Complex16 signed (*.complex16s *.cs8);;" \ "Complex32 unsigned (*.complex32u *.cu16);;" \ "Complex32 signed (*.complex32s *.cs16);;" \ "Complex compressed (*.coco);;" \ "WAV (*.wav);;" \ "All Files (*)" if wav_only: name_filter = "WAV (*.wav);;All Files (*)" elif caption == "Save fuzz profile": name_filter = "Fuzzing Profile (*.fuzz.xml *.fuzz);;All Files (*)" elif caption == "Save encoding": name_filter = "" elif caption == "Save simulator profile": name_filter = "Simulator (*.sim.xml *.sim);;All Files (*)" elif caption == "Export spectrogram": name_filter = "Frequency Time (*.ft);;Frequency Time Amplitude (*.fta)" else: name_filter = "Protocols (*.proto.xml *.proto);;Binary Protocol (*.bin);;All Files (*)" filename = None dialog = QFileDialog(directory=RECENT_PATH, caption=caption, filter=name_filter) dialog.setFileMode(QFileDialog.AnyFile) dialog.setViewMode(QFileDialog.Detail) dialog.setLabelText(QFileDialog.Accept, "Save") dialog.setAcceptMode(QFileDialog.AcceptSave) if selected_name_filter is not None: dialog.selectNameFilter(selected_name_filter) dialog.selectFile(initial_name) if dialog.exec(): filename = dialog.selectedFiles()[0] if filename: RECENT_PATH = os.path.split(filename)[0] return filename
def saveAllCsv(self): """Save data for all currently plotted lines""" #Harsha: Plots were saved in GUI folder instead provided QFileDialog box to save to #user choose fileDialog2 = QFileDialog(self) fileDialog2.setFileMode(QFileDialog.Directory) fileDialog2.setWindowTitle('Select Directory to save plots') fileDialog2.setOptions(QFileDialog.ShowDirsOnly) fileDialog2.setLabelText(QFileDialog.Accept, self.tr("Save")) targetPanel = QFrame(fileDialog2) targetPanel.setLayout(QVBoxLayout()) layout = fileDialog2.layout() layout.addWidget(targetPanel) if fileDialog2.exec_(): directory = fileDialog2.directory().path() for line in list(self.lineToDataSource.keys()): self.saveCsv(line, directory)
def importContours(self): """Import defined contours.""" # Open a dialog fd = QFileDialog() fd.setLabelText(QFileDialog.Accept, "Import") fd.setNameFilters(["Json Files (*.json)", "All Files (*)"]) fd.setOptions(QFileDialog.DontUseNativeDialog) fd.setViewMode(QFileDialog.List) fd.setFileMode(QFileDialog.ExistingFile) if (fd.exec()): filenames = fd.selectedFiles() print("Loading contour levels from file: ", filenames[0]) with open(filenames[0], 'r') as f: data = json.load(f) if self.contours == 'on': self.removeContours() self.drawContours(data['levels']) self.contours = 'on'
def browseLogFile(self): dialog = QFileDialog(self) #logFile = dialog.getSaveFileName(self, "Select log file", # DATADIR, "log file (*.log)") dialog.setLabelText(QFileDialog.Accept, "Select") dialog.setWindowTitle("Select path and enter name for log file") if dialog.exec(): logFile = dialog.selectedFiles() logFileFinal = logFile[0] if logFile == '': return if ("." not in logFile[0]): logFileFinal = logFile[0] + ".log" else: return self.ui.logfileEdit.setText(logFileFinal)
def loadTemplate(self): """Load a sct file.""" fd = QFileDialog(None, "Load Scan Template") fd.setLabelText(QFileDialog.Accept, "Import") fd.setDirectory(self.sctpath) fd.setNameFilters(["Scan Template (*.sct)", "All Files (*)"]) fd.setOptions(QFileDialog.DontUseNativeDialog) fd.setViewMode(QFileDialog.List) fd.setFileMode(QFileDialog.ExistingFile) if fd.exec(): fileName = fd.selectedFiles() sctfile = fileName[0] self.title = 'Observation maker for FIFI-LS [' + sctfile + ']' self.setWindowTitle(self.title) # Default settings self.TW.setDefaults() # Load template and update table widget self.TW.update_status('Loading ' + sctfile + "\n") self.TW.sctfile = sctfile self.aorParameters = readSct(sctfile) # self.TW.update_status(errmsg) self.TW.update_gui(self.aorParameters) self.sctpath = os.path.dirname(os.path.abspath(sctfile)) # self.TW.sctdir.setText(sctpath) Initiliaze with path of read file mapfile = os.path.basename(self.TW.mapListPath) self.TW.pathFile = self.sctpath self.TW.mapListPath = os.path.join(self.sctpath, mapfile) mapfile = self.TW.mapListPath print('mapfile ', mapfile) self.TW.update_status("mapfile: " + mapfile + "\n") if len(mapfile) > 0: try: noMapPoints, mapListPath = readMap(mapfile) print('map path ', mapListPath) self.TW.mapListPath = mapListPath self.TW.noMapPoints.setText(str(noMapPoints)) print('map loaded') # self.TW.update_status("Map loaded. \n") except: print('Invalid map file.') # First build print('First build ') self.TW.buildObs()
def ask_save_file_name(initial_name: str, caption="Save signal", selected_name_filter=None): global RECENT_PATH if caption == "Save signal": name_filter = __get__name_filter_for_signals() elif caption == "Save fuzzing profile": name_filter = FUZZING_FILE_FILTER elif caption == "Save encoding": name_filter = "" elif caption == "Save simulator profile": name_filter = SIMULATOR_FILE_FILTER elif caption == "Export spectrogram": name_filter = "Frequency Time (*.ft);;Frequency Time Amplitude (*.fta)" elif caption == "Save protocol": name_filter = ";;".join( [PROTOCOL_FILE_FILTER, BINARY_PROTOCOL_FILE_FILTER]) elif caption == "Export demodulated": name_filter = WAV_FILE_FILTER else: name_filter = EVERYTHING_FILE_FILTER filename = None dialog = QFileDialog(directory=RECENT_PATH, caption=caption, filter=name_filter) dialog.setFileMode(QFileDialog.AnyFile) dialog.setLabelText(QFileDialog.Accept, "Save") dialog.setAcceptMode(QFileDialog.AcceptSave) if selected_name_filter is not None: dialog.selectNameFilter(selected_name_filter) dialog.selectFile(initial_name) if dialog.exec(): filename = dialog.selectedFiles()[0] if filename: RECENT_PATH = os.path.split(filename)[0] return filename
def download(self): fileDial = QFileDialog(self, 'Save "%s" torrent file' % self.torrent.name, '%s.torrent' % self.torrent.name, 'Torrent file (*.torrent);;all files (*)') fileDial.setAcceptMode(QFileDialog.AcceptSave) fileDial.setLabelText(QFileDialog.Accept, 'Save torrent file') fileDial.setLabelText(QFileDialog.FileName, 'Torrent file name') ok = (fileDial.exec_() == 1) if not ok: return result = fileDial.selectedFiles() if len(result) > 0: dest = result[0] data = self.backend.get_torrent_file(self.torrent.id) try: with open(unicode(dest), 'w') as f: f.write(data) except IOError as e: print('Unable to write .torrent in "%s": %s' % (dest, e), file=self.stderr) return 1 return
def instalar_biblioteca(self): caminho_bibliotecas = os.path.join(get_caminho_padrao(), "bibliotecas") dialogo = QFileDialog() dialogo.setWindowTitle("Escolher biblioteca") dialogo.setLabelText(QFileDialog.FileName, "Arquivo:") dialogo.setLabelText(QFileDialog.LookIn, "Buscar em:") dialogo.setLabelText(QFileDialog.FileType, "Tipo de arquivo:") dialogo.setLabelText(QFileDialog.Accept, "Escolher") dialogo.setLabelText(QFileDialog.Reject, "Cancelar") dialogo.setFileMode(QFileDialog.DirectoryOnly) dialogo.setDirectory(get_caminho_padrao()) if dialogo.exec_() == QFileDialog.Accepted: caminho = dialogo.selectedUrls()[0].path() if (caminho.startswith("/") and os.name == 'nt'): caminho = caminho[1:] # Testa se o arquivo existe if os.path.exists(caminho): try: shutil.copytree( caminho, os.path.join(caminho_bibliotecas, os.path.basename(caminho))) # Directories are the same except shutil.Error as e: print('Directory not copied. Error: %s' % e) # Any error saying that the directory doesn't exist except OSError as e: print('Directory not copied. Error: %s' % e) else: QMessageBox(QMessageBox.Warning, "Erro", "O arquivo não existe", QMessageBox.NoButton, self).show() else: return
def export(self): fileDial = QFileDialog(self, u'Export "%s" recipe' % self.recipe.title, u'%s.kreml' % self.recipe.id, 'Krecipe file (*.kreml);;all files (*)') fileDial.setAcceptMode(QFileDialog.AcceptSave) fileDial.setLabelText(QFileDialog.Accept, 'Export recipe') fileDial.setLabelText(QFileDialog.FileName, 'Recipe file name') ok = (fileDial.exec_() == 1) if not ok: return result = fileDial.selectedFiles() if len(result) > 0: dest = result[0] if not dest.endswith('.kreml'): dest += '.kreml' data = recipe_to_krecipes_xml(self.recipe, author=self.backend.name) try: with codecs.open(dest, 'w', 'utf-8') as f: f.write(data) except IOError as e: print(u'Unable to write Krecipe file in "%s": %s' % (dest, e), file=self.stderr) return 1 return
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 *.cu8);;Complex16 files (2 signed int8) (*.complex16s *.cs8);;" \ "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.xml *.fuzz);;All files (*)" elif caption == "Save encoding": name_filter = "" elif caption == "Save simulator profile": name_filter = "Simulator (*.sim.xml *.sim);;All files (*)" elif caption == "Export spectrogram": name_filter = "Frequency Time (*.ft);;Frequency Time Amplitude (*.fta)" else: name_filter = "Protocols (*.proto.xml *.proto);;Binary Protocol (*.bin);;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 get_save_file_name(initial_name: str, wav_only=False, caption="Save signal"): global RECENT_PATH if caption == "Save signal": name_filter = "Complex (*.complex);;" \ "Complex16 unsigned (*.complex16u *.cu8);;" \ "Complex16 signed (*.complex16s *.cs8);;" \ "Complex compressed (*.coco);;" \ "WAV (*.wav);;" \ "All Files (*)" if wav_only: name_filter = "WAV Files (*.wav);;All Files (*)" elif caption == "Save fuzz profile": name_filter = "Fuzzing Profile (*.fuzz.xml *.fuzz);;All Files (*)" elif caption == "Save encoding": name_filter = "" elif caption == "Save simulator profile": name_filter = "Simulator (*.sim.xml *.sim);;All Files (*)" elif caption == "Export spectrogram": name_filter = "Frequency Time (*.ft);;Frequency Time Amplitude (*.fta)" else: name_filter = "Protocols (*.proto.xml *.proto);;Binary Protocol (*.bin);;All Files (*)" filename = None dialog = QFileDialog(directory=RECENT_PATH, caption=caption, filter=name_filter) dialog.setFileMode(QFileDialog.AnyFile) dialog.setViewMode(QFileDialog.Detail) dialog.setLabelText(QFileDialog.Accept, "Save") 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 show_dlg_path(self): dir_path = '..' dlg_files = QFileDialog() dlg_files.setFileMode(QFileDialog.AnyFile) dlg_files.setLabelText(QFileDialog.LookIn, 'Открыть файл канала режимов ...') dlg_files.setAcceptMode(QFileDialog.AcceptOpen) dlg_files.setDirectory(dir_path) if dlg_files.exec_(): self.table_cycl.clear() self.table_cycl.setRowCount(0) self.table_cycl.setColumnCount(3) self.table_cycl.setHorizontalHeaderLabels(["№", "Время", "Характеристика"]) self.fname = dlg_files.selectedFiles()[0] self.lbl_path.setText(self.fname) if self.thread is not None: self.thread.disconnect() self.thread = None self.num_order = self.get_numord() self.setStatusTip('Идет обработка...') self.thread = CyclogrModeThread(self.fname, self.num_order, self.grafik) self.thread.s_error[str].connect(self.showDlgErr) self.thread.finished.connect(self.finished_cyclogr_mode_thread) self.thread.s_mode.connect(self.update_table) self.thread.start()
def criar_dialogo_arquivo(titulo, acao): """ Cria dialogo personalizado para buscar arquivos :param titulo: Titulo de aba :param acao: Texto do botao de selecionar :return dialogo: dialogo """ dialogo = QFileDialog() dialogo.setWindowTitle(titulo) dialogo.setLabelText(QFileDialog.FileName, "Arquivo:") dialogo.setLabelText(QFileDialog.LookIn, "Buscar em:") dialogo.setLabelText(QFileDialog.FileType, "Tipo de arquivo:") dialogo.setLabelText(QFileDialog.Accept, acao) dialogo.setLabelText(QFileDialog.Reject, "Cancelar") dialogo.setNameFilters(["Rascunhos Br.ino (*.brpp)", "Rascunhos Arduino (*.ino)"]) dialogo.selectNameFilter("Rascunhos Br.ino (*.brpp)") dialogo.setDirectory(get_caminho_padrao()) return dialogo
def _get_files() -> list: # setup settings dialog = QFileDialog(parent=parent, caption=lang['ADD_NEW']['caption'], filter=lang['ADD_NEW']['filter'], directory=sys.path[0]) dialog.setAcceptMode(QFileDialog.AcceptOpen) dialog.setFileMode(QFileDialog.ExistingFiles) dialog.setWindowIcon(QIcon(ZIP)) # setup labels dialog.setLabelText(QFileDialog.FileName, lang['ADD_NEW']['names']) dialog.setLabelText(QFileDialog.FileType, lang['ADD_NEW']['types']) dialog.setLabelText(QFileDialog.Accept, lang['ADD_NEW']['open']) dialog.setLabelText(QFileDialog.Reject, lang['ADD_NEW']['cancel']) # show dialog.show() if dialog.exec() == QFileDialog.Accepted: return dialog.selectedFiles() else: return []
class TermEditor(QWidget): signal_term_was_changed = pyqtSignal(Term) signal_stopped_editing_new_term = pyqtSignal(Term) # Undo, redo signal_can_undo = pyqtSignal(bool) signal_can_redo = pyqtSignal(bool) signal_undo_event = pyqtSignal() signal_redo_event = pyqtSignal() # sent when term links have been changed: add_links_to_term = pyqtSignal(Term, list) remove_links_from_term = pyqtSignal(Term, list) signal_current_term_is_valid = pyqtSignal(bool) def __init__(self, parent=None): super().__init__(parent) self._redo_text_edit = False self._undo_text_edit = False self.ui = Ui_TermEditor() self.ui.setupUi(self) # This is used for detecting if the term content has changed: self._old_term = Term() # Dialogs: self.term_chooser = StrChooser(self) self.term_remover = StrChooser(self) self.file_chooser = QFileDialog() self.file_remover = StrChooser(self) self.file_remover.set_title("Unlinkable files") self.term_chooser.set_title("Linkable terms") self.term_remover.set_title("Unlinkable terms") self.file_chooser.setLabelText(QFileDialog.Accept, "Link") self.file_chooser.setWindowTitle("Choose files to link.") # We add term linker at the botom of this widget: self.term_linker = TermLinker() self.ui.verticalLayout.addWidget(self.term_linker) self._init_actions() self.ui.lineEditTitle.text = "" self._current_term = Term() self._current_term_has_changed = False # Hook into undo/redo of term_editor self.eventFilter = KeyPressEater(QKeySequence.Undo, self) self.eventFilter2 = KeyPressEater(QKeySequence.Redo, self) self.ui.textEditContent.installEventFilter(self.eventFilter) self.ui.textEditContent.installEventFilter(self.eventFilter2) self.ui.lineEditTitle.installEventFilter(self.eventFilter) self.ui.lineEditTitle.installEventFilter(self.eventFilter2) self._init_term_linker() self._init_signals() def set_term(self, term: Term): """ Sets the current term to be edited. :param term: Term to edit """ self.clear() self._current_term = copy.copy(term) self._check_undo_redo() self._old_term = term if self._old_term.term is "": logging.debug("new term") self.signal_current_term_is_valid.emit(False) self.term_linker.term_linking_enabled(False) self.ui.lineEditTitle.setFocus() else: logging.debug("old term") self.term_linker.update_links(term) self.term_linker.term_linking_enabled(True) self.ui.lineEditTitle.setText(term.term) self.ui.textEditContent.setText(term.description) self.ui.textEditContent.setFocus() def show(self): """ Hooks in to the super class show method and enables file linking and unlinking actions when term editor is shown. """ self.act_link_files.setEnabled(True) self.act_unlink_files.setEnabled(True) super().show() def hide(self): """ When term editor is hidden the changes need to be saved. In other words this is the place, that updates the content of a term or sends a new term to the TermController. A new term object is always emitted when editing a new term stops and the term has non empty term string (Term.term). If we are editing already existing term, term editor sets a _current_term_has_changed to True if the content, term string or linked things have changed. Signal signal_term_was_changed(Term) is emitted if the term has changed. Also the undo-redo history of the editing session is forgotten and the undo is set to the version of the term that existed before the start of the editing session. Before hiding term editing related actions are enabled (undo, redo, linking/unlinking of files and linking/unlinking of terms). """ if self._old_term.term is "" and \ self.ui.lineEditTitle.displayText() is not "": self._current_term = self._fill_term(self._current_term) self.signal_stopped_editing_new_term.emit(self._current_term) self.clear() else: self._increment_term_version() if self._current_term_has_changed: self._old_term.next_term = self._current_term self._current_term.next_term = None self.signal_term_was_changed.emit(self._current_term) self.clear() self.act_undo.setEnabled(False) self.act_redo.setEnabled(False) self.act_link_files.setEnabled(False) self.act_unlink_files.setEnabled(False) self.term_linker.term_linking_enabled(False) super().hide() def _increment_term_version(self, force: bool=False): """ This creates a new Term object of current term, if the content of the term (eg. term string or description of the term) have changed or if the increment is forced. :param force: increments version anyway if True :return: True if the version was incremented. """ if (self.ui.lineEditTitle.displayText() != self._old_term.term or self.ui.textEditContent.toPlainText() != self._old_term.description or force): self._current_term.initialize_next_term() self._current_term = self._current_term.next_term self._fill_term(self._current_term) self._current_term_has_changed = True return True return False def clear(self): """ This method clears all the text in term editor, linked things in term_linker and set's _current_term to an empty Term object. """ self.ui.lineEditTitle.clear() self.ui.textEditContent.clear() self.term_linker.clear() self._current_term = Term() self._old_term = Term() self._current_term_has_changed = False def _fill_term(self, term: Term): """ This method read the content of Term.term input field and Term.description editor to a Term object. :param term: Term to fill :return: filled term """ logging.debug("Filling the term") term.term = self.ui.lineEditTitle.displayText() text = self.ui.textEditContent.toPlainText() white_space_removed = list() for line in text.splitlines(): white_space_removed.append(line.rstrip()) term.description = os.linesep.join(white_space_removed) return term def _trigger_event(self, sequence: QKeySequence): """ This is triggered when KeyPressEater filter has caught undo or redo key combination on term line editor or term description editor and delegates the undo/redo action to this class's undo/redo methods. :param sequence: captured key combination as QKeySequence """ if sequence is QKeySequence.Undo: self.undo() if sequence is QKeySequence.Redo: self.redo() @pyqtSlot() def _validate_term(self): """ This slot checks the validity of the filled term on term editor e.g. it ensures that the filled value for Term.term is not "". If Term is valid signal_current_term_is_valid(True) is emitted and if it's not signal_current_term_is_valid(False) is emitted. """ if self.ui.lineEditTitle.displayText() is "": self.signal_current_term_is_valid.emit(False) else: self.signal_current_term_is_valid.emit(True) ######## # TAGS # ######## @pyqtSlot(str, str) def _add_tag(self, item_str: str, group_name: str): """ This is triggered when an item in term linker is activated. We set in _init_term_linker method the different item groups for the term linker. So we can add the appropriate tag based on the group name we have given. """ if group_name == "Image": self.add_image_tag( self._current_term.get_non_project_file_path(item_str)) @pyqtSlot() def add_image_tag(self, path: Path=Path("/path/to/image"), str_title: str="Image title"): """ This adds an image tag to term description editor at the current position of the caret. :param path: Optional parameter. Path to the image to show. :param str_title: Caption for the image. """ self.ui.textEditContent.insertPlainText('#img("' + str(path) + '","' + str_title + '")') @pyqtSlot() def add_title_tag(self, str_title: str="Title"): """ This adds an title tag to term description editor at the current position of the caret. :param str_title: text for title. """ self.ui.textEditContent.insertPlainText( "##" + str_title + "##" + os.linesep + os.linesep) @pyqtSlot() def add_bullet_list_tag(self): """ Add Bullet list tag to editor """ self.ui.textEditContent.insertPlainText( os.linesep + "##LIST##" + os.linesep + "item1" + os.linesep + "item2" + os.linesep + "item3" + os.linesep + "##END##" + os.linesep ) @pyqtSlot() def add_ASCII_tag(self): """ Add ASCII tag to editor """ self.ui.textEditContent.insertPlainText( os.linesep + "##ASCII##" + os.linesep + "+---+" + os.linesep + "| |" + os.linesep + "+---+" + os.linesep + "##END##" + os.linesep ) ############################## # LINKING OF TERMS AND FILES # ############################## @pyqtSlot() def link_terms(self): """ A slot that invokes linking of terms to current term. When raised term_chooser dialog (StrChooser) is accepted execution continues from _link_terms_accepted method. """ a_list = self.parent().term_str_browser.get_list() black_list = [] if self._current_term.term: black_list.append(self._current_term.term) if self._current_term.related_terms: for term_str in self._current_term.related_terms: black_list.append(term_str) [a_list.remove(item) for item in black_list] self.term_chooser.set_list(a_list) self.term_chooser.show() @pyqtSlot(list) def _link_terms_accepted(self, str_list): """ Links terms given as a list of strings to current term. When list of terms to add is given the linking is delegated by emitting add_links_to_term(Term, str_list of terms) signal. When terms have been linked the list of linked things is updated by invoking term_linker.update_links(current_term). :param str_list: list of terms as a string to link """ if len(str_list) > 0: self._increment_term_version(True) self.add_links_to_term.emit(self._current_term, str_list) self.term_linker.update_links(self._current_term) @pyqtSlot() def unlink_terms(self): """ A slot that invokes unlinking of terms from current term. When raised term_remover dialog (StrChooser) is accepted execution continues from _unlink_terms_accepted method. """ self.term_remover.set_list(self._current_term.related_terms) self.term_remover.show() @pyqtSlot(list) def _unlink_terms_accepted(self, str_list): """ Unlinks terms given as a list of strings to current term. When list of terms to remove is given the unlinking is delegated by emitting remove_links_from_term(Term, str_list of terms) signal. When terms have been un linked the list of linked things is updated by invoking term_linker.update_links(current_term). :param str_list: list of terms as a string to link """ if len(str_list) > 0: self._increment_term_version(True) self.remove_links_from_term.emit(self._current_term, str_list) self.term_linker.update_links(self._current_term) @pyqtSlot() def unlink_files(self): """ A slot that invokes unlinking of files from current term. When raised file_remover dialog (StrChooser) is accepted execution continues from _unlink_files_accepted method. """ all_files = list() [all_files.append(file.name) for file in self._current_term.linked_files] [all_files.append(image.name) for image in self._current_term.linked_images] self.file_remover.set_list(all_files) self.file_remover.show() @pyqtSlot(list) def _unlink_files_accepted(self, str_list): """ Unlinks files given as a list of strings containing the filename from current term. When files have been removed the list of linked things is updated by invoking term_linker.update_links(current_term). :param str_list: list of file names as a string to unlink. """ logging.debug("Unlink files accepted with: " + str(str_list)) if len(str_list) > 0: self._increment_term_version(True) for str_file in str_list: self._current_term.unlink_file(Path(str_file)) self.term_linker.update_links(self._current_term) @pyqtSlot() def link_files(self): """ A slot that invoke linking of files to current term. After the files have been linked to current term the term_linker is updated by invoking term_linker.update_links(current_term) method. """ file_names = self.file_chooser.getOpenFileNames( self, "Select a file", '', "All Files (*)", '') if file_names is not None and file_names[0] is not None: self._increment_term_version(True) for file_name in file_names[0]: self._current_term.link_file(Path(file_name)) self.term_linker.update_links(self._current_term) #################################### # UNDO - REDO and COPY, CUT, PASTE # #################################### @pyqtSlot() def _copy(self): """ This slot routes copying to right widget when copy action is invoked (when copy is chosen from main window menu). """ if self.ui.textEditContent.hasFocus(): self.ui.textEditContent.copy() if self.ui.lineEditTitle.hasFocus(): self.ui.lineEditTitle.copy() @pyqtSlot() def _paste(self): """ This slot routes paste to right widget when paste action is invoked (when paste is chosen from main window menu). """ if self.ui.textEditContent.hasFocus(): self.ui.textEditContent.paste() if self.ui.lineEditTitle.hasFocus(): self.ui.lineEditTitle.paste() @pyqtSlot() def _cut(self): """ This slot routes cut to right widget when cut action is invoked (when cut is chosen from main window menu). """ if self.ui.textEditContent.hasFocus(): self.ui.textEditContent.cut() if self.ui.lineEditTitle.hasFocus(): self.ui.lineEditTitle.cut() @pyqtSlot() def undo(self): """ Undoes edit. If undo is available in text editor for term content, it is undone. If undo is not available in text editor for content it is checked if the title field for Term.term has undo available. If it has, term title edits are undone. When term field runs out of undoes it is checked if the term it self has older version linked to it. When we run out of undo for current term signal_can_undo(False) is emitted. """ if self._undo_text_edit: self.ui.textEditContent.undo() elif self.ui.lineEditTitle.isUndoAvailable(): self.ui.lineEditTitle.undo() elif not self._current_term or not self._current_term.can_undo: self.act_undo.setEnabled(False) else: self.set_term(self._current_term.previous_term) self.check_if_can_undo() @pyqtSlot() def redo(self): """ Redoes undone edit. If redo is available in term title field for term, it is redone. If redo is not available in term title field for Term.term, it is checked if the term text editor for term content has redo available. If it has, content edits are redone. When term text editor runs out of redoes it is checked if the term it self has newer version linked to it. When we run out of redo for current term signal_can_redo(False) is emitted. """ if self.ui.lineEditTitle.isRedoAvailable(): self.ui.lineEditTitle.redo() elif self._redo_text_edit: self.ui.textEditContent.redo() elif not self._current_term or not self._current_term.can_redo: self.act_redo.setEnabled(False) else: self.set_term(self._current_term.next_term) self.check_if_can_redo() @pyqtSlot(bool) def _redo_available_in_text_edit(self, boolean): """ This slot is triggered from term content editor when it runs out of redo (boolean=False) or becomes able to redo (boolean=True). :param boolean: True if textEditContent can redo, False if can't. """ self._redo_text_edit = boolean self.check_if_can_redo() @pyqtSlot(bool) def _undo_available_in_text_edit(self, boolean): """ This slot is triggered from term content editor when it runs out of undo (boolean=False) or becomes able to undo (boolean=True). :param boolean: True if textEditContent can undo, False if can't. """ self._undo_text_edit = boolean self.check_if_can_undo() @pyqtSlot() def _check_undo_redo(self): """ This is a helper method to check if there are undoes and redoes left. """ self.check_if_can_undo() self.check_if_can_redo() def check_if_can_undo(self): """ If term text editor or term title line edit can undo undo (action act_undo) is enabled. if they can't undo it is checked if the current term is None and if so undo action is disabled. If current term is not None the term is queried if undo is available and the boolean value for the query is set for action undo availability. """ if self._undo_text_edit or self.ui.lineEditTitle.isUndoAvailable(): self.act_undo.setEnabled(True) else: self.act_undo.setEnabled(self._current_term.can_undo) def check_if_can_redo(self): """ If term text editor or term title line edit can redo action act_redo for redo is enabled. if they can't redo it is checked if the current term is None and if so the redo action is disabled. If current term is not None the term is queried if redo is available and the boolean value for the query set as the value of availability of redo. """ if self._redo_text_edit or self.ui.lineEditTitle.isRedoAvailable(): self.act_redo.setEnabled(True) else: self.act_redo.setEnabled(self._current_term.can_redo) ########################## # INITIALIZATION METHODS # ########################## def _init_actions(self): # Edit self.act_copy = make_action_helper( self, "Copy", "Copy to clipboard", QKeySequence.Copy, QIcon.fromTheme('edit-copy')) self.act_copy.triggered.connect(self._copy) self.act_paste = make_action_helper( self, "Paste", "Paste from clipboard", QKeySequence.Paste, QIcon.fromTheme('edit-paste')) self.act_paste.triggered.connect(self._paste) self.act_cut = make_action_helper( self, "Cut", "Cut to clipboard", QKeySequence.Cut, QIcon.fromTheme('edit-cut')) self.act_cut.triggered.connect(self._cut) self.act_undo = make_action_helper( self, "Undo", "Undo previous change", QKeySequence.Undo, QIcon.fromTheme('edit-undo')) self.act_undo.triggered.connect(self.undo) self.act_redo = make_action_helper( self, "Redo", "Redo undone change", QKeySequence.Redo, QIcon.fromTheme('edit-redo')) self.act_redo.triggered.connect(self.redo) # Linking of files self.act_link_files = make_action_helper( self, "Link &files", "Link files to current term", "ctrl+l", QIcon.fromTheme('list-add')) self.act_link_files.triggered.connect(self.link_files) self.act_unlink_files = make_action_helper( self, "U&nlink files", "Unlink files from current term", "ctrl+u", QIcon.fromTheme('list-remove')) self.act_unlink_files.triggered.connect(self.unlink_files) def _init_term_linker(self): self.term_linker.ui_link_list.add_item_group("Term", "Yellow", "Black") self.term_linker.ui_link_list.add_item_group("Image", "Cyan", "Black") self.term_linker.ui_link_list.add_item_group( "File", "Magenta", "Black") def _init_signals(self): # Editing self.ui.addImageToolButton.clicked.connect(self.add_image_tag) self.ui.addTitleToolButton.clicked.connect(self.add_title_tag) self.ui.addASCIIToolButton.clicked.connect(self.add_ASCII_tag) self.ui.addBulletListToolButton.clicked.connect( self.add_bullet_list_tag) self.ui.lineEditTitle.textChanged.connect(self._validate_term) self.ui.lineEditTitle.textChanged.connect(self._check_undo_redo) self.ui.textEditContent.textChanged.connect(self._check_undo_redo) self.ui.textEditContent.redoAvailable.connect( self._redo_available_in_text_edit) self.ui.textEditContent.undoAvailable.connect( self._undo_available_in_text_edit) # Linking of terms self.term_linker.linkTermsClicked.connect(self.link_terms) self.term_linker.unlinkTermsClicked.connect(self.unlink_terms) self.term_chooser.str_list_accepted.connect(self._link_terms_accepted) self.term_remover.str_list_accepted.connect( self._unlink_terms_accepted) # Linking of files self.term_linker.add_file.connect(self.link_files) self.term_linker.remove_files.connect(self.unlink_files) self.file_remover.str_list_accepted.connect( self._unlink_files_accepted) self.term_linker.ui_link_list.signal_item_activated.connect( self._add_tag)
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
class Dialog(): def __init__(self, mainform): self.__mainform = mainform self.__dialog = QFileDialog() self.__directory = '' self.__filename = ['', '', ''] self.__filters = [] self.__default_filter_index = 0 self.__path = '' @property def path(self): return self.__path @property def filename(self): return self.__filename @property def directory(self): return self.__directory @directory.setter def directory(self, value): self.__directory = value @property def filters(self): return self.__filters @filters.setter def filters(self, value): self.__filters = value @property def default_filter_index(self): return self.__default_filter_index @default_filter_index.setter def default_filter_index(self, value): self.__default_filter_index = value def exec(self, load =True): self.__dialog.setNameFilters(self.__filters) self.__dialog.selectNameFilter(self.__filters[self.__default_filter_index]) self.__dialog.setDirectory(self.__directory) if load == True: self.__dialog.setLabelText(QFileDialog.Accept, 'Yes') self.__dialog.setWindowTitle('Yes') else: self.__dialog.setLabelText(QFileDialog.Accept, 'Save as') self.__dialog.setWindowTitle('Save as') if self.__dialog.exec() == QDialog.Accepted: self.__path = self.__dialog.selectedFiles()[0] fn = os.path.split(self.__path) ex = os.path.splitext(self.__path)[1] self.__filename = [fn[0], fn[1], ex[1:len(ex)]] print(self.__filename) print(os.pathsep)