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)
