class DockFolders(QDockWidget, Ui_dock_folders):
def __init__(self, parent):
QDockWidget.__init__(self, parent=parent)
self.setupUi(self)
self.mw = parent
#
self.ed_path.setText(self.mw.cfg.value("root_path", defaultValue=QDir.homePath()))
self.setupDirModel()
self.tree.clicked.connect(self.onDirClicked)
# self.btn_selectdir.clicked.connect(self.onButtonSelectDir)
self.ed_path.returnPressed.connect(self.setupDirModel)
def setupDirModel(self):
""" Show folders on tree view """
path = self.ed_path.text()
self.dirModel = QFileSystemModel()
self.dirModel.setRootPath(path)
self.dirModel.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
self.tree.setModel(self.dirModel)
self.tree.setRootIndex(self.dirModel.index(path))
self.tree.hideColumn(1)
self.tree.hideColumn(2)
self.tree.hideColumn(3)
self.tree.resizeColumnToContents(0)
def onDirClicked(self, index):
path = self.dirModel.fileInfo(index).absoluteFilePath()
self.mw.loadAlbum(path)
class E5DirCompleter(QCompleter):
"""
Class implementing a completer for directory names.
"""
def __init__(self, parent=None, completionMode=QCompleter.PopupCompletion, showHidden=False):
"""
Constructor
@param parent parent widget of the completer (QWidget)
@keyparam completionMode completion mode of the
completer (QCompleter.CompletionMode)
@keyparam showHidden flag indicating to show hidden entries as well
(boolean)
"""
super(E5DirCompleter, self).__init__(parent)
self.__model = QFileSystemModel(self)
if showHidden:
self.__model.setFilter(QDir.Filters(QDir.Drives | QDir.AllDirs | QDir.Hidden))
else:
self.__model.setFilter(QDir.Filters(QDir.Drives | QDir.AllDirs))
self.setModel(self.__model)
self.setCompletionMode(completionMode)
if isWindowsPlatform():
self.setCaseSensitivity(Qt.CaseInsensitive)
if parent:
parent.setCompleter(self)
class PangoFileWidget(PangoDockWidget):
def __init__(self, title, parent=None):
super().__init__(title, parent)
self.setFixedWidth(160)
self.file_model = QFileSystemModel()
self.file_model.setFilter(QDir.Files | QDir.NoDotAndDotDot)
self.file_model.setNameFilters(["*.jpg", "*.png"])
self.file_model.setNameFilterDisables(False)
self.th_provider = ThumbnailProvider()
self.file_model.setIconProvider(self.th_provider)
self.file_view = QListView()
self.file_view.setModel(self.file_model)
self.file_view.setViewMode(QListView.IconMode)
self.file_view.setFlow(QListView.LeftToRight)
self.file_view.setIconSize(QSize(150, 150))
self.setWidget(self.file_view)
def select_next_image(self):
c_idx = self.file_view.currentIndex()
idx = c_idx.siblingAtRow(c_idx.row()+1)
if idx.row() != -1:
self.file_view.setCurrentIndex(idx)
def select_prev_image(self):
c_idx = self.file_view.currentIndex()
idx = c_idx.siblingAtRow(c_idx.row()-1)
if idx.row() != -1:
self.file_view.setCurrentIndex(idx)
def createDockWindows(self):
dock = QDockWidget("Folders", self)
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
#Code to Create FileView Colums and FolderTree
self.FileView = QtWidgets.QColumnView()
self.FileView.setGeometry(QtCore.QRect(240, 10, 291, 281))
self.FolderTree = QtWidgets.QTreeView()
self.FolderTree.setGeometry(QtCore.QRect(10, 10, 221, 281))
FolderTree = self.FolderTree
#FolderTree.hidecolumn(1),... ?? to show only name column
#include FolderTree to a Dock at the left side
dock.setWidget(FolderTree)
self.addDockWidget(Qt.LeftDockWidgetArea, dock)
#set the model and rootpath for filling the FolderTree from self.ui
dirmodel = QFileSystemModel()
#set filter to show only folders
dirmodel.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)
dirmodel.setRootPath(rootpath)
#filemodel and filter for only files on right side
filemodel = QFileSystemModel()
filemodel.setFilter(QDir.NoDotAndDotDot | QDir.Files)
filemodel.setRootPath(rootpath)
FolderView = self.FolderTree
FolderView.setModel(dirmodel)
FolderView.setRootIndex(dirmodel.index(rootpath))
FileView = self.FileView
FileView.setModel(filemodel)
dock = QDockWidget("Files", self)
dock.setWidget(FileView)
self.addDockWidget(Qt.RightDockWidgetArea, dock)
#important lines for the connection, which does not work
self.FolderTree.clicked['QModelIndex'].connect(self.setpathonclick)
def __init__(self, *args, **kwargs):
super(DirTreeView, self).__init__(*args, **kwargs)
mdl = QFileSystemModel(parent=self)
mdl.setFilter(QDir.AllDirs | QDir.Drives | QDir.Hidden
| QDir.NoDotAndDotDot)
self.setModel(mdl)
class FileChooser(QWidget):
fileOpened = pyqtSignal(str)
def __init__(self, parent=None):
super().__init__(parent)
self.folderBox = QComboBox(self)
self.explorerTree = FileTreeView(self)
self.explorerTree.doubleClickCallback = self._fileOpened
self.explorerModel = QFileSystemModel(self)
self.explorerModel.setFilter(
QDir.AllDirs | QDir.Files | QDir.NoDotAndDotDot)
self.explorerModel.setNameFilters(["*.py"])
self.explorerModel.setNameFilterDisables(False)
self.explorerTree.setModel(self.explorerModel)
for index in range(1, self.explorerModel.columnCount()):
self.explorerTree.hideColumn(index)
self.setCurrentFolder()
self.folderBox.currentIndexChanged[int].connect(
self.updateCurrentFolder)
layout = QVBoxLayout(self)
layout.addWidget(self.folderBox)
layout.addWidget(self.explorerTree)
layout.setContentsMargins(5, 5, 0, 0)
def _fileOpened(self, modelIndex):
path = self.explorerModel.filePath(modelIndex)
if os.path.isfile(path):
self.fileOpened.emit(path)
def currentFolder(self):
return self.explorerModel.rootPath()
def setCurrentFolder(self, path=None):
if path is None:
app = QApplication.instance()
path = app.getScriptsDirectory()
else:
assert os.path.isdir(path)
self.explorerModel.setRootPath(path)
self.explorerTree.setRootIndex(self.explorerModel.index(path))
self.folderBox.blockSignals(True)
self.folderBox.clear()
style = self.style()
dirIcon = style.standardIcon(style.SP_DirIcon)
self.folderBox.addItem(dirIcon, os.path.basename(path))
self.folderBox.insertSeparator(1)
self.folderBox.addItem(self.tr("Browse…"))
self.folderBox.setCurrentIndex(0)
self.folderBox.blockSignals(False)
def updateCurrentFolder(self, index):
if index < self.folderBox.count() - 1:
return
path = QFileDialog.getExistingDirectory(
self, self.tr("Choose Directory"), self.currentFolder(),
QFileDialog.ShowDirsOnly)
if path:
QSettings().setValue("scripting/path", path)
self.setCurrentFolder(path)
class MyGridFilesWidget(QWidget):
def __init__(self, parent):
super(QWidget, self).__init__(parent)
start_dir = QStringListModel()
start_dir = 'C:/ROBOCZY'
self.model = QFileSystemModel()
self.model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot
| QDir.AllEntries)
self.model.setNameFilters()
self.model.setNameFilterDisables(0)
#self.model.setRootPath(start_dir)
#self.model.setRootPath(start_dir)
self.tree = QTreeView()
self.tree.setRootIndex(self.model.index(start_dir))
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
class E5DirCompleter(QCompleter):
"""
Class implementing a completer for directory names.
"""
def __init__(self, parent=None,
completionMode=QCompleter.PopupCompletion,
showHidden=False):
"""
Constructor
@param parent parent widget of the completer (QWidget)
@keyparam completionMode completion mode of the
completer (QCompleter.CompletionMode)
@keyparam showHidden flag indicating to show hidden entries as well
(boolean)
"""
super(E5DirCompleter, self).__init__(parent)
self.__model = QFileSystemModel(self)
if showHidden:
self.__model.setFilter(
QDir.Filters(QDir.Drives | QDir.AllDirs | QDir.Hidden))
else:
self.__model.setFilter(
QDir.Filters(QDir.Drives | QDir.AllDirs))
self.setModel(self.__model)
self.setCompletionMode(completionMode)
if isWindowsPlatform():
self.setCaseSensitivity(Qt.CaseInsensitive)
if parent:
parent.setCompleter(self)
class FileTree(QWidget):
def __init__(self, defaultfolder=r'c:\Zen_Output'):
super(QWidget, self).__init__()
filter = ['*.czi', '*.ome.tiff', '*ome.tif' '*.tiff' '*.tif']
# define the style for the FileTree via s style sheet
self.setStyleSheet("""
QTreeView::item {
background-color: rgb(38, 41, 48);
font-weight: bold;
}
QTreeView::item::selected {
background-color: rgb(38, 41, 48);
color: rgb(0, 255, 0);
}
QTreeView QHeaderView:section {
background-color: rgb(38, 41, 48);
color: rgb(255, 255, 255);
}
""")
self.model = QFileSystemModel()
self.model.setRootPath(defaultfolder)
self.model.setFilter(QtCore.QDir.AllDirs | QDir.Files | QtCore.QDir.NoDotAndDotDot)
self.model.setNameFilterDisables(False)
self.model.setNameFilters(filter)
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setRootIndex(self.model.index(defaultfolder))
self.tree.setAnimated(True)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(False)
header = self.tree.header()
header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.tree.clicked.connect(self.on_treeView_clicked)
@pyqtSlot()
def on_treeView_clicked(self, index):
indexItem = self.model.index(index.row(), 0, index.parent())
filename = self.model.fileName(indexItem)
filepath = self.model.filePath(indexItem)
# open the file when clicked
print('Opening ImageFile : ', filepath)
open_image_stack(filepath)
class E5FileCompleter(QCompleter):
"""
Class implementing a completer for file names.
"""
def __init__(self,
parent=None,
completionMode=QCompleter.PopupCompletion,
showHidden=False):
"""
Constructor
@param parent parent widget of the completer (QWidget)
@keyparam completionMode completion mode of the
completer (QCompleter.CompletionMode)
@keyparam showHidden flag indicating to show hidden entries as well
(boolean)
"""
super(E5FileCompleter, self).__init__(parent)
self.__model = QFileSystemModel(self)
if showHidden:
self.__model.setFilter(
QDir.Filters(QDir.Dirs | QDir.Files | QDir.Drives
| QDir.AllDirs | QDir.Hidden))
else:
self.__model.setFilter(
QDir.Filters(QDir.Dirs | QDir.Files | QDir.Drives
| QDir.AllDirs))
self.__model.setRootPath("")
self.setModel(self.__model)
self.setCompletionMode(completionMode)
if isWindowsPlatform():
self.setCaseSensitivity(Qt.CaseInsensitive)
if parent:
parent.setCompleter(self)
def setRootPath(self, path):
"""
Public method to set the root path of the model.
@param path root path for the model
@type str
"""
if not os.path.isdir(path):
path = os.path.dirname(path)
self.__model.setRootPath(path)
def rootPath(self):
"""
Public method to get the root path of the model.
@return root path of the model
@rtype str
"""
return self.__model.rootPath()
def __init__(self, *args, **kwargs):
super(DirLineEdit, self).__init__(*args, **kwargs)
completer = QCompleter()
completer.setCompletionMode(QCompleter.CompletionMode.PopupCompletion)
model = QFileSystemModel()
model.setRootPath('/')
model.setFilter(QDir.Filter.AllEntries | QDir.Filter.NoDotAndDotDot
| QDir.Filter.Hidden)
completer.setModel(model)
self.setCompleter(completer)
class E5FileCompleter(QCompleter):
"""
Class implementing a completer for file names.
"""
def __init__(self, parent=None,
completionMode=QCompleter.PopupCompletion,
showHidden=False):
"""
Constructor
@param parent parent widget of the completer (QWidget)
@keyparam completionMode completion mode of the
completer (QCompleter.CompletionMode)
@keyparam showHidden flag indicating to show hidden entries as well
(boolean)
"""
super(E5FileCompleter, self).__init__(parent)
self.__model = QFileSystemModel(self)
if showHidden:
self.__model.setFilter(
QDir.Filters(QDir.Dirs | QDir.Files | QDir.Drives |
QDir.AllDirs | QDir.Hidden))
else:
self.__model.setFilter(QDir.Filters(
QDir.Dirs | QDir.Files | QDir.Drives | QDir.AllDirs))
self.__model.directoryLoaded.connect(self.complete)
self.__model.setRootPath("")
self.setModel(self.__model)
self.setCompletionMode(completionMode)
if isWindowsPlatform():
self.setCaseSensitivity(Qt.CaseInsensitive)
if parent:
parent.setCompleter(self)
def setRootPath(self, path):
"""
Public method to set the root path of the model.
@param path root path for the model
@type str
"""
if not os.path.isdir(path):
path = os.path.dirname(path)
self.__model.setRootPath(path)
def rootPath(self):
"""
Public method to get the root path of the model.
@return root path of the model
@rtype str
"""
return self.__model.rootPath()
class DirectoryTree(QWidget):
def __init__(self):
super().__init__()
self.title = 'PyQt5 file system view'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath(QDir.rootPath())
self.model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.hideColumn(1)
self.tree.hideColumn(2)
self.tree.hideColumn(3)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
self.fileModel = QFileSystemModel()
self.fileModel.setRootPath(QDir.rootPath())
self.list = QTableView()
self.list.setModel(self.fileModel)
self.list.setShowGrid(False)
self.list.verticalHeader().setVisible(False)
self.list.setSelectionBehavior(QTableView().SelectRows)
self.tree.clicked.connect(self.onClicked)
windowLayout = QHBoxLayout()
windowLayout.addWidget(self.tree)
windowLayout.addWidget(self.list)
self.setLayout(windowLayout)
self.show()
def onClicked(self, index):
path = self.model.fileInfo(index).absoluteFilePath()
self.list.setRootIndex(self.fileModel.setRootPath(path))
def setup_file_view(view, encoded):
d = path.join(getcwd(), 'docs')
fs_model = QFileSystemModel(view)
fs_model.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs | QDir.AllEntries)
fs_model.setRootPath(d)
model = SortFilterModel(encoded)
model.setSourceModel(fs_model)
view.setModel(model)
view.setRootIndex(model.mapFromSource(fs_model.index(d)))
view.setColumnHidden(2, True)
view.sortByColumn(0, Qt.AscendingOrder)
for i in range(0, 3):
view.header().setSectionResizeMode(i, QHeaderView.ResizeToContents)
return fs_model, model
def __init__(self, *args, filename=None, delimiter=None, **kwargs):
super().__init__(*args, **kwargs)
self.setupUi(self)
self._dialog = None
self._workers = WorkerQueue(self, ProgressDialog(self))
self._column_index = -1
# Set completer for input files
completer = QCompleter(self.editMetadataFile)
if sys.platform.startswith('win'):
completer.setCaseSensitivity(Qt.CaseInsensitive)
model = QFileSystemModel(completer)
model.setFilter(QDir.AllDirs | QDir.Files | QDir.NoDotAndDotDot)
model.setRootPath(QDir.currentPath())
completer.setModel(model)
self.editMetadataFile.setCompleter(completer)
# Create palette used when validating input files
self._error_palette = QPalette()
self._error_palette.setColor(QPalette.Base,
QColor(Qt.red).lighter(150))
# Connect Delimiter ComboBox to delimiter LineEdit
self.cbCsvDelimiter.setOtherEditWidget(self.editCsvDelimiter)
# Connect events
self.btBrowseMetadataFile.clicked.connect(self.browse)
self.chkComment.clicked.connect(
lambda: self.editComment.setEnabled(self.chkComment.isChecked()))
self.editMetadataFile.textChanged.connect(
self.on_metadata_file_changed)
self.cbCsvDelimiter.delimiterChanged.connect(self.populate_table)
self.chkUseFirstLineAsHeader.clicked.connect(self.populate_table)
self.spinSkipRows.valueChanged.connect(self.populate_table)
self.editComment.textChanged.connect(self.populate_table)
self.chkComment.clicked.connect(self.populate_table)
self.btRefresh.clicked.connect(self.populate_table)
self.chkComment.clicked.connect(self.populate_table)
self.btSelectAll.clicked.connect(self.twMetadata.selectAll)
self.btSelectNone.clicked.connect(self.twMetadata.clearSelection)
self.btSelectInvert.clicked.connect(self.invert_selection)
self.cbIndexColumn.currentIndexChanged.connect(
self.on_column_index_changed)
if filename is not None:
self.editMetadataFile.setText(filename)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setupUi(self)
self._dialog = None
self._workers = WorkerQueue(self, ProgressDialog(self))
super().__init__(*args, **kwargs)
self.setupUi(self)
self._dialog = None
# Set completer for output files
completer = QCompleter(self.editExportFile)
if sys.platform.startswith('win'):
completer.setCaseSensitivity(Qt.CaseInsensitive)
model = QFileSystemModel(completer)
model.setFilter(QDir.AllDirs | QDir.Files | QDir.NoDotAndDotDot)
model.setRootPath(QDir.currentPath())
completer.setModel(model)
self.editExportFile.setCompleter(completer)
# Create palette used when validating input files
self._error_palette = QPalette()
self._error_palette.setColor(QPalette.Base,
QColor(Qt.red).lighter(150))
self.cbFieldSeparator.setOtherEditWidget(self.editFieldSeparator)
self.cbFieldSeparator.setCurrentText("Semicolon (;)")
# Connect events
self.btBrowseExportFile.clicked.connect(self.browse)
self.btSelectAllStandards.clicked.connect(
lambda: self.select(self.lstStandards, 'all'))
self.btSelectNodeStandards.clicked.connect(
lambda: self.select(self.lstStandards, 'none'))
self.btInvertSelectionStandards.clicked.connect(
lambda: self.select(self.lstStandards, 'invert'))
self.btSelectAllAnalogs.clicked.connect(
lambda: self.select(self.lstAnalogs, 'all'))
self.btSelectNodeAnalogs.clicked.connect(
lambda: self.select(self.lstAnalogs, 'none'))
self.btInvertSelectionAnalogs.clicked.connect(
lambda: self.select(self.lstAnalogs, 'invert'))
self.editExportFile.textChanged.connect(self.validate_export_filename)
self.editFieldSeparator.textChanged.connect(self.validate_separator)
class FolderContents(QWidget):
def __init__(self, editor):
super().__init__(editor)
self.editor = editor
self.layout = QHBoxLayout()
self.setLayout(self.layout)
self.tView = QTreeView()
self.createFileExplorer()
def createFileExplorer(self):
self.dirModel = QFileSystemModel()
# self.fileModel = QFileSystemModel()
# self.fmDialog = QDialog()
# self.dirModel.setFilter()
self.root = self.dirModel.setRootPath(QDir.homePath())
self.dirModel.setFilter(QDir.NoDot | QDir.AllEntries)
# self.dirModel.setFilter(QDir.AllDirs)
self.tView.setModel(self.dirModel)
self.layout.addWidget(self.tView)
self.tView.setRootIndex(self.root)
self.tView.doubleClicked.connect(self.clickAction)
self.subdirs = 0
self.current_dir = QDir.homePath()
def clickAction(self, index):
if index.data() == '..':
if self.subdirs > 0:
self.current_dir = self.current_dir.rsplit('/', 1)[0]
self.tView.setRootIndex(
self.dirModel.setRootPath(self.current_dir))
self.subdirs -= 1
# print(QDir(index.parent()).absoluteFilePath())
# self.dirModel.setRootPath(QDir(index.parent()).absolutePath())
elif self.dirModel.fileInfo(index).isDir():
self.subdirs += 1
self.current_dir = self.current_dir + '/' + str(index.data())
self.tView.setRootIndex(index)
elif self.dirModel.fileInfo(index).isFile():
extension = index.data().rsplit('.', 1)[1]
if extension == 'nc' or extension == 'nc4':
subprocess.call('ncview ' + self.current_dir + '/' +
index.data(),
shell=True)
elif extension == 'ncl':
self.editor.AddTab(self.current_dir + '/' + index.data())
class CommanderFileManager(object):
"""docstring for FileManager"""
def __init__(self):
self.files_tree_model = QFileSystemModel()
self.set_filter()
self.files_tree_model.setRootPath(os.path.abspath(__file__))
self._file = None
def set_filter(self, filter_list=['*.lua']):
self.files_tree_model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot | QDir.AllEntries)
self.files_tree_model.setNameFilters(filter_list)
self.files_tree_model.setNameFilterDisables(0)
def get_path(self, index):
return self.files_tree_model.filePath(index)
def open(self, path):
try:
with open(path, 'rt') as f:
text = f.read()
self._file = path
return text
except Exception as e:
print(e)
return None
def save(self, fp, text):
""" save file document """
try:
with open(fp, 'wt') as f:
f.write(text)
except Exception as e:
return False
return True
@property
def file(self):
return self._file
@file.setter
def file(self, f):
self._file = f
def open_project(self, project):
project_path = project.path
qfsm = None # Should end up having a QFileSystemModel
if project_path not in self.__projects:
qfsm = QFileSystemModel()
project.model = qfsm
qfsm.setRootPath(project_path)
qfsm.setFilter(QDir.AllDirs | QDir.Files | QDir.NoDotAndDotDot)
# If set to true items that dont match are displayed disabled
qfsm.setNameFilterDisables(False)
pext = ["*{0}".format(x) for x in project.extensions]
logger.debug(pext)
qfsm.setNameFilters(pext)
self.__projects[project_path] = project
self.__check_files_for(project_path)
self.projectOpened.emit(project_path)
else:
qfsm = self.__projects[project_path]
return qfsm
class AssetBrowser(QMainWindow, Ui_MainWindow):
asset_clicked = pyqtSignal(str, str, name='assetClicked')
def __init__(self):
super(AssetBrowser, self).__init__()
self.setupUi(self)
self.dir_model = QFileSystemModel()
self.dir_model.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)
self.dir_model.setReadOnly(False)
self.dir_view.setModel(self.dir_model)
self.dir_view.hideColumn(1)
self.dir_view.hideColumn(2)
self.dir_view.hideColumn(3)
self.file_model = QFileSystemModel()
self.file_model.setFilter(QDir.NoDotAndDotDot | QDir.Files)
self.file_model.setReadOnly(False)
self.file_view.setModel(self.file_model)
def open_project(self, project_dir):
path = os.path.join(project_dir)
self.dir_model.setRootPath(path)
self.file_model.setRootPath(path)
self.dir_view.setRootIndex(self.dir_model.index(path))
self.file_view.setRootIndex(self.file_model.index(path))
def dir_clicked(self, idx):
path = self.dir_model.fileInfo(idx).absoluteFilePath()
self.file_view.setRootIndex(self.file_model.setRootPath(path))
def file_doubleclicked(self, idx):
fileinfo = self.file_model.fileInfo(idx)
path = fileinfo.absoluteFilePath()
ext = fileinfo.suffix()
self.asset_clicked.emit(path, ext)
def open_project(self, project):
project_path = project.path
qfsm = None # Should end up having a QFileSystemModel
if project_path not in self.__projects:
qfsm = QFileSystemModel()
project.model = qfsm
qfsm.setRootPath(project_path)
qfsm.setFilter(QDir.AllDirs | QDir.Files | QDir.NoDotAndDotDot)
# If set to true items that dont match are displayed disabled
qfsm.setNameFilterDisables(False)
pext = ["*{0}".format(x) for x in project.extensions]
logger.debug(pext)
qfsm.setNameFilters(pext)
self.__projects[project_path] = project
self.__check_files_for(project_path)
self.projectOpened.emit(project_path)
else:
qfsm = self.__projects[project_path]
return qfsm
def load_tree(self, project):
"""Load the tree view on the right based on the project selected."""
qfsm = QFileSystemModel()
qfsm.setRootPath(project.path)
load_index = qfsm.index(qfsm.rootPath())
qfsm.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
qfsm.setNameFilterDisables(False)
pext = ["*{0}".format(x) for x in project.extensions]
qfsm.setNameFilters(pext)
self._tree.setModel(qfsm)
self._tree.setRootIndex(load_index)
t_header = self._tree.header()
t_header.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
t_header.setSectionResizeMode(0, QHeaderView.Stretch)
t_header.setStretchLastSection(False)
t_header.setClickable(True)
self._tree.hideColumn(1) # Size
self._tree.hideColumn(2) # Type
self._tree.hideColumn(3) # Modification date
def load_tree(self, project):
"""Load the tree view on the right based on the project selected."""
qfsm = QFileSystemModel()
qfsm.setRootPath(project.path)
load_index = qfsm.index(qfsm.rootPath())
qfsm.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
qfsm.setNameFilterDisables(False)
pext = ["*{0}".format(x) for x in project.extensions]
qfsm.setNameFilters(pext)
self._tree.setModel(qfsm)
self._tree.setRootIndex(load_index)
t_header = self._tree.header()
t_header.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
t_header.setSectionResizeMode(0, QHeaderView.Stretch)
t_header.setStretchLastSection(False)
t_header.setSectionsClickable(True)
self._tree.hideColumn(1) # Size
self._tree.hideColumn(2) # Type
self._tree.hideColumn(3) # Modification date
def setupModel(self):
self.list_view_imported_symbols.setModel(
self._parent_controller.get_instruments_model())
fileName = "G:/Programming/Projects/QtStatisticCalculator/^spx_y_test.csv"
name = AkFunctions.getShortName(fileName)
headers, data = AkFunctions.loadCSV(fileName)
xPeriod = AkPeriod(1, data, headers=headers)
#instrument = AkInstrument(name, [xPeriod])
analysis_list = [
AkAnalysisType.Calendar, AkAnalysisType.Period,
AkAnalysisType.Series
]
instrument_ = AkInstrument(name,
sources=[data],
analysis_types=analysis_list,
method=AkSelectionMethod.CC,
precision=3)
self._parent_controller.get_instruments_model().insertRows(
0, len([instrument_]), [instrument_])
fileSystemModel = QFileSystemModel()
fileSystemModel.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot
| QDir.AllEntries)
filters = ["*.csv"]
fileSystemModel.setNameFilters(filters)
fileSystemModel.setNameFilterDisables(False)
fileSystemModel.setRootPath(QDir.currentPath())
self.tree_view_windows_files.setModel(fileSystemModel)
self.tree_view_windows_files.hideColumn(1)
self.tree_view_windows_files.hideColumn(2)
self.tree_view_windows_files.hideColumn(3)
def __init__(self, win):
Ui_MainWindow.__init__(self)
self.window = win
self.setupUi(win)
qfs = QFileSystemModel(self.treeView)
exclude = ExcludeSomeNamesModel()
exclude.setSourceModel(qfs)
self.treeView.setModel(exclude)
qfs.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot | QDir.Files)
if sys.platform == 'darwin':
qfs.setRootPath("/Volumes")
self.treeView.setRootIndex(
exclude.mapFromSource(qfs.index("/Volumes")))
elif sys.platform == 'win32':
qfs.setRootPath("\\")
self.treeView.setRootIndex(exclude.mapFromSource(qfs.index("\\")))
else:
raise UnsupportedPlatform(sys.platform)
self.treeView.doubleClicked.connect(self.volumeDoubleClicked)
self.qfs = qfs
self.exclude = exclude
self.treeView.setSortingEnabled(True)
self.treeView.setColumnWidth(0, 300)
self.treeView.setItemsExpandable(False)
self.treeView.setRootIsDecorated(False)
self.openFileButton.clicked.connect(self.openFileButtonClicked)
self.aboutButton.clicked.connect(self.aboutButtonClicked)
for elem in range(1, 4):
self.treeView.hideColumn(elem)
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
path = QDir.currentPath()
self.browser_model = QFileSystemModel()
self.browser_model.setRootPath(path)
self.browser_model.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)
self.ui.browser.setModel(self.browser_model)
self.details_model = QFileSystemModel()
self.details_model.setRootPath(path)
self.details_model.setFilter(QDir.NoDotAndDotDot | QDir.AllEntries)
self.ui.details.setModel(self.details_model)
column_count = self.browser_model.columnCount()
for i in range(1, column_count):
self.ui.browser.hideColumn(i)
self.setupUi()
def setupUi(self):
self.ui.browser.clicked.connect(self.browser_clicked)
def browser_clicked(self, index):
file_info = self.browser_model.fileInfo(index)
path = file_info.absoluteFilePath()
self.ui.details.setRootIndex(self.details_model.setRootPath(path))
class miFormulario(QMainWindow,QDialog):
path=''
enPlay2={}
enDirectorio=[]
def __init__(self, parent=None):
QtWidgets.QWidget.__init__(self,parent)
self.ui=Ui_MainWindow()
self.ui.setupUi(self)
self.ui.btnNuevaCancion.clicked.connect(self.nuevaCancion)
self.ui.btnAgregarSet.clicked.connect(self.agregar_a_play)
self.ui.listaCanciones.doubleClicked.connect(self.agregar_a_play)
self.ui.btnQuitarSet.clicked.connect(self.borrarItemListaPlay)
self.ui.btnPlay.clicked.connect(self.abrirCancion)
self.ui.listaPlay.doubleClicked.connect(self.abrirCancion)
self.ui.btnGuardarCancion.clicked.connect(self.guardarCambios)
self.ui.btnSubir.clicked.connect(self.transportarArriba)
self.ui.btnBajar.clicked.connect(self.transportarAbajo)
self.ui.btnExportarPDF.clicked.connect(self.exportarPDF)
self.ui.btnGuardarSet.clicked.connect(self.guardarSet)
self.ui.btnCargarSet.clicked.connect(self.cargarLista)
self.ui.btnAbrirDirectorio.clicked.connect(self.abrirBrwserCarpetas)
self.ui.btnAbrirCancion.clicked.connect(self.abrirUnaCancion)
def abrirBrwserCarpetas(self):
self.ventana=QtWidgets.QDialog()
self.ui2=Ui_Directorio()
self.ui2.setupUi(self.ventana)
self.ventana.show()
homedir = os.path.expanduser("~")
self.model = QFileSystemModel()
self.model.setFilter(QtCore.QDir.NoDotAndDotDot | QtCore.QDir.Dirs | QtCore.QDir.NoSymLinks)
self.model.setRootPath(QtCore.QDir.rootPath())
self.tree = self.ui2.vistaDirectorio
self.tree.setModel(self.model)
self.tree.setRootIndex(self.model.index(homedir))
self.ui2.btnAbrirCarpeta.clicked.connect(self.rutaCarpeta)
self.ui2.btnCancelarBrowser.clicked.connect(self.cerrarBrowser)
def rutaCarpeta(self):
index=self.ui2.vistaDirectorio.currentIndex()
self.path=self.model.filePath(index)
self.abrirDirectorio()
def cerrarBrowser(self):
self.ventana.close()
def closeEvent(self, event):
respuesta = QMessageBox.question(self, 'Cerra Aplicación',
"Está seguro que quiere cerrar la aplicación", QMessageBox.Yes |
QMessageBox.No, QMessageBox.No)
if respuesta == QMessageBox.Yes:
event.accept()
else:
event.ignore()
def abrirDirectorio(self):
self.enDirectorio=[]
self.ui.listaCanciones.clear()
files=[]
for r, d, f in os.walk(self.path): #@UnusedVariable
for file in f:
if file[-4:]=='.cec':
files.append(file)
self.enDirectorio.append((r+'/'+file))
for f in files:
self.ui.listaCanciones.addItem(f.strip('.cec'))
if files!=[]:
self.cerrarBrowser()
if files==[]:
QMessageBox.information(self, 'Error', 'Esta carpeta no contiene canciones para abrir')
def abrirUnaCancion(self):
try:
homedir = os.path.expanduser("~")
ruta=homedir+'\Desktop'
path,_=QFileDialog.getOpenFileName(self, 'Seleccionar Canción', ruta)
nombre=QFileInfo(path).fileName()
if path[-4:]=='.cec':
self.enDirectorio.append(path)
self.ui.listaCanciones.addItem(nombre.strip('.cec'))
except:
pass
def nuevaCancion(self):
self.ui.cancionTE.clear()
self.ui.cancionTE2.clear()
self.ui.cancionTE.setPlaceholderText('''Escribir o pegar la cancion que desee guardar aquí
recuerde que los reglones de las notas deben comensar con un punto (.) en el margen izquierdo
y las tono principal deben estar en mayúscula y el resto del acorde en minúsculas.
Ej:
TITULO (si lo desea)
AUTOR (si lo desea)
ALGUNA OBSERVACIÓN (si lo desea)
INTRO:
.A Dm G#
.C G Ebm
Mi corazón confiado está por que yo te conozco
. Emaj7 F# Gm/D
Y en medio de la tempestad nunca estoy solo ''')
def agregar_a_play(self):
try:
fila=self.ui.listaCanciones.currentRow()
lista=self.ui.listaCanciones.selectedItems()
for l in lista:
self.enPlay2[l.text()]=self.enDirectorio[fila]+'\n'
self.ui.listaPlay.addItem(l.text())
except:
QMessageBox.information(self, 'Error','Error al cargar a Play List')
def borrarItemListaPlay(self):
try:
lista=self.ui.listaPlay.selectedItems()
self.ui.listaPlay.takeItem(self.ui.listaPlay.currentRow())
for l in lista:
del self.enPlay2[l.text()]
except:
QMessageBox.information(self, 'Quitar', 'No hay nada para quitar')
def abrirCancion(self):
try:
self.ui.cancionTE.clear()
self.ui.cancionTE2.clear()
lista=self.ui.listaPlay.selectedItems()
for l in lista:
file_text=abrirCancionSeleccionada(self.enPlay2[l.text()].strip('\n'))
self.abrirConFormato(file_text)
except:
QMessageBox.information(self, 'Error', 'Verifique que la canción no se haya movido de carpeta')
def guardarCambios(self):
homedir = os.path.expanduser("~")
ruta=homedir+'\Desktop'
try:
texto2 = self.ui.cancionTE.toPlainText()
self.ui.cancionTE.clear()
escribirCrearArchivo(texto2)
file_text=abrirAuxiliar()
for f in file_text:
if f[0]=='.':
self.ui.cancionTE.setTextColor(QtGui.QColor("blue"))
self.ui.cancionTE.setFontWeight(QtGui.QFont.Bold)
self.ui.cancionTE.setFontPointSize(10)
self.ui.cancionTE.append(f.strip('\n'))
if f[0]!='.':
if f[0]!=' ':
self.ui.cancionTE.setTextColor(QtGui.QColor("black"))
self.ui.cancionTE.setFontWeight(QtGui.QFont.Bold)
self.ui.cancionTE.setFontPointSize(10)
self.ui.cancionTE.append(' '+f.strip('\n'))
if f[0]==' ':
self.ui.cancionTE.setTextColor(QtGui.QColor("black"))
self.ui.cancionTE.setFontWeight(QtGui.QFont.Bold)
self.ui.cancionTE.setFontPointSize(10)
self.ui.cancionTE.append(f.strip('\n'))
filename, _ = QFileDialog.getSaveFileName(self, 'Save File', ruta)
if filename !='':
if QFileInfo(filename).suffix() == '':
filename += '.cec'
f=open(filename, 'w')
texto = self.ui.cancionTE.toPlainText()+'\n'+self.ui.cancionTE2.toPlainText()
f.write(texto)
f.close()
except:
pass
def transportarArriba(self):
try:
cancion=abrirAuxiliar()
self.ui.cancionTE.clear()
self.ui.cancionTE2.clear()
nuevaCancion=transportarMedioArriba(cancion)
self.abrirConFormato(nuevaCancion)
except:
QMessageBox.information(self, 'Error','Debe guardar la canción primero o No hay nada para transportar')
def transportarAbajo(self):
try:
cancion=abrirAuxiliar()
self.ui.cancionTE.clear()
self.ui.cancionTE2.clear()
nuevaCancion=transportarMedioAbajo(cancion)
self.abrirConFormato(nuevaCancion)
except:
QMessageBox.information(self, 'Error','Debe guardar la canción primero o No hay nada para transportar')
def exportarPDF(self):
try:
self.ui.cancionTE2.clear()
file_text=abrirAuxiliar()
for f in file_text:
if f[0]=='.':
self.ui.cancionTE2.setTextColor(QtGui.QColor("blue"))
self.ui.cancionTE2.setFontWeight(QtGui.QFont.Bold)
self.ui.cancionTE2.setFontPointSize(10)
self.ui.cancionTE2.append(f.strip('\n'))
if f[0]!='.':
self.ui.cancionTE2.setTextColor(QtGui.QColor("black"))
self.ui.cancionTE2.setFontWeight(QtGui.QFont.Bold)
self.ui.cancionTE2.setFontPointSize(10)
self.ui.cancionTE2.append(f.strip('\n'))
except:
pass
try:
filename, _ = QFileDialog.getSaveFileName(self, 'Exportar a PDF', None, 'PDF files (.pdf) ;; All Files()')
if filename !='':
if QFileInfo(filename).suffix() == '':
filename += '.pdf'
printer = QPrinter(QPrinter.HighResolution)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(filename)
self.ui.cancionTE2.document().print_(printer)
self.ui.cancionTE.clear()
self.ui.cancionTE2.clear()
file_text=abrirAuxiliar()
self.abrirConFormato(file_text)
except:
pass
def guardarSet(self):
homedir = os.path.expanduser("~")
ruta=homedir+'\Desktop'
try:
enPlay={}
for i in range(self.ui.listaPlay.count()):
enPlay[self.ui.listaPlay.item(i).text()]=self.enPlay2[self.ui.listaPlay.item(i).text()]
filename, _ = QFileDialog.getSaveFileName(self, 'Guardar Lista', ruta)
if filename !='':
if QFileInfo(filename).suffix() == '':
filename += '.lec'
f=open(filename,'w')
f.writelines(str(enPlay))
f.close()
except:
QMessageBox.information(self, 'Error','Error al Guardar Set')
def cargarLista(self):
homedir = os.path.expanduser("~")
ruta=homedir+'\Desktop'
try:
self.ui.listaPlay.clear()
self.enPlay2={}
filename, _ = QFileDialog.getOpenFileName(self, 'Abrir Lista', ruta)
f=open(filename, 'r')
file_text =f.readlines()
for ft in file_text:
self.enPlay2=eval(ft)
for key in self.enPlay2.keys():
self.ui.listaPlay.addItem(key)
except:
QMessageBox.information(self, 'Error','Error al cargar Lista')
def abrirConFormato(self,file_text):
count=0
for f in file_text:
count+=1
if count<40:
if f[0]=='.':
self.ui.cancionTE.setTextColor(QtGui.QColor("blue"))
self.ui.cancionTE.setFontWeight(QtGui.QFont.Bold)
self.ui.cancionTE.setFontPointSize(10)
self.ui.cancionTE.append(f.strip('\n'))
if f[0]!='.':
self.ui.cancionTE.setTextColor(QtGui.QColor("black"))
self.ui.cancionTE.setFontWeight(QtGui.QFont.Bold)
self.ui.cancionTE.setFontPointSize(10)
self.ui.cancionTE.append(f.strip('\n'))
if count>=40:
if f[0]=='.':
self.ui.cancionTE2.setTextColor(QtGui.QColor("blue"))
self.ui.cancionTE2.setFontWeight(QtGui.QFont.Bold)
self.ui.cancionTE2.setFontPointSize(10)
self.ui.cancionTE2.append(f.strip('\n'))
if f[0]!='.':
self.ui.cancionTE2.setTextColor(QtGui.QColor("black"))
self.ui.cancionTE2.setFontWeight(QtGui.QFont.Bold)
self.ui.cancionTE2.setFontPointSize(10)
self.ui.cancionTE2.append(f.strip('\n'))
#posicionar cursor arriba
cursor = QTextCursor(self.ui.cancionTE2.document())
cursor.setPosition(0)
self.ui.cancionTE2.setTextCursor(cursor)
class Win(QMainWindow):
def __init__(self, options):
super(Win, self).__init__()
self.db = dbtag.Db()
self.db.open(options.db)
self.db.create_tables()
self.rootPath = options.filespath
self._init_widgets()
self._init_more()
def _init_widgets(self):
bigsplitter = QSplitter(Qt.Horizontal, self)
self.setCentralWidget(bigsplitter)
leftsplitter = QSplitter(Qt.Vertical, self)
self.tabWidget = QTabWidget(self)
self.tagChooser = TagChooser(self.db)
self.dirChooser = QTreeView(self)
self.tabWidget.addTab(self.dirChooser, 'Dir')
self.tabWidget.addTab(self.tagChooser, 'Tags')
self.tagEditor = TagEditor(self.db)
self.imageList = ImageList()
leftsplitter.addWidget(self.tabWidget)
leftsplitter.addWidget(self.tagEditor)
bigsplitter.addWidget(leftsplitter)
bigsplitter.addWidget(self.imageList)
self.viewer = ImageViewer(self.db)
def _init_more(self):
self.setWindowTitle('Tags4')
self.dirModel = QFileSystemModel()
self.dirModel.setFilter(QDir.AllDirs | QDir.Drives | QDir.Hidden | QDir.NoDotAndDotDot)
qidx = self.dirModel.setRootPath(self.rootPath)
self.dirChooser.setModel(self.dirModel)
self.dirChooser.setRootIndex(qidx)
self.dirChooser.clicked.connect(self.browseSelectedDir)
self.imageList.itemSelectionChanged.connect(self._editTagsItems)
self.imageList.itemDoubleClicked.connect(self._spawnViewerItem)
self.imageList.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.tabWidget.currentChanged.connect(self._tabSelected)
self.tagChooser.changed.connect(self.browseSelectedTags)
def editTags(self, path):
self.tagEditor.setFile(path)
def editTagsItems(self, paths):
self.tagEditor.setFiles(paths)
def spawnViewer(self, files, currentFile):
self.viewer.spawn(files, currentFile)
@Slot()
def _editTagsItems(self):
self.editTagsItems([qitem.getPath() for qitem in self.imageList.selectedItems()])
@Slot(QListWidgetItem)
def _spawnViewerItem(self, qitem):
self.spawnViewer(self.imageList.getFiles(), qitem.getPath())
@Slot()
def browseSelectedDir(self):
path = self.dirModel.filePath(self.dirChooser.currentIndex())
if not path:
return
files = [os.path.join(path, f) for f in os.listdir(path)]
files = filter(os.path.isfile, files)
files.sort()
self.imageList.setFiles(files)
@Slot()
def browseSelectedTags(self):
self.imageList.setFiles(self.tagChooser.matchingFiles())
@Slot(int)
def _tabSelected(self, idx):
if idx == 0:
self.browseSelectedDir()
else:
self.browseSelectedTags()
def browsePath(self, path):
self.imageList.setFiles(os.path.join(path, f) for f in os.listdir(path))
class PhotoAlbumAndDirectoryViewer(QWidget):
def __init__(self, parent):
super(QWidget, self).__init__(parent)
self.parent = parent
self.setFixedWidth(400)
self.layout = QVBoxLayout(self)
# Инициализация вкладок
self.tabs = QTabWidget()
# init first tab
self.directory_viewer = QTreeView()
self.cur_item = None
path = QDir.rootPath()
self.dirModel = QFileSystemModel()
self.dirModel.setRootPath(QDir.rootPath())
self.dirModel.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)
self.fileModel = QFileSystemModel()
self.fileModel.setFilter(QDir.NoDotAndDotDot | QDir.Files)
self.directory_viewer.setModel(self.dirModel)
self.directory_viewer.setRootIndex(self.dirModel.index(path))
self.directory_viewer.clicked.connect(self.parent.on_clicked_directory)
self.tabs.addTab(self.directory_viewer, 'Directory')
# init photo album creator and viewer
self.album_viewer = QListWidget()
self.dict_albums = {} # key - name album, value list path photo path
self.album_viewer.setViewMode(QListWidget.IconMode)
self.album_viewer.setResizeMode(QListWidget.Adjust)
self.album_viewer.setMovement(QListView.Static)
self.tabs.addTab(self.album_viewer, 'Album viewer')
self.album_viewer.itemClicked.connect(self.on_clicked_album)
self.layout.addWidget(self.tabs)
# init btn for manage photo album directory
self.search_btn = QPushButton(self)
self.search_btn.resize(QSize(28, 28))
self.search_btn.setIconSize(QSize(28, 28))
self.search_btn.setIcon(QIcon('image/search.png'))
self.search_btn.clicked.connect(self.open_find_widget)
self.add_album = QPushButton(self)
self.add_album.resize(QSize(28, 28))
self.add_album.setIconSize(QSize(28, 28))
self.add_album.setIcon(QIcon('image/add_album.png'))
self.add_album.clicked.connect(self.add_album_widget)
self.edit_album = QPushButton(self)
self.edit_album.resize(QSize(28, 28))
self.edit_album.setIconSize(QSize(40, 44))
self.edit_album.setIcon(QIcon('image/edit_folder.png'))
self.edit_album.clicked.connect(self.edit_album_f)
self.del_album = QPushButton(self)
self.del_album.resize(QSize(28, 28))
self.del_album.setIconSize(QSize(28, 28))
self.del_album.setIcon(QIcon('image/delete_folder.png'))
self.del_album.clicked.connect(self.del_album_f)
self.cluster_widget = ClusterWidget(list(self.dict_albums.keys()),
parent=self)
self.btn_cluster = QPushButton(self)
self.btn_cluster.resize(QSize(28, 28))
self.btn_cluster.setIconSize(QSize(28, 28))
self.btn_cluster.setIcon(QIcon('image/cluster.png'))
self.btn_cluster.clicked.connect(self.show_cluster_widget)
# init widgets edit and add, del album
self.add_album_w = AddAlbum(self)
self.edit_album_w = None
self.search_widget = SearchWidget(self)
self.cluster_creator = None
self.setLayout(self.layout)
def show_cluster_widget(self):
self.cluster_widget = ClusterWidget(list(self.dict_albums.keys()),
parent=self)
self.cluster_widget.show()
def clusters_files(self, clusters_list_album):
dict_tags = {}
for album in clusters_list_album:
for image_path in self.dict_albums[album]:
print('Dict_tags: ', dict_tags)
dict_tags[DirectoryViewer.get_name_from_path(image_path)] = \
[image_path, list(get_tags_image(image_path).keys())]
self.cluster_creator = ClusterSelector(self, dict_tags)
self.cluster_creator.show()
def open_find_widget(self):
self.search_widget.show()
def add_cluster_albums(self, added_albums):
del self.cluster_creator
for i in added_albums:
self.create_album(i, [added_albums[i][1]])
def find_files(self, file_name, flags_search: list):
if 'folder' in flags_search:
self.search_file_in_folders(file_name)
if 'album' in flags_search:
self.search_file_in_album(file_name)
def search_file_in_folders(self, file_name):
pass
def search_file_in_album(self, file_name):
list_equal = []
for file_list in self.dict_albums:
for file_path in self.dict_albums[file_list]:
print(file_path, ':', file_name)
if file_name == DirectoryViewer.get_name_from_path(file_path):
list_equal.append(file_path)
if not list_equal:
QMessageBox.critical(None, 'Error', 'No files found in album')
else:
self.parent.change_list(list_equal)
def del_album_f(self):
if self.cur_item:
if self.cur_item in self.dict_albums:
self.dict_albums.pop(self.cur_item)
self.update_album_list()
def edit_album_f(self):
if self.cur_item:
if self.cur_item in self.dict_albums:
self.edit_album_w = EditAlbum(
name=self.cur_item,
list_images=self.dict_albums[self.cur_item],
parent=self)
self.edit_album_w.show()
def contain_name_album(self, name):
if name in self.dict_albums:
return True
return False
def create_album(self, name, photo_list):
if name in self.dict_albums:
self.dict_albums[name].extend(photo_list)
else:
self.dict_albums[name] = photo_list
self.album_viewer.clear()
for i in self.dict_albums:
item = QListWidgetItem()
item.setText(i)
item.setIcon(QIcon('image/photo.png'))
item.setSizeHint(QSize(128, 128))
self.album_viewer.addItem(item)
item.setTextAlignment(Qt.AlignCenter)
def update_album_list(self):
self.album_viewer.clear()
for i in self.dict_albums:
item = QListWidgetItem()
item.setText(i)
item.setIcon(QIcon('image/photo.png'))
item.setSizeHint(QSize(128, 128))
self.album_viewer.addItem(item)
item.setTextAlignment(Qt.AlignCenter)
def add_album_widget(self):
self.add_album_w.show()
def resizeEvent(self, e):
cor = e.size()
self.btn_cluster.move(self.tabs.width() - 165, 0)
self.search_btn.move(self.tabs.width() - 130, 0)
self.add_album.move(self.tabs.width() - 25, 0)
self.edit_album.move(self.tabs.width() - 60, 0)
self.del_album.move(self.tabs.width() - 95, 0)
self.tabs.resize(abs(cor.width() - self.tabs.width()),
abs(cor.height() - self.tabs.height()))
def on_clicked_album(self, item):
self.cur_item = item.text()
text_item = item.text()
self.parent.on_clicked_album(self.dict_albums[text_item])
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(874, 596)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.verticalLayout = QtWidgets.QVBoxLayout(MainWindow)
self.verticalLayout.setObjectName("verticalLayout")
self.horizontalLayout = QtWidgets.QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.horizontalLayout.addWidget(self.centralwidget)
self.frame = QtWidgets.QFrame(self.centralwidget)
self.frame.setGeometry(QtCore.QRect(0, 0, 871, 41))
self.frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame.setFrameShadow(QtWidgets.QFrame.Sunken)
self.frame.setObjectName("frame")
self.line = QtWidgets.QFrame(self.frame)
self.line.setGeometry(QtCore.QRect(43, 0, 20, 41))
self.line.setFrameShape(QtWidgets.QFrame.VLine)
self.line.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line.setObjectName("line")
self.line_2 = QtWidgets.QFrame(self.frame)
self.line_2.setGeometry(QtCore.QRect(180, 0, 20, 41))
self.line_2.setFrameShape(QtWidgets.QFrame.VLine)
self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line_2.setObjectName("line_2")
self.widget = QtWidgets.QWidget(self.centralwidget)
self.widget.setGeometry(QtCore.QRect(0, 40, 221, 541))
self.widget.setObjectName("widget")
self.label = QtWidgets.QLabel(self.widget)
self.label.setGeometry(QtCore.QRect(10, 10, 191, 16))
self.label.setObjectName("label")
self.label_2 = QtWidgets.QLabel(self.widget)
self.label_2.setGeometry(QtCore.QRect(10, 70, 201, 16))
self.label_2.setObjectName("label_2")
self.label_3 = QtWidgets.QLabel(self.widget)
self.label_3.setGeometry(QtCore.QRect(10, 140, 191, 16))
self.label_3.setObjectName("label_3")
self.groupBox = QtWidgets.QGroupBox(self.widget)
self.groupBox.setGeometry(QtCore.QRect(10, 250, 201, 141))
self.groupBox.setObjectName("groupBox")
self.checkBox = QtWidgets.QCheckBox(self.groupBox)
self.checkBox.setGeometry(QtCore.QRect(10, 20, 70, 17))
self.checkBox.setShortcut("")
self.checkBox.setTristate(False)
self.checkBox.setObjectName("checkBox")
self.checkBox_2 = QtWidgets.QCheckBox(self.groupBox)
self.checkBox_2.setGeometry(QtCore.QRect(10, 50, 70, 17))
self.checkBox_2.setObjectName("checkBox_2")
self.checkBox_3 = QtWidgets.QCheckBox(self.groupBox)
self.checkBox_3.setGeometry(QtCore.QRect(10, 80, 70, 17))
self.checkBox_3.setObjectName("checkBox_3")
self.checkBox_4 = QtWidgets.QCheckBox(self.groupBox)
self.checkBox_4.setGeometry(QtCore.QRect(10, 110, 111, 17))
self.checkBox_4.setObjectName("checkBox_4")
self.pushButton = QtWidgets.QPushButton(self.widget)
self.pushButton.setGeometry(QtCore.QRect(10, 200, 75, 23))
self.pushButton.setObjectName("pushButton")
self.pushButton_2 = QtWidgets.QPushButton(self.widget)
self.pushButton_2.setGeometry(QtCore.QRect(100, 200, 75, 23))
self.pushButton_2.setObjectName("pushButton_2")
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 874, 21))
self.menubar.setObjectName("menubar")
self.menuFile = QtWidgets.QMenu(self.menubar)
self.menuFile.setObjectName("menuFile")
self.menuEdit = QtWidgets.QMenu(self.menubar)
self.menuEdit.setObjectName("menuEdit")
self.menuTools = QtWidgets.QMenu(self.menubar)
self.menuTools.setObjectName("menuTools")
self.menuHelp = QtWidgets.QMenu(self.menubar)
self.menuHelp.setObjectName("menuHelp")
MainWindow.setMenuBar(self.menubar)
self.actionAbout = QtWidgets.QAction(MainWindow)
self.actionAbout.setObjectName("actionAbout")
self.actionOpen = QtWidgets.QAction(MainWindow)
self.actionOpen.setObjectName("actionOpen")
self.actionSearch_From_Specific_Location = QtWidgets.QAction(
MainWindow)
self.actionSearch_From_Specific_Location.setObjectName(
"actionSearch_From_Specific_Location")
self.actionDelete = QtWidgets.QAction(MainWindow)
self.actionDelete.setObjectName("actionDelete")
self.actionExit = QtWidgets.QAction(MainWindow)
self.actionExit.setObjectName("actionExit")
self.actionCut = QtWidgets.QAction(MainWindow)
self.actionCut.setObjectName("actionCut")
self.actionCopy = QtWidgets.QAction(MainWindow)
self.actionCopy.setObjectName("actionCopy")
self.actionClear_List = QtWidgets.QAction(MainWindow)
self.actionClear_List.setObjectName("actionClear_List")
self.actionSelect_All = QtWidgets.QAction(MainWindow)
self.actionSelect_All.setObjectName("actionSelect_All")
self.actionProperties = QtWidgets.QAction(MainWindow)
self.actionProperties.setObjectName("actionProperties")
self.menuFile.addAction(self.actionOpen)
self.menuFile.addSeparator()
self.menuFile.addAction(self.actionSearch_From_Specific_Location)
self.menuFile.addAction(self.actionDelete)
self.menuFile.addSeparator()
self.menuFile.addAction(self.actionExit)
self.menuEdit.addAction(self.actionCut)
self.menuEdit.addAction(self.actionCopy)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionClear_List)
self.menuEdit.addAction(self.actionSelect_All)
self.menuTools.addAction(self.actionProperties)
self.menuTools.addSeparator()
self.menuHelp.addAction(self.actionAbout)
self.menuHelp.addSeparator()
self.menubar.addAction(self.menuFile.menuAction())
self.menubar.addAction(self.menuEdit.menuAction())
self.menubar.addAction(self.menuTools.menuAction())
self.menubar.addAction(self.menuHelp.menuAction())
#Search column View
#self.columnView = QtWidgets.QColumnView(self.centralwidget)
#self.columnView.setGeometry(QtCore.QRect(220, 50, 651, 521))
#self.columnView.setResizeGripsVisible(True)
#self.columnView.setObjectName("columnView")
self.treeView = QtWidgets.QTreeView(self.centralwidget)
self.treeView.setGeometry(QtCore.QRect(220, 50, 651, 521))
self.treeView.setObjectName("columnView")
self.horizontalLayout.addWidget(self.treeView)
path = QDir.rootPath()
self.dirModel = QFileSystemModel()
self.dirModel.setRootPath(QDir.rootPath())
self.fileModel = QFileSystemModel()
self.fileModel.setFilter(QDir.NoDotAndDotDot | QDir.Files)
self.model = QtWidgets.QFileSystemModel()
self.model.setRootPath((QtCore.QDir.rootPath()))
self.treeView.setModel(self.model)
self.treeView.setRootIndex(self.dirModel.index(path))
self.treeView.doubleClicked.connect(self.on_clicked)
self.treeView.setObjectName("treeView")
self.treeView.setColumnWidth(0, 300)
logoPath = QDir.homePath()
self.logoModel = QFileSystemModel()
self.logoModel.setRootPath(logoPath)
self.logoModel.setFilter(QDir.NoDotAndDotDot | QDir.Files
| QDir.NoSymLinks)
print(logoPath)
self.comboBox = QtWidgets.QComboBox(self.widget)
self.comboBox.setGeometry(QtCore.QRect(10, 30, 201, 31))
self.comboBox.setEditable(True)
self.comboBox.setObjectName("comboBox")
self.comboBox_2 = QtWidgets.QComboBox(self.widget)
self.comboBox_2.setGeometry(QtCore.QRect(10, 100, 201, 31))
self.comboBox_2.setEditable(True)
self.comboBox_2.setObjectName("comboBox_2")
self.comboBox_3 = QtWidgets.QComboBox(self.widget)
self.comboBox_3.setGeometry(QtCore.QRect(10, 160, 201, 31))
self.comboBox_3.setEditable(True)
self.comboBox_3.setObjectName("comboBox_3")
self.comboBox_3.setModel(self.logoModel)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.label.setText(
_translate("MainWindow", "Search for files or folders"))
self.label_2.setText(
_translate("MainWindow",
"Containing text (for wordprocessor files)"))
self.label_3.setText(_translate("MainWindow", "Look in (Directory)"))
self.groupBox.setTitle(_translate("MainWindow", "Options"))
self.checkBox.setText(_translate("MainWindow", "Date"))
self.checkBox_2.setText(_translate("MainWindow", "Size"))
self.checkBox_3.setText(_translate("MainWindow", "Type"))
self.checkBox_4.setText(_translate("MainWindow", "Advance Options"))
self.pushButton.setText(_translate("MainWindow", "Search"))
self.pushButton.clicked.connect(self.search)
self.pushButton_2.setText(_translate("MainWindow", "Stop"))
self.pushButton_2.clicked.connect(self.stop)
self.menuFile.setTitle(_translate("MainWindow", "File"))
self.menuEdit.setTitle(_translate("MainWindow", "Edit"))
self.menuTools.setTitle(_translate("MainWindow", "Tools"))
self.menuHelp.setTitle(_translate("MainWindow", "Help"))
self.actionAbout.setText(_translate("MainWindow", "About"))
self.actionOpen.setText(_translate("MainWindow", "Open"))
self.actionSearch_From_Specific_Location.setText(
_translate("MainWindow", "Search From Specific Location"))
self.actionDelete.setText(_translate("MainWindow", "Delete"))
self.actionExit.setText(_translate("MainWindow", "Exit"))
self.actionCut.setText(_translate("MainWindow", "Cut"))
self.actionCopy.setText(_translate("MainWindow", "Copy"))
self.actionClear_List.setText(_translate("MainWindow", "Clear List"))
self.actionSelect_All.setText(_translate("MainWindow", "Select All"))
self.actionProperties.setText(_translate("MainWindow", "Properties"))
def on_clicked(self, index):
path = self.fileModel.fileInfo(index).absoluteFilePath()
#Tab Reading for index values
os.startfile(path)
def stop(self):
print("Program Stoped")
self.pushButton.setEnabled(True)
def search(self):
print("Search started")
self.pushButton.setEnabled(False)
file_name = self.comboBox.currentText()
print(file_name)
path_tmp1 = self.comboBox_3.currentText()
print(path_tmp1)
path_tmp = re.findall("[A-Z]:", path_tmp1)
print(path_tmp[-1])
cur_dir = path_tmp[-1] + '/' ''
print(cur_dir)
result = []
# Wlaking top-down from the root
for root, dir, files in os.walk(cur_dir):
for i in files:
b = re.findall(".*" + file_name + ".*.*", i, re.IGNORECASE)
if b == []:
pass
elif b != []:
for i in files:
if b[-1] == i:
result.append(os.path.join(root, b[-1]))
if result != []:
for i in result:
print(i)
self.pushButton.setEnabled(True)
else:
print("No match")
self.pushButton.setEnabled(True)
class CandyWinForm(QMainWindow):
refreshDroneAsked = pyqtSignal()
refreshArduinoAsked = pyqtSignal()
refreshRiotAsked = pyqtSignal()
verticalSpeedValueChanged = pyqtSignal(float)
horizontalSpeedValueChanged = pyqtSignal(float)
rotationSpeedValueChanged = pyqtSignal(int)
axesChanged = pyqtSignal(list)
presetChanged = pyqtSignal(str)
saveAsked = pyqtSignal()
closing = pyqtSignal()
discrete_threshold_changed = pyqtSignal(int)
discrete_duration_changed = pyqtSignal(int)
control_changed = pyqtSignal(str)
drone_changed = pyqtSignal(str)
calibrationChanged = pyqtSignal()
ask_take_off = pyqtSignal()
ask_land = pyqtSignal()
def __init__(self):
super().__init__()
# create the form
self.ui = Ui_MainWindow()
widget = QWidget()
self.ui.setupUi(widget)
self.setCentralWidget(widget)
# create the scene and add it to the tabs
self.scene = QGraphicsScene()
self.scene.setBackgroundBrush(BG_COL)
self.view = self.ui.graphicsView
self.view.setScene(self.scene)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.scale(1.2, 1.2)
# set up the central scene with axis
self.z_axis = VerticalAxis("up.png", "down.png", self)
self.rotation_axis = VerticalAxis("clock.png", "anticlock.png", self)
self.rotation_axis.setRotation(90)
self.axis1_rect = RectSelector(self.z_axis, self.rotation_axis, self)
self.front_axis = VerticalAxis("front.png", "back.png", self)
self.right_axis = VerticalAxis("front.png", "back.png", self)
self.right_axis.setRotation(90)
self.axis2_rect = RectSelector(self.front_axis, self.right_axis, self)
self.scene.addItem(self.z_axis)
self.scene.addItem(self.rotation_axis)
self.scene.addItem(self.axis1_rect)
self.scene.addItem(self.front_axis)
self.scene.addItem(self.right_axis)
self.scene.addItem(self.axis2_rect)
self.ui.simple_mode.stateChanged.connect(self.set_simplified)
self.set_simplified(False)
# set up the calibration widgets
self.range_keys = ["up", "down", "clock", "anticlock", "front", "back", 'right', 'left']
self.range_sliders = {}
for key in self.range_keys:
_min = 0
_max = 100
_start = 5
_end = 95
rs = QRangeSlider()
rs.setMin(_min)
rs.setMax(_max)
rs.setRange(_start, _end)
rs.setBackgroundStyle('background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #222, stop:1 #333);')
rs.handle.setStyleSheet(
'background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #282, stop:1 #393);')
rs.endValueChanged.connect(self.calibrationChanged)
rs.startValueChanged.connect(self.calibrationChanged)
self.range_sliders[key] = rs
self.ui.top_down_layout.addWidget(self.range_sliders['up'])
self.ui.top_down_layout.addWidget(self.range_sliders['down'])
self.ui.clock_anticlock_layout.addWidget(self.range_sliders['clock'])
self.ui.clock_anticlock_layout.addWidget(self.range_sliders['anticlock'])
self.ui.front_back_layout.addWidget(self.range_sliders['front'])
self.ui.front_back_layout.addWidget(self.range_sliders['back'])
self.ui.right_left_layout.addWidget(self.range_sliders['right'])
self.ui.right_left_layout.addWidget(self.range_sliders['left'])
# handle presets
self.current_preset = None
self.presets_path = ""
self.file_model = QFileSystemModel(self)
self.ui.save_as_btn.clicked.connect(self.saveAsked)
# add bindings to values
self.ui.discrete_treshold_sld.valueChanged.connect(self.discrete_threshold_changed)
self.ui.discrete_treshold_spin.valueChanged.connect(self.discrete_threshold_changed)
self.ui.drone_refresh_btn.clicked.connect(lambda: self.ui.take_off_btn.setEnabled(True))
self.ui.drone_refresh_btn.clicked.connect(self.refreshDroneAsked.emit)
self.ui.arduino_refresh_btn.clicked.connect(self.refreshArduinoAsked.emit)
self.ui.control_group.buttonClicked.connect(lambda button: self.control_changed.emit(button.text()))
self.ui.drone_group.buttonClicked.connect(lambda button: self.drone_changed.emit(button.text()))
# process speed sliders (handle double values)
self.ui.vert_speed_spin.valueChanged.connect(self.verticalSpeedValueChanged)
self.ui.horiz_speed_spin.valueChanged.connect(self.horizontalSpeedValueChanged)
self.ui.rot_speed_spin.valueChanged.connect(self.rotationSpeedValueChanged)
self.ui.vert_speed_spin.valueChanged.connect(lambda val: self.ui.vert_speed_sld.setValue(val * 100))
self.ui.vert_speed_sld.valueChanged.connect(lambda val: self.ui.vert_speed_spin.setValue(val / 100))
self.ui.horiz_speed_spin.valueChanged.connect(lambda val: self.ui.horiz_speed_sld.setValue(val * 100))
self.ui.horiz_speed_sld.valueChanged.connect(lambda val: self.ui.horiz_speed_spin.setValue(val / 100))
self.ui.rot_speed_spin.valueChanged.connect(self.ui.rot_speed_sld.setValue)
self.ui.rot_speed_sld.valueChanged.connect(self.ui.rot_speed_spin.setValue)
self.ui.take_off_btn.clicked.connect(lambda : self.ask_take_off.emit())
self.ui.land_btn.clicked.connect(lambda : self.ask_land.emit())
def display_processed_inputs(self, _up, _rotate, _front, _right):
self.z_axis.display(_up)
self.rotation_axis.display(_rotate)
self.front_axis.display(_front)
self.right_axis.display(_right)
def display_raw_inputs(self, _up, _rotate, _front, _right):
self.z_axis.display_raw(_up)
self.rotation_axis.display_raw(_rotate)
self.front_axis.display_raw(_front)
self.right_axis.display_raw(_right)
def set_simplified(self, is_simplified):
if is_simplified:
self.front_axis.set_active(False)
self.rotation_axis.set_active(False)
self.rotation_axis.hide()
self.front_axis.hide()
self.axis2_rect.hide()
self.z_axis.show()
self.z_axis.setPos(270, 50)
self.right_axis.show()
self.right_axis.setPos(435, 135)
self.axis1_rect.show()
self.axis1_rect.setPos(290, 155)
self.axis1_rect.set_axis(self.z_axis, self.right_axis)
else:
# axis 1
self.z_axis.show()
self.z_axis.setPos(110, 50)
self.rotation_axis.show()
self.rotation_axis.setPos(275, 135)
self.axis1_rect.show()
self.axis1_rect.setPos(130, 155)
self.axis1_rect.set_axis(self.z_axis, self.rotation_axis)
# axis 2
self.front_axis.show()
self.front_axis.setPos(410, 50)
self.right_axis.show()
self.right_axis.setPos(575, 135)
self.axis2_rect.show()
self.axis2_rect.setPos(430, 155)
def get_calibration(self):
res = {}
for key in self.range_keys:
slider = self.range_sliders[key]
res[key] = [slider.start() / 100, slider.end() / 100]
return res
def set_calibration(self, calibration_list):
for key in self.range_keys:
slider = self.range_sliders[key]
if key in calibration_list:
values = calibration_list[key]
slider.setStart_silent(values[0] * 100)
slider.setEnd_silent(values[1] * 100)
else:
slider.setStart_silent(5)
slider.setEnd_silent(95)
self.calibrationChanged.emit()
def update_battery_level(self, battery_val):
max = 4.3
mid = 3.6
min = 3.1
percentage = (battery_val / max) * 100
self.ui.drone_battery_gauge.setValue(int(percentage))
style = gauge_danger
if battery_val > mid:
style = gauge_safe
elif battery_val > min:
style = gauge_warning
self.ui.drone_battery_gauge.setStyleSheet(style)
self.ui.drone_battery_gauge.setFormat("{:.2f}".format(battery_val) + "v (%p%)")
def update_drone_connection(self, connection_status):
if connection_status == "on":
self.ui.drone_status_lbl.setStyleSheet(STATUS_ON_STYLE)
elif connection_status == "progress":
self.ui.drone_status_lbl.setStyleSheet(STATUS_PROGRESS_STYLE)
else:
self.ui.drone_status_lbl.setStyleSheet(STATUS_OFF_STYLE)
if connection_status != "on":
self.update_battery_level(0)
def update_arduino_connection(self, is_connected):
if is_connected:
self.ui.arduino_status_lbl.setStyleSheet(STATUS_ON_STYLE)
else:
self.ui.arduino_status_lbl.setStyleSheet(STATUS_OFF_STYLE)
def set_max_vert_speed(self, val):
self.ui.vert_speed_spin.setValue(val)
def set_max_horiz_speed(self, val):
self.ui.horiz_speed_spin.setValue(val)
def set_max_rotation_speed(self, val):
self.ui.rot_speed_spin.setValue(val)
def get_control_mode(self):
return self.ui.control_group.checkedButton().text()
def set_control_mode(self, _mode):
if _mode == "Arduino Continu":
self.ui.arduino_continous_radio.setChecked(True)
else :
self.ui.arduino_discrete_radio.setChecked(True)
def get_drone_type(self):
return self.ui.drone_group.checkedButton().text()
def set_drone_type(self, _type):
if _type == "Crazyflie":
self.ui.crazy_radio.setChecked(True)
else:
self.ui.ar_radio.setChecked(True)
def set_comments(self, comments):
self.ui.comment_textEdit.setText(comments)
def set_discrete_threshold(self, _threshold):
self.ui.discrete_treshold_spin.setValue(_threshold)
def set_discrete_duration(self, _duration):
self.ui.discrete_duration_spin.setValue(_duration)
def get_max_vert_speed(self):
return self.ui.vert_speed_spin.value()
def get_max_horiz_speed(self):
return self.ui.horiz_speed_spin.value()
def get_max_rotation_speed(self):
return self.ui.rot_speed_spin.value()
def update_activated_axis(self):
self.axesChanged.emit(self.get_axes())
def set_axes(self, _axes):
self.z_axis.set_active(bool(_axes[0]))
if not self.ui.simple_mode.isChecked():
self.rotation_axis.set_active(bool(_axes[1]))
self.front_axis.set_active(bool(_axes[2]))
else:
self.rotation_axis.set_active(False)
self.front_axis.set_active(False)
self.right_axis.set_active(bool(_axes[3]))
def get_axes(self):
return [self.z_axis.is_active(), self.rotation_axis.is_active(), self.front_axis.is_active(),
self.right_axis.is_active()]
def get_comments(self):
return self.ui.comment_textEdit.toPlainText()
def get_discrete_threshold(self):
return self.ui.discrete_treshold_spin.value()
def get_discrete_duration(self):
return self.ui.discrete_duration_spin.value()
def closeEvent(self, event):
self.closing.emit()
def on_selection_changed(self, selected, deselected):
index = self.ui.presets_listView.currentIndex()
preset = str(index.data())
self.presetChanged.emit(preset)
def populate_presets(self, path):
self.presets_path = path
self.file_model.setRootPath(path)
self.file_model.setFilter(QDir.NoDotAndDotDot | QDir.Files)
self.ui.presets_listView.setModel(self.file_model)
def load_first_element(val):
self.ui.presets_listView.setCurrentIndex(self.file_model.index(0,0,self.ui.presets_listView.rootIndex()))
self.file_model.directoryLoaded.connect(load_first_element)
self.ui.presets_listView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.ui.presets_listView.setRootIndex(self.file_model.index(path))
self.ui.presets_listView.selectionModel().selectionChanged.connect(self.on_selection_changed)
def get_current_preset(self):
return self.current_preset
class FileManager(QWidget, _HalWidgetBase):
def __init__(self, parent=None):
super(FileManager, self).__init__(parent)
self.title = 'PyQt5 file system view - pythonspot.com'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
self.default_path = (os.path.join(os.path.expanduser('~'), 'linuxcnc/nc_files/examples'))
self.user_path = (os.path.join('/media'))
self.currentPath = None
self.EXT = INFO.PROGRAM_FILTERS_EXTENSIONS
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath(QDir.currentPath())
self.model.setFilter(QDir.AllDirs | QDir.NoDot | QDir.Files)
self.model.setNameFilterDisables(False)
self.model.setNameFilters(self.EXT)
self.list = QListView()
self.list.setModel(self.model)
self.updateDirectoryView(self.default_path)
self.list.setWindowTitle("Dir View")
self.list.resize(640, 480)
self.list.clicked[QModelIndex].connect(self.clicked)
self.list.activated.connect(self._getPathActivated)
#self.list.currentChanged = self.currentChanged
self.list.setAlternatingRowColors(True)
self.cb = QComboBox()
self.cb.currentTextChanged.connect(self.filterChanged)
self.cb.addItems(self.EXT)
#self.cb.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.button = QPushButton()
self.button.setText('Media')
self.button.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.button.setToolTip('Jump to Media directory')
self.button.clicked.connect(self.onMediaClicked)
self.button2 = QPushButton()
self.button2.setText('User')
self.button2.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.button2.setToolTip('Jump to linuxcnc directory')
self.button2.clicked.connect(self.onUserClicked)
hbox = QHBoxLayout()
hbox.addWidget(self.button)
hbox.addWidget(self.button2)
hbox.addWidget(self.cb)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.list)
windowLayout.addLayout(hbox)
self.setLayout(windowLayout)
self.show()
# this could return the current/previous selected as it's selected.
# need to uncomment monkey patch of self.list.currentChanged above
# so far this is not needed
def currentChanged(self,c,p):
dir_path = self.model.filePath(c)
print('-> ',dir_path)
def updateDirectoryView(self, path):
self.list.setRootIndex(self.model.setRootPath(path))
def filterChanged(self, text):
self.model.setNameFilters([text])
def clicked(self, index):
# the signal passes the index of the clicked item
dir_path = self.model.filePath(index)
if self.model.fileInfo(index).isFile():
self.currentPath = dir_path
return
root_index = self.model.setRootPath(dir_path)
self.list.setRootIndex(root_index)
def onMediaClicked(self):
self.updateDirectoryView(self.user_path)
def onUserClicked(self):
self.updateDirectoryView(self.default_path)
def select_row(self, style):
style = style.lower()
selectionModel = self.list.selectionModel()
row = selectionModel.currentIndex().row()
self.rows = self.model.rowCount(self.list.rootIndex())
if style == 'last':
row = self.rows
elif style == 'up':
if row > 0:
row -= 1
else:
row = 0
elif style == 'down':
if row < self.rows:
row += 1
else:
row = self.rows
else:
return
top = self.model.index(row, 0, self.list.rootIndex())
selectionModel.setCurrentIndex(top, QItemSelectionModel.Select | QItemSelectionModel.Rows)
selection = QItemSelection(top, top)
selectionModel.clearSelection()
selectionModel.select(selection, QItemSelectionModel.Select)
# returns the current highlighted (selected) path as well as
# whether it's a file or not.
def getCurrentSelected(self):
selectionModel = self.list.selectionModel()
index = selectionModel.currentIndex()
dir_path = self.model.filePath(index)
if self.model.fileInfo(index).isFile():
return (dir_path, True)
else:
return (dir_path, False)
def _hal_init(self):
if self.PREFS_:
last_path = self.PREFS_.getpref('last_loaded_directory', self.default_path, str, 'BOOK_KEEPING')
self.updateDirectoryView(last_path)
LOG.debug("lAST FILE PATH: {}".format(last_path))
else:
LOG.debug("lAST FILE PATH: {}".format(self.default_path))
self.updateDirectoryView(self.default_path)
# get current selection and update the path
# then if the path is good load it into linuxcnc
# record it in the preference file if available
def _getPathActivated(self):
row = self.list.selectionModel().currentIndex()
self.clicked(row)
fname = self.currentPath
if fname is None:
return
if fname:
self.load(fname)
# this can be class patched to do something else
def load(self, fname=None):
if fname is None:
self._getPathActivated()
return
self.recordBookKeeping()
ACTION.OPEN_PROGRAM(fname)
STATUS.emit('update-machine-log', 'Loaded: ' + fname, 'TIME')
# this can be class patched to do something else
def recordBookKeeping(self):
fname = self.currentPath
if fname is None:
return
if self.PREFS_:
self.PREFS_.putpref('last_loaded_directory', self.model.rootPath(), str, 'BOOK_KEEPING')
self.PREFS_.putpref('RecentPath_0', fname, str, 'BOOK_KEEPING')
# moves the selection up
# used with MPG scrolling
def up(self):
self.select_row('up')
# moves the selection down
# used with MPG scrolling
def down(self):
self.select_row('down')
class mainForm(QMainWindow):
get_template_filename = pyqtSignal(str)
exit_program = pyqtSignal()
camera_changed = pyqtSignal(int)
def __init__(self):
super().__init__()
self.stream = None
self.image_difference_thread = None
self.template_set = False
self._countour_max_tresh = 10
self._countour_min_tresh = 1
self._transparency_max = 10
self._transparency_min = 0
self._countour_gamma_max = 10
self._countour_gamma_min = 1
self._color_max = 255
self._color_min = 0
self.screen_resolution = None
self.grid_layout = None
self.output_picture = None
self.initUI()
self.init_image_difference()
if self.webcam_switcher.count() > 0:
self.stream = streamCapture(self.webcam_switcher.itemData(self.webcam_switcher.currentIndex()))
self.stream.getframe.connect(self.mat2qimage)
self.webcam_switcher.currentIndexChanged.connect(self.camera_switcher_index_changed)
self.camera_changed.connect(self.stream.reopenStream)
self.stream.start()
self.exit_program.connect(self.stream.exit)
### отрисовка интерфейса
def initUI(self):
self.screen_resolution = QApplication.desktop().screenGeometry()
# self.resize(self.screen_resolution.size())
# self.move(self.screen_resolution.left(), self.screen_resolution.top())
self.grid_layout = QGridLayout()
self.central_widget = QWidget()
self.central_widget.setLayout(self.grid_layout)
self.central_widget.setMaximumSize(self.screen_resolution.width() // 4 * 3,
self.screen_resolution.height() // 4 * 3)
self.setCentralWidget(self.central_widget)
self.camera_label = QLabel("Camera:")
self.grid_layout.addWidget(self.camera_label, 0, 0, 1, 1, Qt.AlignmentFlag.AlignHCenter)
self.webcam_switcher = QComboBox()
self.detect_webcam_devices(self.webcam_switcher)
self.grid_layout.addWidget(self.webcam_switcher, 0, 1, 1, 3)
self.output_picture = QLabel()
self.grid_layout.addWidget(self.output_picture, 1, 0, 1, 4)
### creating right dock
self.right_dock_layout = QVBoxLayout()
self.right_dock_widget = QDockWidget()
self.right_dock_widget.setFeatures(QDockWidget.DockWidgetFeature.DockWidgetMovable | QDockWidget.DockWidgetFeature.DockWidgetFloatable)
self.right_dock_widget.setMinimumSize(self.screen_resolution.width() // 4, self.screen_resolution.height())
right_dock = QWidget(self.right_dock_widget)
right_dock.setMinimumSize(self.screen_resolution.width() // 4, self.screen_resolution.height())
right_dock.setLayout(self.right_dock_layout)
template_label = QLabel("Templates")
template_label.setMinimumSize(50, 25)
self.right_dock_layout.addWidget(template_label)
self.filter_template_edit = QLineEdit()
self.filter_template_edit.setPlaceholderText("Filter (Ctr + Alt + f)")
template_label.setMinimumSize(90, 25)
self.filter_template_edit.setStyleSheet(
"background-image: url(../image_difference/icons/searchIcon.png); background-repeat: no-repeat; background-position: right;")
self.right_dock_layout.addWidget(self.filter_template_edit)
self.file_system_model = QFileSystemModel()
self.file_system_model.setFilter(QDir.Filter.AllDirs | QDir.Filter.NoDotAndDotDot | QDir.Filter.AllEntries)
self.file_system_model.setRootPath(QDir.currentPath())
self.directory_tree_view = QTreeView()
self.directory_tree_view.setModel(self.file_system_model)
self.directory_tree_view.setMinimumSize(200, 100)
self.directory_tree_view.hideColumn(1)
self.directory_tree_view.hideColumn(2)
self.directory_tree_view.hideColumn(3)
# self.directory_tree_view.sortByColumn(0)
self.directory_tree_view.setSortingEnabled(True)
self.directory_tree_view.doubleClicked.connect(self.load_template)
self.directory_tree_view.setRootIndex(self.file_system_model.index("../image_difference/"))
self.right_dock_layout.addWidget(self.directory_tree_view)
self.load_template_button = QPushButton("Select Template")
self.load_template_button.setMaximumSize(self.screen_resolution.width() // 4 - 30, 30)
self.load_template_button.clicked.connect(self.load_template)
self.right_dock_layout.addWidget(self.load_template_button)
self.create_template_button = QPushButton("Create Template")
self.create_template_button.setMaximumSize(self.screen_resolution.width() // 4 - 30, 30)
self.create_template_button.clicked.connect(self.create_template)
self.right_dock_layout.addWidget(self.create_template_button)
self.template_image_widget = QWidget()
self.template_image_widget.setMinimumSize(self.screen_resolution.width() // 4 - 20,
self.screen_resolution.width() // 4 - 10)
self.template_image_back = QLabel(self.template_image_widget)
self.template_image_back.resize(self.screen_resolution.width() // 4 - 20,
self.screen_resolution.width() // 4 - 10)
pix = QPixmap(self.template_image_back.size())
pix.fill(Qt.lightGray)
rect = QRectF(0.0, 0.0, self.template_image_back.size().width(), self.template_image_back.size().height())
painter = QPainter()
painter.begin(pix)
painter.setRenderHints(QPainter.Antialiasing, True)
path = QPainterPath()
path.addRoundedRect(rect, 5.0, 5.0)
painter.drawPath(path)
painter.end()
self.template_image_back.setPixmap(pix)
self.template_image = QLabel(self.template_image_widget)
self.template_image.move(5, 5)
self.template_image.resize(self.screen_resolution.width() // 4 - 30, self.screen_resolution.width() // 4 - 30)
self.template_image_text = QLabel(self.template_image_widget, text="Current Template")
self.template_image_text.setStyleSheet("font-weight: bold")
self.template_image_text.move(self.screen_resolution.width() // 8 - 65, 20)
self.right_dock_layout.addWidget(self.template_image_widget)
self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.right_dock_widget)
### creating bottom dock
self.bottom_dock_layout = QGridLayout()
self.bottom_dock_layout.setSpacing(10)
self.bottom_dock_widget = QDockWidget()
self.bottom_dock_widget.setMinimumSize(self.screen_resolution.width() // 4 * 3 - 10,
self.screen_resolution.height() // 4 - 10)
bottom_dock = QWidget(self.bottom_dock_widget)
bottom_dock.setMinimumSize(self.screen_resolution.width() // 4 * 3 - 20,
self.screen_resolution.height() // 4 - 20)
bottom_dock.move(10, 10)
bottom_dock.setLayout(self.bottom_dock_layout)
settings_label = QLabel("Settings:")
self.bottom_dock_layout.addWidget(settings_label, 0, 0, 1, 2,
Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop)
countour_tresh_label = QLabel("Countour Tresh:")
self.bottom_dock_layout.addWidget(countour_tresh_label, 1, 0, 1, 1, Qt.AlignmentFlag.AlignTop)
self.countour_tresh_slider = QSlider(Qt.Orientation.Horizontal)
self.countour_tresh_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
self.countour_tresh_slider.setRange(self._countour_min_tresh, self._countour_max_tresh)
self.countour_tresh_slider.setValue(2)
self.bottom_dock_layout.addWidget(self.countour_tresh_slider, 1, 1, 1, 1, Qt.AlignmentFlag.AlignTop)
transparency_weight_label = QLabel("Transparency:")
self.bottom_dock_layout.addWidget(transparency_weight_label, 2, 0, 1, 1, Qt.AlignmentFlag.AlignTop)
self.transparency_weight_slider = QSlider(Qt.Orientation.Horizontal)
self.transparency_weight_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
self.transparency_weight_slider.setValue(6)
self.transparency_weight_slider.setRange(self._transparency_min, self._transparency_max)
self.bottom_dock_layout.addWidget(self.transparency_weight_slider, 2, 1, 1, 1, Qt.AlignmentFlag.AlignTop)
countour_gamma_label = QLabel("Countour Gamma:")
self.bottom_dock_layout.addWidget(countour_gamma_label, 3, 0, 1, 1, Qt.AlignmentFlag.AlignTop)
self.countour_gamma_slider = QSlider(Qt.Orientation.Horizontal)
self.countour_gamma_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
self.countour_gamma_slider.setValue(8)
self.countour_gamma_slider.setRange(self._countour_gamma_min, self._countour_gamma_max)
self.bottom_dock_layout.addWidget(self.countour_gamma_slider, 3, 1, 1, 1, Qt.AlignmentFlag.AlignTop)
### right side of settings
countour_color_label = QLabel("Countour Color:")
self.bottom_dock_layout.addWidget(countour_color_label, 0, 2, 1, 2,
Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop)
r_color_label = QLabel("R:")
self.bottom_dock_layout.addWidget(r_color_label, 1, 2, 1, 1, Qt.AlignmentFlag.AlignTop)
self.r_color_slider = QSlider(Qt.Orientation.Horizontal)
self.r_color_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
self.r_color_slider.setRange(self._color_min, self._color_max)
self.r_color_slider.setValue(255)
self.bottom_dock_layout.addWidget(self.r_color_slider, 1, 3, 1, 1, Qt.AlignmentFlag.AlignTop)
g_color_label = QLabel("G:")
self.bottom_dock_layout.addWidget(g_color_label, 2, 2, 1, 1, Qt.AlignmentFlag.AlignTop)
self.g_color_slider = QSlider(Qt.Orientation.Horizontal)
self.g_color_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
self.g_color_slider.setRange(self._color_min, self._color_max)
self.bottom_dock_layout.addWidget(self.g_color_slider, 2, 3, 1, 1, Qt.AlignmentFlag.AlignTop)
b_color_label = QLabel("B:")
self.bottom_dock_layout.addWidget(b_color_label, 3, 2, 1, 1, Qt.AlignmentFlag.AlignTop)
self.b_color_slider = QSlider(Qt.Orientation.Horizontal)
self.b_color_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
self.b_color_slider.setRange(self._color_min, self._color_max)
self.bottom_dock_layout.addWidget(self.b_color_slider, 3, 3, 1, 1, Qt.AlignmentFlag.AlignTop)
self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, self.bottom_dock_widget)
self.setCorner(Qt.Corner.BottomRightCorner, Qt.DockWidgetArea.RightDockWidgetArea)
def init_image_difference(self):
self.image_difference_thread = imageDifference()
self.get_template_filename.connect(self.image_difference_thread.set_template_image)
self.countour_tresh_slider.valueChanged.connect(self.image_difference_thread.set_countour_tresh_value)
self.transparency_weight_slider.valueChanged.connect(self.image_difference_thread.set_transparency_weight_value)
self.countour_gamma_slider.valueChanged.connect(self.image_difference_thread.set_countour_gamma_value)
self.r_color_slider.valueChanged.connect(self.image_difference_thread.set_countour_color_r)
self.g_color_slider.valueChanged.connect(self.image_difference_thread.set_countour_color_g)
self.b_color_slider.valueChanged.connect(self.image_difference_thread.set_countour_color_b)
self.image_difference_thread.output_image_defference.connect(self.mat2qimage)
self.image_difference_thread.set_template_picture.connect(self.set_template_picture)
self.image_difference_thread.start()
def detect_webcam_devices(self, combo_box):
_video_capture = cv2.VideoCapture()
_dev_id = 0
while (_dev_id < 3):
if _video_capture.open(_dev_id):
combo_box.addItem("Device #" + str(_dev_id + 1), _dev_id)
_dev_id += 1
else:
_dev_id += 1
_video_capture.release()
def load_template(self):
index = self.directory_tree_view.selectedIndexes()[0]
if not QFileInfo(self.file_system_model.filePath(index)).isDir():
# print("load template, path:", self.file_system_model.filePath(index))
self.get_template_filename.emit(self.file_system_model.filePath(index))
def create_template(self):
if self.stream is not None:
template_to_save = self.stream.get_current_frame()
cv2.imwrite("../image_difference/examples/template.jpg", template_to_save)
print("create template")
pyqtSlot(np.ndarray)
def mat2qimage(self, image):
rgbImage = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
rgbImage = cv2.resize(rgbImage, (self.output_picture.size().width(),
self.output_picture.size().height()))
# rgbImage = imutils.resize(rgbImage, height=self.output_picture.height())
h, w, ch = rgbImage.shape
bytesPerLine = ch * w
result_image = QImage(rgbImage.data, w, h, bytesPerLine, QImage.Format_RGB888)
self.output_picture.setPixmap(QPixmap.fromImage(result_image))
pyqtSlot(np.ndarray)
def set_template_picture(self, image):
rgbImage = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# rgbImage = cv2.resize(rgbImage, (self.template_image.size().width(),
# self.template_image.size().height()))
rgbImage = imutils.resize(rgbImage, self.template_image.size().width())
h, w, ch = rgbImage.shape
bytesPerLine = ch * w
result_image = QImage(rgbImage.data, w, h, bytesPerLine, QImage.Format_RGB888)
self.template_image.setPixmap(QPixmap.fromImage(result_image))
if not self.template_set:
self.template_set = True
self.stream.getframe.disconnect(self.mat2qimage)
self.stream.getframe.connect(self.image_difference_thread.get_image)
self.image_difference_thread.output_image_defference.connect(self.mat2qimage)
def camera_switcher_index_changed(self, index):
self.camera_changed.emit(self.webcam_switcher.itemData(index))
print("current index:", index)
print("item data:", self.webcam_switcher.itemData(index))
def closeEvent(self, event):
self.exit_program.emit()
event.accept()
class Explorer(QWidget):
def __init__(self, rootdir=QDir.rootPath()):
QWidget.__init__(self)
self.treeview = QTreeView()
self.listview = QListView()
self.path = rootdir
self.filename = ''
self.filepath = rootdir
self.canvas = None
self.col_selector = None
self.header = ''
self.xcol = [1]
self.ycol = [1]
self.ncols = 0
self.dirModel = QFileSystemModel()
self.dirModel.setRootPath(self.path)
self.dirModel.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)
self.fileModel = QFileSystemModel()
self.fileModel.setRootPath(self.filepath)
self.fileModel.setFilter(QDir.NoDotAndDotDot | QDir.Files)
self.fileModel.setNameFilters(['*.txt'])
self.fileModel.setNameFilterDisables(0)
self.treeview.setModel(self.dirModel)
self.listview.setModel(self.fileModel)
for i in [1, 2, 3]: self.treeview.setColumnHidden(i, True)
self.treeview.setHeaderHidden(True)
self.treeview.setRootIndex(self.dirModel.index(self.path))
self.listview.setRootIndex(self.fileModel.index(self.path))
self.treeview.clicked.connect(self.on_clicked)
self.listview.selectionModel().currentChanged.connect(self.file_selected)
self.listview.selectionModel().currentChanged.connect(lambda: self.canvas.update_plot(self))
self.listview.selectionModel().currentChanged.connect(lambda: self.col_selector.update_range(self.ncols))
def on_clicked(self, index):
self.path = self.dirModel.fileInfo(index).absoluteFilePath()
self.listview.setRootIndex(self.fileModel.setRootPath(self.path))
def file_selected(self, index):
self.filename = self.fileModel.fileName(index)
self.filepath = self.fileModel.filePath(index)
self.load_file()
def load_file(self):
try:
if self.filepath.endswith('.txt'):
with open(self.filepath, 'r') as file:
self.header, self.xcol, self.ycol = '', [], []
for ln in file:
if ln.startswith('#'):
self.header += ln[2:]
else:
cols = ln.split('\t')
self.xcol.append(float(cols[0]))
self.ycol.append(float(cols[self.col_selector.sp.value()]))
self.ncols = len(cols)
self.col_selector.update_range(self.ncols)
except:
self.header, self.xcol, self.ycol = '', [0], [0]
def update_rootdir(self, rootdir):
self.path = rootdir
self.treeview.setRootIndex(self.dirModel.index(self.path))
self.listview.setRootIndex(self.fileModel.index(self.path))
class LogInspectorWindow(QMainWindow):
def __init__(self, configFilePath, parent=None):
super(LogInspectorWindow, self).__init__(parent)
self.initMatPlotLib()
self.configFilePath = configFilePath
folder = os.path.dirname(self.configFilePath)
if not os.path.exists(folder):
os.makedirs(folder)
if os.path.exists(self.configFilePath):
# config.yaml found. Read from file.
file = open(self.configFilePath, 'r')
self.config = yaml.safe_load(file)
file.close()
else:
# config.yaml not found. Create new file.
self.config = {}
self.config['logs_directory'] = os.path.join(
os.path.expanduser("~"), "Documents", "Inertial_Sense", "Logs")
self.config['directory'] = ""
self.config['serials'] = ["ALL"]
file = open(self.configFilePath, 'w')
yaml.dump(self.config, file)
file.close()
self.currently_selected = 'posNEDMap'
self.downsample = 5
self.plotargs = None
self.log = None
self.plotter = None
def initMatPlotLib(self):
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.figure.subplots_adjust(left=0.05,
right=0.99,
bottom=0.05,
top=0.91,
wspace=0.2,
hspace=0.2)
def addButton(self, name, function, multithreaded=True, layout=None):
setattr(self, name + "button", QPushButton(name))
# if multithreaded:
# setattr(self, name+"buttonThread", Thread(target=function))
# getattr(self, name+"button").pressed.connect(self.startLoadingIndicator)
# getattr(self, name+"button").released.connect(getattr(self, name+"buttonThread").start)
# else:
getattr(self, name + "button").clicked.connect(function)
# getattr(self, name + "button").setMinimumWidth(220)
if layout is None:
if self.buttonLayoutRightCol.count(
) < self.buttonLayoutMiddleCol.count():
self.buttonLayoutRightCol.addWidget(
getattr(self, name + "button"))
elif self.buttonLayoutMiddleCol.count(
) < self.buttonLayoutLeftCol.count():
self.buttonLayoutMiddleCol.addWidget(
getattr(self, name + "button"))
else:
self.buttonLayoutLeftCol.addWidget(
getattr(self, name + "button"))
else:
layout.addWidget(getattr(self, name + "button"))
def updatePlot(self):
self.plot(self.currently_selected, self.plotargs)
def updateWindowTitle(self):
if np.shape(self.log.data[0, DID_DEV_INFO])[0] != 0:
info = self.log.data[0, DID_DEV_INFO][0]
infoStr = 'SN' + str(info[1]) + ', H:' + verArrayToString(
info[2]) + ', F:' + verArrayToString(
info[3]) + ' build ' + str(
info[4]) + ', ' + dateTimeArrayToString(
info[8], info[9]) + ', ' + info[10].decode('UTF-8')
self.setWindowTitle("LogInspector - " + infoStr)
def choose_directory(self):
log_dir = config['logs_directory']
directory = QFileDialog.getExistingDirectory(
parent=self, caption='Choose Log Directory', directory=log_dir)
if directory != '':
try:
self.load(directory)
except Exception as e:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Unable to load log: " + e.__str__())
msg.setDetailedText(traceback.format_exc())
msg.exec()
def load(self, directory):
print("loading files from " + directory)
# if self.log is None:
self.log = Log()
self.log.load(directory)
print("done loading")
self.plotter = logPlot(False, False, 'svg', self.log)
self.plotter.setDownSample(self.downsample)
# str = ''
# if self.log.navMode:
# str += 'NAV '
# if self.log.rtk:
# str += 'RTK '
# if self.log.compassing:
# str += 'Comp '
# self.statusLabel.setText(str)
self.updatePlot()
self.updateWindowTitle()
self.stopLoadingIndicator()
def setupUi(self):
self.setObjectName("LogInspector")
self.setWindowTitle("LogInspector")
self.resize(1280, 900)
self.setWindowFlags(self.windowFlags() | QtCore.Qt.WindowSystemMenuHint
| QtCore.Qt.WindowMinMaxButtonsHint)
self.setWindowIcon(QIcon("assets/Magnifying_glass_icon.png"))
# MainWindow.showMaximized()
self.createFileTree()
self.createButtonColumn()
self.formatButtonColumn()
self.createBottomToolbar()
self.figureLayout = QVBoxLayout()
self.figureLayout.addWidget(self.canvas)
self.figureLayout.addLayout(self.toolLayout)
self.figureLayout.setStretchFactor(self.canvas, 1)
layout = QHBoxLayout()
layout.addLayout(self.controlLayout)
layout.addLayout(self.figureLayout)
layout.setStretch(1, 1)
widget = QWidget()
widget.setLayout(layout)
self.setCentralWidget(widget)
# self.resize(1280, 900)
self.resize(1450, 1000)
self.setAcceptDrops(True)
def createButtonColumn(self):
self.controlLayout = QVBoxLayout()
self.buttonLayoutLeftCol = QVBoxLayout()
self.buttonLayoutMiddleCol = QVBoxLayout()
self.buttonLayoutRightCol = QVBoxLayout()
self.addButton('Pos NED Map', lambda: self.plot('posNEDMap'))
self.addButton('Pos NED', lambda: self.plot('posNED'))
self.addButton('Pos LLA', lambda: self.plot('posLLA'))
self.addButton('GPS LLA', lambda: self.plot('llaGps'))
self.addButton('Vel NED', lambda: self.plot('velNED'))
self.addButton('Vel UVW', lambda: self.plot('velUVW'))
self.addButton('Attitude', lambda: self.plot('attitude'))
self.addButton('Heading', lambda: self.plot('heading'))
self.addButton('INS Status', lambda: self.plot('insStatus'))
self.addButton('HDW Status', lambda: self.plot('hdwStatus'))
self.addButton('GPS 1 Stats', lambda: self.plot('gpsStats'))
self.addButton('GPS 2 Stats', lambda: self.plot('gps2Stats'))
self.addButton('RTK Pos Stats', lambda: self.plot('rtkPosStats'))
self.addButton('RTK Cmp Stats', lambda: self.plot('rtkCmpStats'))
self.addButton('Flash Config', lambda: self.showFlashConfig())
self.addButton('Device Info', lambda: self.showDeviceInfo())
self.addButton('IMU PQR', lambda: self.plot('imuPQR'))
self.addButton('IMU Accel', lambda: self.plot('imuAcc'))
self.addButton('PSD PQR', lambda: self.plot('gyroPSD'))
self.addButton('PSD Accel', lambda: self.plot('accelPSD'))
self.addButton('Magnetometer', lambda: self.plot('magnetometer'))
self.addButton('Temp', lambda: self.plot('temp'))
def formatButtonColumn(self):
self.buttonLayoutLeftCol.setAlignment(QtCore.Qt.AlignTop)
self.buttonLayoutMiddleCol.setAlignment(QtCore.Qt.AlignTop)
self.buttonLayoutRightCol.setAlignment(QtCore.Qt.AlignTop)
self.buttonColumnLayout = QHBoxLayout()
self.buttonColumnLayout.addLayout(self.buttonLayoutLeftCol)
self.buttonColumnLayout.addLayout(self.buttonLayoutMiddleCol)
self.buttonColumnLayout.addLayout(self.buttonLayoutRightCol)
self.controlLayout.addLayout(self.buttonColumnLayout)
self.controlDirLayout = QHBoxLayout()
self.controlDirLayout.addWidget(self.dirLineEdit)
self.controlLayout.addLayout(self.controlDirLayout)
self.controlLayout.addWidget(self.fileTree)
# self.buttonLayout.addItem(QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding))
# self.addButton('load', self.choose_directory, multithreaded=False)
def createBottomToolbar(self):
self.toolLayout = QHBoxLayout()
self.toolLayout.addWidget(self.toolbar)
self.loadingIndictator = QLabel()
self.loadingMovie = QMovie('assets/loader.gif')
self.emptyLoadingPicture = QPicture()
self.emptyLoadingPicture.load('assets/empty_loader.png')
self.stopLoadingIndicator()
self.toolLayout.addWidget(self.loadingIndictator)
self.toolLayout.addItem(
QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding))
# self.toolLayout.addWidget(QSpacerItem(150, 10, QSizePolicy.Expanding))
self.copyImagePushButton = QPushButton()
# self.copyImagePushButton.setText("Copy")
# self.copyImagePushButton.setMinimumWidth(1)
# self.copyImagePushButton.style().standardIcon(QStyle.SP_DialogOpenButton)
self.copyImagePushButton.setIcon(self.style().standardIcon(
QStyle.SP_DialogSaveButton))
self.toolLayout.addWidget(self.copyImagePushButton)
self.copyImagePushButton.clicked.connect(self.copyPlotToClipboard)
downsampleLabel = QLabel()
downsampleLabel.setText("DS")
self.downSampleInput = QSpinBox()
self.downSampleInput.setValue(self.downsample)
self.toolLayout.addWidget(downsampleLabel)
self.toolLayout.addWidget(self.downSampleInput)
self.downSampleInput.valueChanged.connect(self.changeDownSample)
self.statusLabel = QLabel()
self.toolLayout.addWidget(self.statusLabel)
def changeDownSample(self, val):
self.downsample = val
self.plotter.setDownSample(self.downsample)
self.updatePlot()
def copyPlotToClipboard(self):
# pixmap = QPixmap.grabWidget(self.canvas)
# QApplication.clipboard().setPixmap(pixmap)
# pixmap.save('test.png')
# store the image in a buffer using savefig(), this has the
# advantage of applying all the default savefig parameters
# such as background color; those would be ignored if you simply
# grab the canvas using Qt
buf = io.BytesIO()
self.figure.savefig(buf)
QApplication.clipboard().setImage(QImage.fromData(buf.getvalue()))
buf.close()
def startLoadingIndicator(self):
self.loadingIndictator.setMovie(self.loadingMovie)
self.loadingMovie.start()
def dragEnterEvent(self, e):
if (e.mimeData().hasUrls()):
e.acceptProposedAction()
def dropEvent(self, e):
try:
directory = e.mimeData().urls()[0].toLocalFile()
self.load(directory)
except Exception as e:
self.showError(e)
def showError(self, e):
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Unable to load log: " + e.__str__())
msg.setDetailedText(traceback.format_exc())
msg.exec()
def createFileTree(self):
self.dirModel = QFileSystemModel()
self.dirModel.setRootPath(self.config["logs_directory"])
self.dirModel.setFilter(QtCore.QDir.Dirs | QtCore.QDir.NoDotAndDotDot)
self.dirLineEdit = QLineEdit()
self.dirLineEdit.setText(self.config["logs_directory"])
self.dirLineEdit.setFixedHeight(25)
self.dirLineEdit.returnPressed.connect(self.handleTreeDirChange)
self.fileTree = QTreeView()
self.fileTree.setModel(self.dirModel)
self.fileTree.setRootIndex(
self.dirModel.index(self.config['logs_directory']))
self.fileTree.setColumnHidden(1, True)
self.fileTree.setColumnHidden(2, True)
self.fileTree.setColumnHidden(3, True)
self.fileTree.setMinimumWidth(300)
self.fileTree.clicked.connect(self.handleTreeViewClick)
self.fileTree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.fileTree.setSelectionMode(QAbstractItemView.SingleSelection)
self.fileTree.customContextMenuRequested.connect(
self.handleTreeViewRightClick)
# self.populateRMSCheck(self.config['logs_directory'])
def updateFileTree(self):
self.dirModel.setRootPath(self.config["logs_directory"])
self.fileTree.setRootIndex(
self.dirModel.index(self.config['logs_directory']))
def populateRMSCheck(self, directory):
for subdir in os.listdir(directory):
path = os.path.join(directory, subdir)
if os.path.isdir(path):
self.populateRMSCheck(path)
elif 'RMS' in subdir:
f = open(path)
rms_report = f.read()
p = re.compile(r'(?<=^PASS/FAIL).*\n', re.M)
line = re.search(p, rms_report).group()
failed = True if "FAIL" in line else False
if failed:
pass
else:
pass
def handleTreeDirChange(self):
self.config["logs_directory"] = self.dirLineEdit.text()
self.updateFileTree()
file = open(self.configFilePath, 'w')
yaml.dump(self.config, file)
file.close()
def handleTreeViewClick(self):
selected_directory = self.fileTree.model().filePath(
self.fileTree.selectedIndexes()[0])
for fname in os.listdir(selected_directory):
if fname.endswith('.dat'):
try:
self.load(selected_directory)
except Exception as e:
self.showError(e)
break
def handleTreeViewRightClick(self, event):
selected_directory = os.path.normpath(self.fileTree.model().filePath(
self.fileTree.selectedIndexes()[0]))
menu = QMenu(self)
copyAction = menu.addAction("Copy path")
nppActionHot = menu.addAction("Run NPP, HOT start")
nppActionCold = menu.addAction("Run NPP, COLD start")
nppActionFactory = menu.addAction("Run NPP, FACTORY start")
setDataInfoDirHotAction = menu.addAction(
"Set dataInfo.json directory, HOT start")
setDataInfoDirColdAction = menu.addAction(
"Set dataInfo.json directory, COLD start")
setDataInfoDirFactoryAction = menu.addAction(
"Set dataInfo.json directory, FACTORY start")
exploreAction = menu.addAction("Explore folder")
cleanFolderAction = menu.addAction("Clean folder")
deleteFolderAction = menu.addAction("Delete folder")
action = menu.exec_(self.fileTree.viewport().mapToGlobal(event))
if action == copyAction:
cb = QApplication.clipboard()
cb.clear(mode=cb.Clipboard)
cb.setText(selected_directory, mode=cb.Clipboard)
if action == nppActionHot:
cleanFolder(selected_directory)
setDataInformationDirectory(selected_directory,
startMode=START_MODE_HOT)
sys.path.insert(1, '../../../../python/src')
from supernpp.supernpp import SuperNPP
spp = SuperNPP(selected_directory, self.config['serials'])
spp.run()
if action == nppActionCold:
cleanFolder(selected_directory)
setDataInformationDirectory(selected_directory,
startMode=START_MODE_COLD)
sys.path.insert(1, '../../../../python/src')
from supernpp.supernpp import SuperNPP
spp = SuperNPP(selected_directory,
self.config['serials'],
startMode=START_MODE_COLD)
spp.run()
if action == nppActionFactory:
cleanFolder(selected_directory)
setDataInformationDirectory(selected_directory,
startMode=START_MODE_FACTORY)
sys.path.insert(1, '../../../../python/src')
from supernpp.supernpp import SuperNPP
spp = SuperNPP(selected_directory,
self.config['serials'],
startMode=START_MODE_FACTORY)
spp.run()
if action == setDataInfoDirHotAction:
setDataInformationDirectory(selected_directory,
startMode=START_MODE_HOT)
if action == setDataInfoDirColdAction:
setDataInformationDirectory(selected_directory,
startMode=START_MODE_COLD)
if action == setDataInfoDirFactoryAction:
setDataInformationDirectory(selected_directory,
startMode=START_MODE_FACTORY)
if action == exploreAction:
openFolderWithFileBrowser(selected_directory)
if action == cleanFolderAction:
cleanFolder(selected_directory)
if action == deleteFolderAction:
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Question)
msg.setText("Are you sure you want to delete this folder?\n\n" +
selected_directory)
msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
result = msg.exec()
if result == QMessageBox.Yes:
removeDirectory(selected_directory)
def stopLoadingIndicator(self):
self.loadingMovie.stop()
self.loadingIndictator.clear()
self.loadingIndictator.setPicture(self.emptyLoadingPicture)
def showDeviceInfo(self):
dlg = DeviceInfoDialog(self.log, self)
dlg.show()
dlg.exec_()
def showFlashConfig(self):
dlg = FlashConfigDialog(self.log, self)
dlg.show()
dlg.exec_()
def plot(self, func, args=None):
print("plotting " + func)
self.currently_selected = func
self.plotargs = args
self.figure.clear()
if hasattr(self, 'plotter'):
if args is not None:
getattr(self.plotter, func)(*args, self.figure)
else:
getattr(self.plotter, func)(self.figure)
self.canvas.draw()
self.stopLoadingIndicator()
print("done plotting")
class AssetBrowser(QMainWindow, Ui_MainWindow, PlaygroundModule):
Name = "asset_browser"
def __init__(self, module_manager):
super(AssetBrowser, self).__init__()
self.setupUi(self)
self.init_module(module_manager)
self.dir_model = QFileSystemModel()
self.dir_model.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)
self.dir_model.setReadOnly(False)
self.dir_view.setModel(self.dir_model)
self.dir_view.hideColumn(1)
self.dir_view.hideColumn(2)
self.dir_view.hideColumn(3)
self.file_model = QFileSystemModel()
self.file_model.setFilter(QDir.NoDotAndDotDot | QDir.Files)
self.file_model.setReadOnly(False)
self.file_view.setModel(self.file_model)
self.dock = self.modules_manager.new_docked(self, self.Name, "Asset browser",
Qt.BottomDockWidgetArea)
self.modules_manager.main_window.splitDockWidget(self.dock,
self.modules_manager["asset_view"].dock, Qt.Horizontal)
def on_open_project(self, project):
project_dir = project.project_dir
path = os.path.join(project_dir)
self.dir_model.setRootPath(path)
self.file_model.setRootPath(path)
self.dir_view.setRootIndex(self.dir_model.index(path))
self.file_view.setRootIndex(self.file_model.index(path))
def dir_clicked(self, idx):
path = self.dir_model.fileInfo(idx).absoluteFilePath()
self.file_view.setRootIndex(self.file_model.setRootPath(path))
def file_doubleclicked(self, idx):
fileinfo = self.file_model.fileInfo(idx)
path = fileinfo.absoluteFilePath()
ext = fileinfo.suffix()
asset_name = path.replace(self.project_manager.project_dir, '').replace('/src/', '').split('.')[0]
self.modules_manager.open_asset(path, asset_name, ext)
def file_clicked(self, idx):
fileinfo = self.file_model.fileInfo(idx)
path = fileinfo.absoluteFilePath()
ext = fileinfo.suffix()
asset_name = path.replace(self.project_manager.project_dir, '').replace('/src/', '').split('.')[0]
self.modules_manager.show_asset(path, asset_name, ext)
class Dialog_ImageFolder():
def __init__(self, parent, title, init_path):
self.w = QDialog(parent)
self.parent = parent
self.left = 300
self.top = 300
self.width = 600
self.height = 400
self.title = title
self.dirModel = QFileSystemModel()
self.dirModel.setRootPath(init_path)
self.dirModel.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)
self.treeview = QTreeView()
self.treeview.setModel(self.dirModel)
self.treeview.setRootIndex(self.dirModel.index(""))
self.treeview.clicked.connect(self.on_clicked)
#--- Hide All Header Sections Except First ----
header = self.treeview.header()
for sec in range(1, header.count()):
header.setSectionHidden(sec, True)
#--- ---- ---- ---- ---- ---- ---- ---- ---- --
focus_index = self.dirModel.index(init_path)
self.treeview.setCurrentIndex(focus_index)
self.current_row_changed()
self.listview = QListView()
self.listview.setViewMode(QListView.IconMode)
self.listview.setIconSize(QSize(192, 192))
targetfiles1 = glob.glob(os.path.join(init_path, '*.png'))
targetfiles2 = glob.glob(os.path.join(init_path, '*.tif'))
targetfiles3 = glob.glob(os.path.join(init_path, '*.tiff'))
targetfiles = targetfiles1 + targetfiles2 + targetfiles3
lm = _MyListModel(targetfiles, self.parent)
self.listview.setModel(lm)
self.sub_layout = QHBoxLayout()
self.sub_layout.addWidget(self.treeview)
self.sub_layout.addWidget(self.listview)
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Open
| QDialogButtonBox.Cancel)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.main_layout = QVBoxLayout()
self.main_layout.addLayout(self.sub_layout)
self.main_layout.addWidget(self.buttonBox)
self.w.setGeometry(self.left, self.top, self.width, self.height)
self.w.setWindowTitle(self.title)
self.w.setWindowIcon(QIcon(os.path.join(icon_dir, 'Mojo2_16.png')))
self.w.setLayout(self.main_layout)
def current_row_changed(self):
index = self.treeview.currentIndex()
self.treeview.scrollTo(index, QAbstractItemView.EnsureVisible)
self.treeview.resizeColumnToContents(0)
def on_clicked(self, index):
path = self.dirModel.fileInfo(index).absoluteFilePath()
targetfiles1 = glob.glob(os.path.join(path, '*.png'))
targetfiles2 = glob.glob(os.path.join(path, '*.tif'))
targetfiles3 = glob.glob(os.path.join(path, '*.tiff'))
targetfiles = targetfiles1 + targetfiles2 + targetfiles3
lm = _MyListModel(targetfiles, self.parent)
self.listview.setModel(lm)
def accept(self):
index = self.treeview.currentIndex()
self.newdir = self.dirModel.filePath(index)
self.w.done(1)
def reject(self):
self.w.done(0)
def GetValue(self):
index = self.treeview.currentIndex()
self.newdir = self.dirModel.filePath(index)
return self.newdir
class NProject(QObject):
"""Project representation.
SIGNALS:
@projectPropertiesUpdated()
"""
projectPropertiesUpdated = pyqtSignal()
projectNameUpdated = pyqtSignal(str)
def __init__(self, path):
super(NProject, self).__init__()
project = json_manager.read_ninja_project(path)
self.path = path
self._name = project.get('name', '')
if self._name == '':
self._name = file_manager.get_basename(path)
self.project_type = project.get('project-type', '')
self.description = project.get('description', '')
if self.description == '':
self.description = translations.TR_NO_DESCRIPTION
self.url = project.get('url', '')
self.license = project.get('license', '')
self.main_file = project.get('mainFile', '')
self.pre_exec_script = project.get('preExecScript', '')
self.post_exec_script = project.get('postExecScript', '')
self.indentation = project.get('indentation', settings.INDENT)
self.use_tabs = project.get('use-tabs', settings.USE_TABS)
self.extensions = project.get('supported-extensions',
settings.SUPPORTED_EXTENSIONS)
self.python_exec = project.get('pythonExec', settings.PYTHON_EXEC)
self.python_path = project.get('PYTHONPATH', '')
self.additional_builtins = project.get('additional_builtins', [])
self.program_params = project.get('programParams', '')
self.venv = project.get('venv', '')
self.related_projects = project.get('relatedProjects', [])
self.added_to_console = False
self.is_current = False
#Model is a QFileSystemModel to be set on runtime
self.__model = QFileSystemModel()
self.__model.setRootPath(path)
def _get_name(self):
return self._name
def _set_name(self, name):
if name == '':
self._name = file_manager.get_basename(self.path)
else:
self._name = name
self.projectNameUpdated.emit(self._name)
name = property(_get_name, _set_name)
def save_project_properties(self):
#save project properties
project = {}
project['name'] = self._name
project['description'] = self.description
project['url'] = self.url
project['license'] = self.license
project['mainFile'] = self.main_file
project['project-type'] = self.project_type
project['supported-extensions'] = self.extensions
project['indentation'] = self.indentation
project['use-tabs'] = self.use_tabs
project['pythonExec'] = self.python_exec # FIXME
project['PYTHONPATH'] = self.python_path
project['additional_builtins'] = self.additional_builtins
project['preExecScript'] = self.pre_exec_script
project['postExecScript'] = self.post_exec_script
project['venv'] = self.venv
project['programParams'] = self.program_params
project['relatedProjects'] = self.related_projects
if file_manager.file_exists(self.path, self._name + '.nja'):
file_manager.delete_file(self.path, self._name + '.nja')
json_manager.create_ninja_project(self.path, self._name, project)
#TODO: update project tree on extensions changed
@property
def full_path(self):
'''
Returns the full path of the project
'''
project_file = json_manager.get_ninja_project_file(self.path)
if not project_file: # FIXME: If we dont have a project file
project_file = '' # we should do SOMETHING! like kill zombies!
return os.path.join(self.path, project_file)
@property
def python_exec_command(self):
'''
Returns the python exec command of the project
'''
if self.venv is '':
return self.venv
return self.python_exec
@property
def model(self):
return self.__model
@model.setter
def model(self, model): # lint:ok
self.__model = model
self.__model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot |
QDir.AllEntries)
self.__model.setNameFilters(self.extensions)
@model.deleter
def model(self): # lint:ok
del(self.__model)
class ViewerWindow(QWidget):
statusWindow: QLabel = None
bottomStatus: QLabel = None
fsDirModel: QFileSystemModel = None
fsFileModel: QFileSystemModel = None
fsTree: QTreeView = None
fsList: QListView = None
def makeTop(self):
topBox = QHBoxLayout()
self.statusWidget = QLabel('')
self.statusWidget.setMinimumHeight(1)
self.statusWidget.setMaximumHeight(1)
self.statusWidget.setStyleSheet(
"QLabel { background-color : lightgray; color : black; }")
topBox.addWidget(self.statusWidget)
return topBox
@pyqtSlot(QModelIndex)
def onDirChange(self, index):
mPath = self.fsDirModel.fileInfo(index).absoluteFilePath()
self.fsList.setRootIndex(self.fsFileModel.setRootPath(mPath))
print("Dir=%s", mPath)
def makeExplorer(self, under):
self.fsDirModel = QFileSystemModel()
self.fsDirModel.setFilter(QDir.Dirs | QDir.Drives | QDir.NoDotAndDotDot
| QDir.AllDirs)
self.fsDirModel.setRootPath("")
self.fsTree = QTreeView()
self.fsTree.setModel(self.fsDirModel)
self.fsTree.clicked.connect(self.onDirChange)
self.fsTree.hideColumn(1)
self.fsTree.hideColumn(2)
self.fsTree.hideColumn(3)
self.fsTree.hideColumn(4)
self.fsTree.setStyleSheet(
"QLabel { background-color : green; color : blue; }")
return self.fsTree
def makeFiles(self, under):
self.fsFileModel = QFileSystemModel()
self.fsFileModel.setFilter(QDir.NoDotAndDotDot | QDir.Files)
self.fsFileModel.setRootPath("")
self.fsList = QListView()
self.fsList.setModel(self.fsFileModel)
self.fsList.setStyleSheet(
"QLabel { background-color : lightblue; color : blue; }")
return self.fsList
def makeDisplay(selfself, under):
displayWidget = QLabel("Display")
displayWidget.setAlignment(QtCore.Qt.AlignCenter)
displayWidget.setStyleSheet(
"QLabel { background-color : pink; color : blue; }")
return displayWidget
def makeMiddle(self):
middleBox = QHBoxLayout()
explorerWidget = self.makeExplorer(middleBox)
explorerWidget.setMinimumHeight(300)
explorerWidget.setMinimumWidth(300)
explorerWidget.setMaximumWidth(400)
explorerWidget.setMaximumHeight(20000)
filesWidget = self.makeFiles(middleBox)
filesWidget.setMinimumHeight(300)
filesWidget.setMinimumWidth(300)
filesWidget.setMaximumWidth(400)
filesWidget.setMaximumHeight(20000)
displayWidget = self.makeDisplay(middleBox)
displayWidget.setMinimumHeight(300)
displayWidget.setMinimumWidth(300)
displayWidget.setMaximumHeight(20000)
middleBox.addWidget(explorerWidget)
middleBox.addWidget(filesWidget)
middleBox.addWidget(displayWidget)
return middleBox
@pyqtSlot()
def okOK(self):
print("Clicked")
def makeBottom(self):
bottomBox = QHBoxLayout()
self.bottomStatus = QLabel("Status")
self.bottomStatus.setMaximumHeight(20)
self.bottomStatus.setMinimumHeight(20)
self.bottomStatus.setStyleSheet(
"QLabel { background-color : lightgray; color : black; }")
bottomBox.addWidget(self.bottomStatus)
bottomOK = QPushButton("Quit", self)
bottomOK.setMaximumWidth(80)
bottomOK.setToolTip("Quit Application")
bottomOK.clicked.connect(self.okOK)
bottomBox.addWidget(bottomOK)
return bottomBox
def __init__(self):
super().__init__()
vbox = QVBoxLayout()
vbox.addLayout(self.makeTop())
vbox.addLayout(self.makeMiddle())
vbox.addLayout(self.makeBottom())
self.setLayout(vbox)
self.setWindowTitle("QtText")
self.setGeometry(200, 200, 800, 600)
class MyMainWindow(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.config_window()
self.create_widgets()
self.config_widgets()
self.create_menubar()
self.bind_widgets()
self.show_widgets()
def config_window(self):
self.setWindowTitle('DirectoPy')
self.setMinimumHeight(600)
self.setMinimumWidth(1000)
def create_widgets(self):
self.central_widget = QWidget()
self.main_layout = QGridLayout()
self.moveup_button = QPushButton('Collapse all', self)
self.goto_lineedit = QLineEdit('', self)
self.goto_button = QPushButton('Go', self)
self.folder_view = QTreeView(self)
self.file_view = QTreeView(self)
self.folder_model = QFileSystemModel(self)
self.file_model = QFileSystemModel(self)
def config_widgets(self):
self.main_layout.addWidget(self.moveup_button, 0, 0)
self.main_layout.addWidget(self.goto_lineedit, 0, 1, 1, 2)
self.main_layout.addWidget(self.goto_button, 0, 3)
self.main_layout.addWidget(self.folder_view, 1, 0, 1, 2)
self.main_layout.addWidget(self.file_view, 1, 2, 1, 2)
self.central_widget.setLayout(self.main_layout)
# Кнопка "вверх"
self.moveup_button.setMaximumWidth(100)
# Кнопка "перейти"
self.goto_button.setMaximumWidth(70)
self.setCentralWidget(self.central_widget)
# панели
self.folder_model.setRootPath(None)
self.folder_model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
self.folder_view.setModel(self.folder_model)
self.folder_view.setRootIndex(self.folder_model.index(None))
self.folder_view.clicked[QModelIndex].connect(self.clicked_onfolder)
self.folder_view.hideColumn(1)
self.folder_view.hideColumn(2)
self.folder_view.hideColumn(3)
self.file_model.setFilter(QDir.Files)
self.file_view.setModel(self.file_model)
self.file_model.setReadOnly(False)
self.file_view.setColumnWidth(0, 200)
self.file_view.setSelectionMode(QAbstractItemView.ExtendedSelection)
# открытие папки при нажати на неё в окне папок
def clicked_onfolder(self, index):
selection_model = self.folder_view.selectionModel()
index = selection_model.currentIndex()
dir_path = self.folder_model.filePath(index)
self.file_model.setRootPath(dir_path)
self.file_view.setRootIndex(self.file_model.index(dir_path))
# ф-я открытия нового файла
def open_file(self):
index = self.file_view.selectedIndexes()
if not index:
return
else:
index = index[0]
file_path = self.file_model.filePath(index).replace('/', '\\')
print(file_path)
self.file_view.update()
# ф-я создания нового файла
def new_file(self):
global file_name
index = self.folder_view.selectedIndexes()
if len(index) > 0:
path = self.folder_model.filePath(index[0])
for i in range(1, 9999999999999999):
if not os.path.isfile(os.path.join(path, "newfile{}.txt".format(i))):
file_name = os.path.join(path, "newfile{}.txt".format(i))
break
file_name = os.path.abspath(file_name)
open(file_name, 'w').close()
else:
print("Please, select folder")
# ф-я удаления файла
def delete_file(self):
indexes = self.file_view.selectedIndexes()
for i in indexes:
self.file_model.remove(i)
# ф-я переименования файла
def rename_file(self):
index = self.file_view.selectedIndexes()
if not index:
return
else:
index = index[0]
self.file_view.edit(index)
# ф-я копирования файла
def copy_file(self):
print("COPY")
ask = QFileDialog.getExistingDirectory(self, "Open Directory", "C:\\",
QFileDialog.ShowDirsOnly |
QFileDialog.DontResolveSymlinks)
new_path = ask.replace('\\', '/')
indexes = self.file_view.selectedIndexes()[::4]
for i in indexes:
new_filename = new_path + '/' + self.file_model.fileName(i)
copy2(self.file_model.filePath(i), new_filename)
# ф-я возвращения к корню пути
def colapse(self):
self.folder_view.collapseAll()
# ф-я перемещения в заданную директорию
def go_to(self):
dir_path = self.goto_lineedit.text().replace('\\', '/')
print(dir_path)
self.file_model.setRootPath(dir_path)
self.file_view.setRootIndex(self.file_model.index(dir_path))
#self.file_model.setRootPath()
# ф-я перемещения файла
def move_file(self):
print("MOVE")
ask = QFileDialog.getExistingDirectory(self, "Open Directory", "C:\\",
QFileDialog.ShowDirsOnly |
QFileDialog.DontResolveSymlinks)
if ask == '':
return
new_path = ask.replace('\\', '/')
indexes = self.file_view.selectedIndexes()[::4]
for i in indexes:
new_filename = new_path + '/' + self.file_model.fileName(i)
move(self.file_model.filePath(i), new_filename)
# ф-я создания новой папки
def new_folder(self):
global file_name
index = self.folder_view.selectedIndexes()
if len(index) > 0:
path = self.folder_model.filePath(index[0])
for i in range(1, 9999999999999999):
if not os.path.isdir(os.path.join(path, "newfolder{}".format(i))):
file_name = os.path.join(path, "newfolder{}".format(i))
break
file_name = os.path.abspath(file_name)
os.mkdir(file_name)
else:
print("Please, select folder")
# ф-я удаления папки
def delete_folder(self):
indexes = self.folder_view.selectedIndexes()
for i in indexes:
self.folder_model.remove(i)
# ф-я переименования папки
def rename_folder(self):
index = self.folder_view.selectedIndexes()
if not index:
return
else:
index = index[0]
self.folder_view.edit(index)
# ф-я закрытия окна файлового менеджера
def exit_application(self):
print("EXIT")
self.close()
# задавание функции каждой кнопке
def bind_widgets(self):
self.open_file_action.triggered.connect(self.open_file)
self.new_file_action.triggered.connect(self.new_file)
self.delete_file_action.triggered.connect(self.delete_file)
self.rename_file_action.triggered.connect(self.rename_file)
self.copy_file_action.triggered.connect(self.copy_file)
self.move_file_action.triggered.connect(self.move_file)
self.exit_action.triggered.connect(self.exit_application)
self.new_folder_action.triggered.connect(self.new_folder)
self.delete_folder_action.triggered.connect(self.delete_folder)
self.rename_folder_action.triggered.connect(self.rename_folder)
self.goto_button.clicked.connect(partial(self.go_to))
self.moveup_button.clicked.connect(partial(self.colapse))
# создание меню
def create_menubar(self):
self.exit_action = QAction('Exit', self)
self.exit_action.setShortcut('Ctrl+Q')
self.new_file_action = QAction('New file', self)
self.new_file_action.setShortcut('F4')
self.open_file_action = QAction('Open file', self)
self.open_file_action.setShortcut('F3')
self.rename_file_action = QAction('Rename file', self)
self.rename_file_action.setShortcut('F2')
self.delete_file_action = QAction('Remove file', self)
self.delete_file_action.setShortcut(QKeySequence.Delete)
self.copy_file_action = QAction('Copy folder...', self)
self.copy_file_action.setShortcut(QKeySequence.Copy)
self.move_file_action = QAction('Move folder...', self)
self.move_file_action.setShortcut(QKeySequence.Cut)
self.new_folder_action = QAction('New folder', self)
self.new_folder_action.setShortcut('Ctrl+Shift+N')
self.delete_folder_action = QAction('Delete folder', self)
self.delete_folder_action.setShortcut('Ctrl+Shift+Del')
self.rename_folder_action = QAction('Rename folder', self)
self.rename_folder_action.setShortcut('Ctrl+Shift+R')
self.menubar = self.menuBar()
self.file_menu = self.menubar.addMenu('File')
self.file_menu.addAction(self.new_file_action)
self.file_menu.addAction(self.open_file_action)
self.file_menu.addAction(self.rename_file_action)
self.file_menu.addAction(self.delete_file_action)
self.file_menu.addAction(self.copy_file_action)
self.file_menu.addAction(self.move_file_action)
self.file_menu.addSeparator()
self.file_menu.addAction(self.exit_action)
self.folder_menu = self.menubar.addMenu('Folder')
self.folder_menu.addAction(self.new_folder_action)
self.folder_menu.addAction(self.delete_folder_action)
self.folder_menu.addAction(self.rename_folder_action)
def show_widgets(self):
self.setLayout(self.main_layout)
class MainView(QMainWindow):
resizeCompleted = pyqtSignal()
def __init__(self, model, controller, image_path):
self.settings = SettingsModel()
self.slideshow = SlideshowModel()
self.model = model
self.canvas = self.model.canvas
self.main_controller = controller
self.canvas_controller = CanvasController(self.canvas)
super(MainView, self).__init__()
self.build_ui()
self.center_ui()
# Resize timer to prevent laggy updates
self.resize_timer = None
self.resizeCompleted.connect(self.resize_completed)
# Slideshow
if self.settings.get('Slideshow', 'reverse') == 'True':
self.slideshow.updateSignal.connect(self.on_previous_item)
else:
self.slideshow.updateSignal.connect(self.on_next_item)
self.model.subscribe_update_func(self.update_ui_from_model)
self.arguments = {
'image_path': image_path
}
def build_ui(self):
self.ui = Ui_Hitagi()
self.ui.setupUi(self)
# File menu
self.ui.actionSet_as_wallpaper.triggered.connect(self.on_set_as_wallpaper)
self.ui.actionCopy_to_clipboard.triggered.connect(self.on_clipboard)
self.ui.actionOpen_current_directory.triggered.connect(self.on_current_dir)
self.ui.actionOptions.triggered.connect(self.on_options)
self.ui.actionExit.triggered.connect(self.on_close)
# Folder menu
self.ui.actionOpen_next.triggered.connect(self.on_next_item)
self.ui.actionOpen_previous.triggered.connect(self.on_previous_item)
self.ui.actionChange_directory.triggered.connect(self.on_change_directory)
self.ui.actionSlideshow.triggered.connect(self.on_slideshow)
# View menu
self.ui.actionZoom_in.triggered.connect(self.on_zoom_in)
self.ui.actionZoom_out.triggered.connect(self.on_zoom_out)
self.ui.actionOriginal_size.triggered.connect(self.on_zoom_original)
self.ui.actionRotate_clockwise.triggered.connect(self.on_rotate_clockwise)
self.ui.actionRotate_counterclockwise.triggered.connect(self.on_rotate_counterclockwise)
self.ui.actionFlip_horizontally.triggered.connect(self.on_flip_horizontal)
self.ui.actionFlip_vertically.triggered.connect(self.on_flip_vertical)
self.ui.actionFit_image_width.triggered.connect(self.on_scale_image_to_width)
self.ui.actionFit_image_height.triggered.connect(self.on_scale_image_to_height)
self.ui.actionFile_list.triggered.connect(self.on_toggle_filelist)
self.ui.actionFullscreen.triggered.connect(self.on_fullscreen)
# Favorite menu
self.ui.actionAdd_to_favorites.triggered.connect(self.on_add_to_favorites)
self.ui.actionRemove_from_favorites.triggered.connect(self.on_remove_from_favorites)
# Help menu
self.ui.actionChangelog.triggered.connect(self.on_changelog)
self.ui.actionAbout.triggered.connect(self.on_about)
# Load stylesheet
stylesheet_dir = "resources/hitagi.stylesheet"
with open(stylesheet_dir, "r") as sh:
self.setStyleSheet(sh.read())
# File listing
self.file_model = QFileSystemModel()
self.file_model.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs | QDir.Files)
self.file_model.setNameFilters(['*.bmp', '*.gif', '*.jpg', '*.jpeg', '*.png', '*.png', '*.pbm', '*.pgm', '*.ppm', '*.xbm', '*.xpm'])
self.file_model.setNameFilterDisables(False)
self.file_model.setRootPath(self.settings.get('Directory', 'default'))
self.ui.treeView.setModel(self.file_model)
self.ui.treeView.setColumnWidth(0, 120)
self.ui.treeView.setColumnWidth(1, 120)
self.ui.treeView.hideColumn(1)
self.ui.treeView.hideColumn(2)
# Double click
self.ui.treeView.activated.connect(self.on_dir_list_activated)
# Update file list
self.ui.treeView.clicked.connect(self.on_dir_list_clicked)
# Open parent
self.ui.pushButton_open_parent.clicked.connect(self.on_open_parent)
self.ui.pushButton_favorite.clicked.connect(self.on_manage_favorite)
# Shortcuts
_translate = QCoreApplication.translate
self.ui.actionExit.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Exit')))
self.ui.actionOpen_next.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Next')))
self.ui.actionOpen_previous.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Previous')))
self.ui.actionChange_directory.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Directory')))
self.ui.actionAdd_to_favorites.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Add to favorites')))
self.ui.actionRemove_from_favorites.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Remove from favorites')))
self.ui.actionSlideshow.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Slideshow')))
self.ui.actionZoom_in.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Zoom in')))
self.ui.actionZoom_out.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Zoom out')))
self.ui.actionOriginal_size.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Zoom original')))
self.ui.actionRotate_clockwise.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Rotate clockwise')))
self.ui.actionRotate_counterclockwise.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Rotate counterclockwise')))
self.ui.actionFlip_horizontally.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Flip horizontal')))
self.ui.actionFlip_vertically.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Flip vertical')))
self.ui.actionFit_image_width.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Fit to width')))
self.ui.actionFit_image_height.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Fit to height')))
self.ui.actionFile_list.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Toggle filelist')))
self.ui.actionFullscreen.setShortcut(_translate("Hitagi", self.settings.get('Hotkeys', 'Fullscreen')))
# Load favorites in UI
self.load_favorites()
# Background
self.ui.graphicsView.setBackgroundBrush(QBrush(QColor(self.settings.get('Look', 'background')), Qt.SolidPattern))
# Save current height for fullscreen mode
self.default_menubar_height = self.ui.menubar.height()
# Save current width for file list
self.default_filelist_width = self.ui.fileWidget.width()
def load_favorites(self):
self.favorites = FavoritesModel()
self.ui.menuFavorites.clear()
for item in self.favorites.items():
self.ui.menuFavorites.addAction(item).triggered.connect((lambda item: lambda: self.on_open_favorite(item))(item))
def on_open_favorite(self, path):
self.main_controller.change_directory(path)
def center_ui(self):
ui_geometry = self.frameGeometry()
center_point = QDesktopWidget().availableGeometry().center()
ui_geometry.moveCenter(center_point)
self.move(ui_geometry.topLeft())
# Qt show event
def showEvent(self, event):
self.main_controller.start(self.arguments['image_path']) # Arguments and starting behaviour
# Start in fullscreen mode according to settings
if self.settings.get('Misc', 'fullscreen_mode') == 'True':
self.on_fullscreen()
# Initialize container geometry to canvas
self.canvas_controller.update(self.ui.graphicsView.width(), self.ui.graphicsView.height())
self.main_controller.update_canvas()
def update_resize_timer(self, interval=None):
if self.resize_timer is not None:
self.killTimer(self.resize_timer)
if interval is not None:
self.resize_timer = self.startTimer(interval)
else:
self.resize_timer = None
# Qt resize event
def resizeEvent(self, event):
self.update_resize_timer(300)
# Qt timer event
def timerEvent(self, event):
if event.timerId() == self.resize_timer:
self.update_resize_timer()
self.resizeCompleted.emit()
def resize_completed(self):
self.canvas_controller.update(self.ui.graphicsView.width(), self.ui.graphicsView.height())
self.main_controller.update_canvas()
# Additional static shortcuts
def keyPressEvent(self, e):
if e.key() == Qt.Key_Escape and self.model.is_fullscreen:
self.main_controller.toggle_fullscreen()
def on_open_parent(self):
parent_index = self.file_model.parent(self.file_model.index(self.file_model.rootPath()))
self.file_model.setRootPath(self.file_model.filePath(parent_index))
self.ui.treeView.setRootIndex(parent_index)
# Update directory path
self.model.directory = self.file_model.filePath(parent_index)
self.update_ui_from_model()
def on_dir_list_activated(self, index):
if self.file_model.isDir(index) is not False:
self.file_model.setRootPath(self.file_model.filePath(index))
self.ui.treeView.setRootIndex(index)
# Save current path
self.model.directory = self.file_model.filePath(index)
self.update_ui_from_model()
def on_dir_list_clicked(self, index):
self.main_controller.open_image(self.file_model.filePath(index))
# File menu
def on_set_as_wallpaper(self):
from hitagilib.view.WallpaperView import WallpaperDialog
from hitagilib.controller.wallpaper import WallpaperController
image = self.model.get_image()
if image is not None:
dialog = WallpaperDialog(self, None, WallpaperController(self.model), image)
dialog.show()
def on_clipboard(self):
self.main_controller.copy_to_clipboard()
def on_current_dir(self):
if not self.main_controller.open_in_explorer():
self.show_explorer_error()
def on_options(self):
from hitagilib.view.OptionsView import OptionDialog
self.dialog = OptionDialog(self)
self.dialog.show()
def on_close(self):
if self.slideshow.isRunning():
self.slideshow.exit()
self.close()
# Folder menu
def on_next_item(self):
current_index = self.ui.treeView.currentIndex()
# Slideshow restart - determine if we are at the end of our file list
if self.slideshow.is_running and self.settings.get('Slideshow', 'restart') == 'True' and not self.ui.treeView.indexBelow(current_index).isValid():
self.main_controller.open_image(self.file_model.filePath(current_index))
self.on_slideshow_restart(0) # Restart slideshow
elif self.slideshow.is_running and self.settings.get('Slideshow', 'random') == 'True':
# Random index - moveCursor expects constants @http://doc.qt.io/qt-5/qabstractitemview.html#CursorAction-enum
index = self.ui.treeView.moveCursor(randint(0,9), Qt.NoModifier)
self.ui.treeView.setCurrentIndex(index)
self.main_controller.open_image(self.file_model.filePath(index))
else:
# Proceed normally, scroll down
index = self.ui.treeView.moveCursor(QAbstractItemView.MoveDown, Qt.NoModifier)
self.ui.treeView.setCurrentIndex(index)
self.main_controller.open_image(self.file_model.filePath(index))
def on_previous_item(self):
current_index = self.ui.treeView.currentIndex()
# Slideshow restart (reverse) - determine if we are the the top of our file list
if self.slideshow.is_running and self.settings.get('Slideshow', 'restart') == 'True' and not self.ui.treeView.indexAbove(current_index).isValid():
self.main_controller.open_image(self.file_model.filePath(current_index))
self.on_slideshow_restart(1) # Restart slideshow
elif self.slideshow.is_running and self.settings.get('Slideshow', 'random') == 'True':
# Random index
index = self.ui.treeView.moveCursor(randint(0,9), Qt.NoModifier)
self.ui.treeView.setCurrentIndex(index)
self.main_controller.open_image(self.file_model.filePath(index))
else:
# Proceed normally, scroll up
index = self.ui.treeView.moveCursor(QAbstractItemView.MoveUp, Qt.NoModifier)
self.ui.treeView.setCurrentIndex(index)
self.main_controller.open_image(self.file_model.filePath(index))
def on_slideshow(self):
if self.ui.actionSlideshow.isChecked():
self.slideshow.start()
self.slideshow.is_running = True
else:
self.slideshow.is_running = False
self.slideshow.exit()
def on_slideshow_restart(self, direction):
# 0: Restart from top to bottom
# 1: Restart from bottom to top
if direction == 0:
index = self.ui.treeView.moveCursor(QAbstractItemView.MoveHome, Qt.NoModifier)
self.main_controller.open_image(self.file_model.filePath(index))
else:
index = self.ui.treeView.moveCursor(QAbstractItemView.MoveEnd, Qt.NoModifier)
self.main_controller.open_image(self.file_model.filePath(index))
self.ui.treeView.setCurrentIndex(index)
def on_change_directory(self):
self.main_controller.change_directory()
# View menu
def on_zoom_in(self):
self.canvas_controller.scale_image(1.1)
def on_zoom_out(self):
self.canvas_controller.scale_image(0.9)
def on_rotate_clockwise(self):
self.canvas_controller.rotate_image(90)
def on_rotate_counterclockwise(self):
self.canvas_controller.rotate_image(-90)
def on_flip_horizontal(self):
self.canvas_controller.flip_image(0)
def on_flip_vertical(self):
self.canvas_controller.flip_image(1)
def on_scale_image_to_width(self):
self.canvas_controller.update_image(1)
def on_scale_image_to_height(self):
self.canvas_controller.update_image(2)
def on_zoom_original(self):
self.canvas_controller.update_image(3)
def on_toggle_filelist(self):
if self.ui.fileWidget.isHidden():
self.ui.fileWidget.show()
else:
self.ui.fileWidget.hide()
self.update_resize_timer(300)
def on_fullscreen(self):
self.main_controller.toggle_fullscreen()
if self.model.is_fullscreen:
self.showFullScreen()
if self.settings.get('Misc', 'hide_menubar') == 'True':
self.ui.menubar.setMaximumHeight(0) # Workaround to preserve shortcuts
else:
self.showNormal()
if self.settings.get('Misc', 'hide_menubar') == 'True':
self.ui.menubar.setMaximumHeight(self.default_menubar_height)
self.canvas_controller.update(self.ui.graphicsView.width(), self.ui.graphicsView.height())
self.main_controller.update_canvas()
# Favorite button
def on_manage_favorite(self):
if self.main_controller.check_favorites(self.model.directory):
self.on_remove_from_favorites()
else:
self.on_add_to_favorites()
# Favorite menu
def on_add_to_favorites(self):
self.main_controller.add_to_favorites()
self.load_favorites()
self.update_ui_from_model()
def on_remove_from_favorites(self):
self.main_controller.remove_from_favorites()
self.load_favorites()
self.update_ui_from_model()
# Help menu
def on_changelog(self):
webbrowser.open('https://github.com/gimu/hitagi-reader/releases')
def on_about(self):
from hitagilib.view.AboutView import AboutDialog
dialog = AboutDialog(self, None, None)
dialog.show()
def on_fileWidget_visibilityChanged(self, visible):
"""On file list hide/show and de/attachment"""
if visible:
self.ui.actionFile_list.setChecked(True)
else:
self.ui.actionFile_list.setChecked(False)
self.update_resize_timer(300)
def show_explorer_error(self):
notify = QMessageBox()
notify.setWindowTitle("Error")
notify.setText(QCoreApplication.translate('Hitagi', "Couldn't open the current directory with an appropriate filemanager!"))
notify.exec_()
def update_ui_from_model(self):
"""Update UI from model."""
self.settings = SettingsModel()
# On changing directory
self.file_model.setRootPath(self.model.directory)
self.ui.treeView.setRootIndex(self.file_model.index(self.model.directory))
# Update favorite button
if self.main_controller.check_favorites(self.model.directory):
self.ui.pushButton_favorite.setText(QCoreApplication.translate('Hitagi', "Unfavorite"))
else:
self.ui.pushButton_favorite.setText(QCoreApplication.translate('Hitagi', "Favorite"))
# Canvas update
self.ui.graphicsView.setScene(self.canvas.scene)
class LocalPathView(QTreeView):
def __init__ (self):
super(LocalPathView, self).__init__()
self._model = QFileSystemModel()
self._model.setFilter(QDir.Dirs | QDir.Drives | QDir.NoDotAndDotDot | QDir.AllDirs)
self._model.setRootPath('')
self.setModel(self._model )
self.hideColumn(1); # removing Size Column
self.hideColumn(2); # removing Type Column
self.setAnimated(False)
self.setSortingEnabled(True)
self.header().setSortIndicator(0, Qt.AscendingOrder)
width = self.size().width() >> 1
self.setColumnWidth(0, width*0.7)
self.setColumnWidth(1, width*0.3)
index = self._model.index(QDir.currentPath())
self.selectionModel().setCurrentIndex(index, QItemSelectionModel.Select | QItemSelectionModel.Rows)
self.expand(index)
self.scrollTo(index)
@property
def selectedDir(self):
return self._model.filePath(self.selectionModel().selectedIndexes()[0])
