def _connect(self, src): try: d = self._find_odbc_driver() if d is None: raise RuntimeError("Failed to find appropriate ODBC driver") self.cnxn = pyodbc.connect(driver='{' + d + '}', DBQ=src) except pyodbc.Error as error: raise _DatabaseServerError(error.__str__()) # Check images folder self.imgDir = QtCore.QDir(src) if not self.imgDir.cd('../../CoinImages'): directory = QFileDialog.getExistingDirectory( self.parent(), self.tr("Select directory with images"), OpenNumismat.HOME_PATH) if directory: self.imgDir = QtCore.QDir(directory) else: return False # Check predefined images folder self.defImgDir = QtCore.QDir(src) if not self.defImgDir.cd('../../Images'): directory = QFileDialog.getExistingDirectory( self.parent(), self.tr("Select directory with pre-defined images"), OpenNumismat.HOME_PATH) if directory: self.defImgDir = QtCore.QDir(directory) else: return False return self.cnxn.cursor()
def renamePage(self, item): oldAttDir = self.itemToAttachmentDir(item) parent = item.parent() parentPage = self.itemToPage(parent) parentPath = os.path.join(self.notePath, parentPage) dialog = LineEditDialog(parentPath, self) dialog.setText(item.text(0)) if dialog.exec_(): newPageName = dialog.editor.text() # if hasattr(item, 'text'): # if item is not QTreeWidget if parentPage != '': parentPage = parentPage + '/' oldFile = self.itemToFile(item) newFile = parentPage + newPageName + self.settings.fileExt QtCore.QDir(self.notePath).rename(oldFile, newFile) if item.childCount() != 0: oldDir = parentPage + item.text(0) newDir = parentPage + newPageName QtCore.QDir(self.notePath).rename(oldDir, newDir) item.setText(0, newPageName) self.sortItems(0, Qt.AscendingOrder) # if attachment folder exists, rename it if QtCore.QDir().exists(oldAttDir): newAttDir = self.itemToAttachmentDir(item) QtCore.QDir().rename(oldAttDir, newAttDir) self.parent.updateAttachmentView()
def _connect(self, src): try: self.cnxn = pyodbc.connect(driver='{Microsoft Access Driver (*.mdb)}', DBQ=src) except pyodbc.Error as error: raise _DatabaseServerError(error.__str__()) # Check images folder self.imgDir = QtCore.QDir(src) if not self.imgDir.cd('../../CoinImages'): directory = QFileDialog.getExistingDirectory(self.parent(), self.tr("Select directory with images"), OpenNumismat.HOME_PATH) if directory: self.imgDir = QtCore.QDir(directory) else: return False # Check predefined images folder self.defImgDir = QtCore.QDir(src) if not self.defImgDir.cd('../../Images'): directory = QFileDialog.getExistingDirectory(self.parent(), self.tr("Select directory with pre-defined images"), OpenNumismat.HOME_PATH) if directory: self.defImgDir = QtCore.QDir(directory) else: return False return self.cnxn.cursor()
def availableStyles(): # https://github.com/qt/qtquickcontrols2/blob/5.14/src/quickcontrols2/qquickstyle.cpp#L591 importPaths = [ QtCore.QLibraryInfo.location(QtCore.QLibraryInfo.Qml2ImportsPath), ":/qt-project.org/imports", QtCore.QCoreApplication.applicationDirPath(), DIR_PATH, ] path = os.environ.get("QT_QUICK_CONTROLS_STYLE_PATH", "") if path: importPaths.append(path) stylePaths = [] targetPath = "QtQuick/Controls.2" for importPath in importPaths: d = QtCore.QDir(importPath) if d.cd(targetPath): stylePaths.append(d.absolutePath()) styles = [] for path in stylePaths: entries = QtCore.QDir(path).entryInfoList( QtCore.QDir.Dirs | QtCore.QDir.NoDotAndDotDot ) for entry in entries: name = entry.fileName() if not name.endswith(".dSYM") and name != "designer": # print(path, name) styles.append(name) return list(set(styles))
def initialise(notebookName, notebookPath): """ Called by create() A notebook directory will be initialised to: css/ notebook.conf notes/ """ # QDir().mkpath will create all necessary parent directories QtCore.QDir().mkpath( os.path.join(notebookPath, "notes").replace(os.sep, '/')) QtCore.QDir().mkpath( os.path.join(notebookPath, "css").replace(os.sep, '/')) cssFile = os.path.join(notebookPath, "css", "notebook.css").replace(os.sep, '/') searchCssFile = os.path.join(notebookPath, "css", "search-window.css").replace(os.sep, '/') cssTemplate = "/usr/share/mikidown/notebook.css" searchCssTemplate = "/usr/share/mikidown/search-window.css" if not os.path.exists(cssTemplate): cssTemplate = os.path.join(os.path.dirname(__file__), "css", "sphinx.css").replace(os.sep, '/') if not os.path.exists(searchCssTemplate): searchCssTemplate = os.path.join(os.path.dirname(__file__), "css", "search-window.css").replace( os.sep, '/') # If //cssFile// already exists, copy() returns false! print(cssTemplate) print(searchCssTemplate) QtCore.QFile.copy(cssTemplate, cssFile) QtCore.QFile.copy(searchCssTemplate, searchCssFile)
def create_qp_clicked(self): # Checking to see if the values are valid if not (self.qp_path_line_edit.text()) or not (self.qp_filename_line_edit.text()): QtWidgets.QMessageBox.critical(self, 'Error Creating', 'The input fields are invalid', QtWidgets.QMessageBox.Ok) return if not (self.get_file_extension(self.qp_filename_line_edit.text()) == self.extension): self.qp_filename = self.qp_filename + self.extension self.setEnabled(False) # Creating a new instance of GeneratorMainWindow, after creating and loading the file if os.name == 'posix': self.new_file = QtCore.QDir(self.qp_path + '/' + self.qp_filename).path() elif os.name == 'nt': self.new_file = QtCore.QDir(self.qp_path + '\\' + self.qp_filename).path() print("Creating new qp file " + self.new_file) q_file = QtCore.QFile(self.new_file) if not q_file.open(QtCore.QFile.ReadWrite): QtWidgets.QMessageBox.critical(self, 'Error Creating', 'Unable to create the file !', QtWidgets.QMessageBox.Ok) return q_file.close() self.new_qp_full_path = self.new_file file = open(self.new_file, "w", encoding="utf-8") if self.extension == '.qp': json.dump(self.gv.default_qp_values, file) elif self.extension == '.qpd': json.dump(self.gv.default_qpd_values, file) file.close() self.done(1)
def insert(self, key, d): if isinstance(d, str): fileCache = self.AQ_DISKCACHE_DIRPATH + '/' + key fi = QtCore.QFile(fileCache) drc = QtCore.QDir(self.AQ_DISKCACHE_DIRPATH) if not drc.exists(): drc.mkdir(self.AQ_DISKCACHE_DIRPATH) elif fi.exists(): return True if d and d != "": if fi.open(self.IO_WriteOnly): t = QtCore.QTextStream(fi) t << d fi.close() return True return False else: fileCache = self.AQ_DISKCACHE_DIRPATH + '/' + key + "-BIN" fi = QtCore.QFile(fileCache) drc = QtCore.QDir(self.AQ_DISKCACHE_DIRPATH) if not drc.exists(): drc.mkdir(self.AQ_DISKCACHE_DIRPATH) elif fi.exists(): return True if not d.isEmpty(): if fi.open(self.IO_WriteOnly): dat = QtCore.QDataStream(fi) dat << d fi.close() return True return False
def initLogging(): home = QtCore.QDir(home_dir) config = QtCore.QDir(config_dir) if not config.exists(): home.mkpath(config_dir) config = { 'version': 1, 'root': { 'handlers': ['console'], 'level': 'DEBUG' }, 'disable_existing_loggers': False, 'formatters': { 'standard': { 'format': '%(asctime)s [%(levelname)s]: %(message)s' }, 'detailed': { 'format': '%(asctime)s %(module)-17s line:%(lineno)-4d %(levelname)-8s %(message)s' } }, 'handlers': { 'console': { 'level': 'DEBUG', 'class': 'logging.StreamHandler', 'stream': 'ext://sys.stdout', 'formatter': 'standard' }, } } logging.config.dictConfig(config)
def sanitizeShellLogsPath(self, filepath: str) -> str: """ Sanitize a shell log filepath to make sure it is in the appropriate folder. Args: filepath (str): The filepath to sanitize Returns: str: The sanitized path """ filepath = QtCore.QDir(filepath).dirName() return QtCore.QDir(self.shellLogsDir()).absoluteFilePath(filepath)
def sanitizeVulnerabilityPath(self, filepath: str) -> str: """ Sanitize a vulnerability filepath to make sure it is in the appropriate folder. Args: filepath (str): The filepath to sanitize Returns: str: The sanitized path """ filepath = QtCore.QDir(filepath).dirName() return QtCore.QDir(self.vulnsPath()).absoluteFilePath(filepath)
def sanitizeDownloadPath(self, filepath: str) -> str: """ Sanitize a download filepath to make sure it is in the appropriate folder. Args: filepath (str): The filepath to sanitize Returns: str: The sanitized path """ filepath = QtCore.QDir(filepath).dirName() return QtCore.QDir(self.downloadsPath()).absoluteFilePath(filepath)
def __init__(self, parent=None, pathMode=0): QtWidgets.QDialog.__init__(self, parent) uic.loadUi('{}/dbselect.ui'.format(os.path.dirname(utils.__file__)), self) self.customDbFilePath = QtCore.QFileInfo(QtCore.QDir(QtCore.QStandardPaths.standardLocations(QtCore.QStandardPaths.HomeLocation)[0]).filePath('ship.sqlite')) self.tempDbFilePath = QtCore.QFileInfo(QtCore.QDir(QtCore.QStandardPaths.standardLocations(QtCore.QStandardPaths.TempLocation)[0]).filePath('ship.sqlite')) self.existingDbFilePath = QtCore.QFileInfo() self.dbPathCombo.currentIndexChanged.connect(self.updateDbPath) self.dbBrowseFunc = self.dbBrowseCustomPath self.dbBrowseBtn.clicked.connect(lambda: self.dbBrowseFunc()) self.OkBtn = self.buttonBox.button(self.buttonBox.Ok) self.dbPathCombo.setCurrentIndex(pathMode) self.state = self.dbError self.updateDbPath(pathMode)
def restoreDataBase(self) : home = QtCore.QDir(home_dir) config = QtCore.QDir(config_dir) database = QtCore.QFile(database_file) confirmation = QtWidgets.QMessageBox.question(self, self.tr("Remplacer la base ?"), self.tr("La base des ingrédients actuelle va être effacée et remplacée par la base originale. Toutes vos modifications vont être effacées. Un redémarrage de l'application sera nécessaire.<br> Continuer ?"), QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No) if (confirmation == QtWidgets.QMessageBox.Yes): database.remove(database_file) database.copy(database_root, database_file) else : pass
def icon(self, icontype_or_qfileinfo): """Reimplement Qt method""" if isinstance(icontype_or_qfileinfo, QtWidgets.QFileIconProvider.IconType): return super(IconProvider, self).icon(icontype_or_qfileinfo) else: qfileinfo = icontype_or_qfileinfo fname = os.path.normpath(qfileinfo.absoluteFilePath()) if os.path.isdir(fname): dir = QtCore.QDir(fname) dirList = dir.entryList(QtCore.QDir.Files) if "__init__.py" in dirList: icon = QtGui.QIcon( os.path.join("Resources", "images", "box")) else: icon = QtGui.QIcon( os.path.join("Resources", "images", "folder-horizontal")) return icon else: if os.path.basename(fname) == "__init__.py": return QtGui.QIcon(os.path.join("Resources", "images", "haiku-wide")) ext = os.path.splitext(fname)[1][1:] if ext == "py" or ext == "pyw": return QtGui.QIcon(os.path.join("Resources", "images", "gear")) else: return super(IconProvider, self).icon(qfileinfo)
def _update(self): data = self.data if not data: return try: keep = data['keep'] except KeyError: pass else: if keep: if keep == 'CLEAR': self.cache = [] elif data[keep]: self.cache += data[keep] # print('xxxxx', self.cache) try: tmplt = self.templateCache[data['ID']] except KeyError: try: tmplt = TEMPLATES[data['template']]() except KeyError: print('Error: {} template missing'.format(data['template'])) return else: self.templateCache[data['ID']] = tmplt #tmplt = defaultTemplate # url = QtCore.QUrl.fromLocalFile(self.fileBase) url = QtCore.QUrl.fromLocalFile(QtCore.QDir(self.fileBase).absoluteFilePath('dummy.html')) # QtWebKit.QWebSettings.clearMemoryCaches() #QtWebEngineCore.QWebSettings.clearMemoryCaches() #scrollValue = self.page().scrollPosition() self.setHtml(tmplt(data, self.cache[:], self.fileBase, self.width()), url)
def initTree(self, notePath, parent): ''' When there exist foo.md, foo.mkd, foo.markdown, only one item will be shown in notesTree. ''' if not QtCore.QDir(notePath).exists(): return notebookDir = QtCore.QDir(notePath) notesList = notebookDir.entryInfoList(['*.md', '*.mkd', '*.markdown'], QtCore.QDir.NoFilter, QtCore.QDir.Name|QtCore.QDir.IgnoreCase) nl = [note.completeBaseName() for note in notesList] noduplicate = list(set(nl)) for name in noduplicate: item = QtWidgets.QTreeWidgetItem(parent, [name]) path = notePath + '/' + name self.initTree(path, item)
def enum(root: str, database: str = 'info.md') -> [str]: """ List all the directories in `root` that have the `database` file. Args: root (str): The folder in which to search for vulnerabilities database (str): The name of the database file that defines a vulnerability as such (default 'info.md') Returns: [str]: An array of the found vulnerabilities """ root = QtCore.QDir(root) if root.exists(): dirList = root.entryInfoList(QtCore.QDir.Dirs | QtCore.QDir.NoDotAndDotDot) return [d.absoluteFilePath() for d in dirList if QtCore.QDir(d.absoluteFilePath()).exists(database)] return []
def initContentsWidget(self): folder = QtCore.QDir(CONFIG_DIR) folder.setFilter(QtCore.QDir.AllDirs) # Loop inside the categories in the config tree for folderName in folder.entryInfoList(): # Condider only category names of al laast three characters if len(folderName.fileName()) > 2: current_dir = os.path.join(CONFIG_DIR, unicode(folderName.fileName())) # Bear in mind that self.contentsWidget is a docked list item # configButton is an item in that list configButton = QtWidgets.QListWidgetItem(self.contentsWidget) configButton.setIcon( QtGui.QIcon(os.path.join(current_dir, FOLDER_ICON))) configButton.setText(self.getSectionTitle(current_dir)) #configButton.setText(folderName.fileName()) configButton.setTextAlignment(QtCore.Qt.AlignLeft) # Align center vertically (Didier) configButton.setTextAlignment(QtCore.Qt.AlignVCenter) configButton.setData(QtCore.Qt.UserRole, QtCore.QVariant(folderName.fileName())) configButton.setFont( QtGui.QFont("DejaVu Sans", 11, QtGui.QFont.Bold))
def __init__(self, parent=None): QtWidgets.QWidget.__init__(self, parent) mainLayout = QtWidgets.QHBoxLayout() mainLayout.setContentsMargins(0, 0, 0, 0) self.setLayout(mainLayout) self.destinationLine = QtWidgets.QLineEdit() self.destinationLine.textChanged.connect(self.textChanged.emit) mainLayout.addWidget(self.destinationLine) homePath = QtCore.QDir().homePath() # Todo: Workspace must unpack to the platform specific home # directory by default if sys.platform == 'win32': path = os.path.join(homePath, "My Documents", "PyCoderProjects") elif sys.platform == 'darwin': path = os.path.join(homePath, "Documents", "PyCoderProjects") else: path = os.path.join(homePath, "Projects", "PyCoderProjects") path = os.path.normpath(path) self.destinationLine.setText(path) self.browseButton = QtWidgets.QPushButton('...') self.browseButton.clicked.connect(self.browsePath) mainLayout.addWidget(self.browseButton)
def handleDirectoryChangedSlot( self, _s_directory ): self.ui.directoryListWidget.clear() self.s_currentDirectory = os.path.normpath( os.path.abspath( str(_s_directory) ) ) self.ui.urlLineEdit.setText( self.s_currentDirectory ) o_qdir = QtCore.QDir( self.s_currentDirectory ) # Mise a jour liste des repertoires #--------------------------------------------------------------- o_qdir.setFilter( QtCore.QDir.Dirs ) t_dirList = o_qdir.entryList() if len(t_dirList) > 0: self.ui.directoryListWidget.setEnabled(True) self.ui.directoryListWidget.addItems( t_dirList ) o_qFileIconProvider = QtWidgets.QFileIconProvider() for o_item in self.iterAllDirectories(): o_item.setIcon( o_qFileIconProvider.icon( QtCore.QFileInfo(o_qdir, o_item.text()) ) ) else: self.ui.directoryListWidget.setEnabled(False) # Mise a jour de la liste de tous les fichiers (hors filtre) contenu # dans le repertoire courant #--------------------------------------------------------------- o_qdir.setFilter( QtCore.QDir.Files | QtCore.QDir.NoDotAndDotDot ) self.t_allFilesInCurrentDirectory = o_qdir.entryList() self.updateFileListWidget()
def refresh(self): self.listWidget.clear() if self.lineEdit.text() == "": QtWidgets.QMessageBox.warning( self.listWidget, "Warning!", "The directory entry should not be empty!\nPlease enter a valid directory address!" ) return address = QtCore.QDir(self.lineEdit.text()) if (address.exists() == False): QtWidgets.QMessageBox.warning( self.listWidget, "Warning!", "There is no such directory!\nPlease enter a valid directory address!" ) return filters = [] filters.append("*.txt") filters.append("*.docx") filters.append("*.doc") for item in address.entryList(filters, sort=QtCore.QDir.Name): listItem = QtWidgets.QListWidgetItem(item) if item.startswith("(c)"): listItem.setCheckState(2) listItem.setBackground(QtGui.QBrush( QtGui.QColor("lightgreen"))) else: listItem.setCheckState(0) listItem.setBackground(QtGui.QBrush(QtGui.QColor("pink"))) self.listWidget.addItem(listItem)
def update_file_menu(self): """Add a new saved directory into the File menu list. """ self.file_menu.clear() self.add_actions(self.file_menu, self.file_menu_actions[:self.file_menu_offset]) current = self.save_directory if self.save_directory is not None else None recent_directories = [] if current is not None: self.file_menu.addAction(QtWidgets.QAction("Current:", self)) self.file_menu.addAction(QtWidgets.QAction(str(current), self)) self.file_menu.addSeparator() if self.recent_directories is not None: for rdir in self.recent_directories: if rdir != current and QtCore.QDir.exists(QtCore.QDir(rdir)): recent_directories.append(rdir) if len(recent_directories) != 0: self.file_menu.addSeparator() self.file_menu.addAction(QtWidgets.QAction("Recent:", self)) for i, rdir in enumerate(recent_directories): action = QtWidgets.QAction("&{} {}".format(i + 1, rdir), self) action.setData(QtCore.QVariant(rdir)) action.triggered.connect(self.set_internal_save_directory) self.file_menu.addAction(action) else: self.recent_directories = [] self.file_menu.addSeparator() self.add_actions(self.file_menu, self.file_menu_actions[self.file_menu_offset:])
def defaultDir(): # Search for default default dir in default location on disk dir_ = QtCore.QDir(OpenNumismat.HOME_PATH) dirNames = [ "CoinManage/Data", "CoinManage UK/Data", "CoinManage Canada/Data" ] for dirName in dirNames: if dir_.cd(dirName): break # Search for default dir in windows registry subkeys = ['CoinManage', 'CoinManage UK', 'CoinManage Canada'] for key in [ r'Software\Liberty Street Software\%s' % subkey for subkey in subkeys ]: try: hkey = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key) value = winreg.QueryValueEx(hkey, 'DataDirectory')[0] winreg.CloseKey(hkey) if dir_.cd(value): break except (WindowsError, NameError): continue return dir_.absolutePath()
def _copyDir(self, src, dst, dir_name, model): curr_dir = QtCore.QDir(src) #Object of current source dir filters = QtCore.QDir.NoDotAndDotDot | QtCore.QDir.Dirs | QtCore.QDir.Files curr_dir.setFilter(filters) files_list = curr_dir.entryList() #List of source dir content dst_directory = dst + '\\' + dir_name curr_dir.mkpath(dst_directory) #Mkdir in destination folder for fileN in files_list: #Loop through all content to find directories path = src + '\\' + fileN insideFile_ind = model.index(path) #Grabbing index of inner file if model.isDir( insideFile_ind): #Check if file of this index is dir files_list.remove(fileN) #Removing dirs from list self._copyDir(path, dst_directory, model.fileName(insideFile_ind), model) #RECURSION file = QtCore.QFile() for fileN in files_list: #Creating copies of files from 'src' in directory inside of 'destination directory' path = src + '\\' + fileN file.copy(path, dst_directory + '\\' + fileN)
def __init__(self, caller=None, trial_params=None, locations=None): # noinspection PyUnresolvedReferences flags_ = QtCore.Qt.WindowFlags() super(TrialDialog, self).__init__(flags=flags_) self.ui = Ui_TrialDialog() self.ui.setupUi(self) self.ui.objectComboBox.currentIndexChanged.connect( self.update_object_change) if caller: self.ui.addTrialButton.clicked.connect(caller.add_trial) self.ui.skipTrialButton.clicked.connect(caller.skip_trial) if locations: self.ui.location1ComboBox.addItems(locations) self.ui.location2ComboBox.addItems(locations) self.locations = locations else: raise ValueError("missing argument locations") # object codes are derived by the filenames of the images in the resource file d = QtCore.QDir(':/obj_images') l = d.entryList() self.obj_idxs = [int(s[:-4]) for s in l] self.obj_idxs.sort() str_obj_idxs = [str(i) for i in self.obj_idxs] self.ui.objectComboBox.addItems(str_obj_idxs) self.set_values(trial_params) self.set_image() self.setWindowTitle("Next Trial")
def fileInput_button_click(self): absolute_path=QtWidgets.QFileDialog.getOpenFileName(self, 'Open file') if absolute_path: cur_path=QtCore.QDir('.') relative_path=cur_path.relativeFilePath(str(absolute_path[0])) self.right_fileinput.setText(absolute_path[0]) with open(filename,'w') as f_obj: json.dump(absolute_path[0],f_obj)
def getDefaults(self): dataDir = QtCore.QDir(QtCore.QStandardPaths.standardLocations(QtCore.QStandardPaths.AppDataLocation)[0]) rootpath = os.path.join(os.getcwd()) #defaultDbFile = QtCore.QFileInfo(dataDir.filePath('ship.sqlite')) defaultDbFilepath = rootpath + '/ship.sqlite' defaultDbFile = QtCore.QFileInfo(defaultDbFilepath) #print("defaultDbFilePath:",defaultDbFilepath) return dataDir, defaultDbFile
def recursiveAddPath(filePath): """ recursively add files and directories to watcher """ watcher.addPath(filePath) fileList = QtCore.QDir( filePath).entryInfoList(QtCore.QDir.Dirs | QtCore.QDir.Files | QtCore.QDir.NoDotAndDotDot) for f in fileList: recursiveAddPath(f.absoluteFilePath())
def __init__(self): super(ApplicationWindow, self).__init__() self.setAttribute(QtCore.Qt.WA_DeleteOnClose, True) self.ui = Ui_MainWindow() self.ui.setupUi(self) self._translate = self.ui.retranslateUi(self) self.ui.tabWidget.clear() self.model = QFileSystemModel() self.model.setRootPath(QtCore.QDir().rootPath()) # self.model.setFilter(QtCore.QDir().AllDirs|QtCore.QDir().NoDot) self.model.setNameFilters(filters) source = self.model.index(QtCore.QDir().homePath()) self.proxyModel = QtCore.QSortFilterProxyModel(self) self.proxyModel.setSourceModel(self.model) self.proxyModel.setDynamicSortFilter(True) index = self.proxyModel.mapFromSource(source) self.ui.treeView.setModel(self.model) self.ui.treeView.setRootIndex(source) # self.ui.treeView.setModel(self.proxyModel) # self.ui.treeView.setRootIndex(index) # self.ui.treeView.setRootIndex(self.model.index(user_home())) # self.ui.treeView.setModel(self.proxyModel) # self.ui.treeView.setRootIndex(self.proxyModel) [self.ui.treeView.setColumnHidden(cols, True) for cols in range(1, 4)] self.ui.treeView.doubleClicked.connect(self.onClick) self.ui.treeView.setContextMenuPolicy(QtCore.Qt.CustomContextMenu) self.ui.treeView.customContextMenuRequested.connect( self.create_popup_menu) self.ui.filedirsearch.textChanged.connect(self.textFilter) self.ui.actionOpenProject.triggered.connect(self.openProjDialog) self.ui.actionOpenFile.triggered.connect(self.openFileDialog) self.ui.actionAbout_Qt.triggered.connect(self.aboutQt) self.ui.actionQuit.triggered.connect(self.close) self.ui.action_Save.triggered.connect(self.save) self.ui.tabWidget.tabCloseRequested.connect(self.removeTab) self.textFilter()
def newShellLogFilename(self) -> str: """ Create a new filename to store shell logs Returns: str: A filename based on current timestamps """ filename = f'Shell_{QtCore.QDateTime.currentMSecsSinceEpoch()}.txt' return QtCore.QDir(self.shellLogsDir()).absoluteFilePath(filename)