def update_file_tree(self):
model = QFileSystemModel()
model.setRootPath(self._root_dir)
self.localFilesTreeView.setModel(model)
local_selection_model = self.localFilesTreeView.selectionModel()
local_selection_model.selectionChanged.connect(self.local_file_selection_changed)
self.localFilesTreeView.setRootIndex(model.index(self._root_dir))
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 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.__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 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)
class FileTree(QTreeView):
def __init__(self):
super(FileTree, self).__init__()
self.model = QFileSystemModel()
self.model.setRootPath('')
self.setModel(self.model)
self.setAnimated(False)
self.setIndentation(20)
self.setSortingEnabled(True)
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()
def initRootDir(self,indexDir):
if not indexDir:
return
self.indexDir = indexDir
model = QFileSystemModel()
model.setRootPath('')
self.setModel(model)
self.setAnimated(False)
self.setIndentation(20)
self.setSortingEnabled(True)
self.setRootIndex(model.index(self.indexDir))
for i in range(1,model.columnCount()):
self.hideColumn(i)
def _init_ui(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
model = QFileSystemModel(self)
model.setRootPath('')
view = QTreeView()
view.setModel(model)
view.setAnimated(False)
view.setIndentation(20)
view.setSortingEnabled(True)
layout = QVBoxLayout()
layout.addWidget(view)
self.setLayout(layout)
def load_dir(self, dir_path):
if dir_path == self.dir_path:
return
self.dir_path = dir_path
model = QFileSystemModel()
model.setRootPath(dir_path)
self.setModel(model)
index_root = model.index(model.rootPath())
self.setRootIndex(index_root)
# hide unwanted info
self.hideColumn(1)
self.hideColumn(2)
self.hideColumn(3)
self.setHeaderHidden(True)
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)
class ComplexDialog(QDialog, Ui_ComplexForm):
def __init__(self, parent=None):
super(ComplexDialog, self).__init__(parent)
self.setupUi(self)
self.file_model = QFileSystemModel()
self.bundle_model = QStringListModel()
bundle_lists = []
self.bundle_model.setStringList(bundle_lists)
root = self.file_model.setRootPath("/Volumes")
self.columnView_files.setModel(self.file_model)
self.columnView_files.setRootIndex(root)
self.listView_files.setModel(self.bundle_model)
# connect the buttons
self.pushButton_add_file.clicked.connect(self._add_to_bundle)
self.pushButton_remove_file.clicked.connect(self._remove_from_bundle)
self.pushButton_cancle.clicked.connect(self.close_window)
self.pushButton_add_object.clicked.connect(self.return_bundle)
def _add_to_bundle(self):
selection = self.columnView_files.selectedIndexes()
files = self.bundle_model.stringList()
model = self.columnView_files.model()
for index in selection:
# path = os.path.join()
if model.isDir(index):
continue
newfile = model.filePath(index)
files.append(newfile)
self.bundle_model.setStringList(files)
# self.bundle_model.inser
def _remove_from_bundle(self):
selection = self.listView_files.selectedIndexes()
model = self.listView_files.model()
for index in selection:
row = index.row()
model.removeRows(row, 1)
def return_bundle(self):
self.close_window()
@property
def bundle(self):
return self.bundle_model.stringList()
def close_window(self):
self.close()
def __init__(self):
super(FileSystemOpener, self).__init__()
hbox = QHBoxLayout(self)
hbox.setContentsMargins(0, 0, 0, 0)
self.btnClose = QPushButton(
self.style().standardIcon(QStyle.SP_DialogCloseButton), '')
self.completer = QCompleter(self)
self.pathLine = ui_tools.LineEditTabCompleter(self.completer)
fileModel = QFileSystemModel(self.completer)
fileModel.setRootPath("")
self.completer.setModel(fileModel)
self.pathLine.setCompleter(self.completer)
self.btnOpen = QPushButton(
self.style().standardIcon(QStyle.SP_ArrowRight), 'Open!')
hbox.addWidget(self.btnClose)
hbox.addWidget(QLabel(_translate("FileSystemOpener", "Path:")))
hbox.addWidget(self.pathLine)
hbox.addWidget(self.btnOpen)
self.pathLine.returnPressed.connect(self._open_file)
self.btnOpen.clicked['bool'].connect(self._open_file)
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_project_structure2(self):
model = QFileSystemModel()
model.setRootPath(My_Sync.path2)
self.treeView_2.setModel(model)
self.treeView_2.setRootIndex(model.index(My_Sync.path2))
self.treeView_2.show()
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(800, 600)
MainWindow.setLayoutDirection(QtCore.Qt.LeftToRight)
self.MRATcentralwidget = QtWidgets.QWidget(MainWindow)
self.MRATcentralwidget.setObjectName("MRATcentralwidget")
self.widget = QtWidgets.QWidget(self.MRATcentralwidget)
self.widget.setGeometry(QtCore.QRect(10, 0, 201, 480))
#tree.resize(340, 480)
#tree.show()
MainWindow.setCentralWidget(self.MRATcentralwidget)
self.dockWidget = QtWidgets.QDockWidget(MainWindow)
self.dockWidget.setObjectName("dockWidget")
self.dockWidgetContents = QtWidgets.QWidget()
self.dockWidgetContents.setObjectName("dockWidgetContents")
self.dockWidget.setWidget(self.dockWidgetContents)
MainWindow.addDockWidget(QtCore.Qt.DockWidgetArea(1), self.dockWidget)
#self.widget.setObjectName("widget")
self.treeView = QtWidgets.QTreeView(self.dockWidget)
self.treeView.setGeometry(QtCore.QRect(10, 20, 191, 480))
self.treeView.sizeAdjustPolicy()
self.treeView.setObjectName("treeView")
model = QFileSystemModel()
model.setRootPath('')
self.treeView.setModel(model)
self.treeView.setAnimated(True)
self.treeView.setIndentation(5)
self.treeView.setSortingEnabled(True)
self.treeView.setWindowTitle("MRAT workspace")
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 22))
self.menubar.setMinimumSize(QtCore.QSize(10, 10))
self.menubar.setDefaultUp(False)
self.menubar.setNativeMenuBar(False)
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.menuData = QtWidgets.QMenu(self.menubar)
self.menuData.setObjectName("menuData")
self.menuGraphics = QtWidgets.QMenu(self.menubar)
self.menuGraphics.setObjectName("menuGraphics")
self.menuStatistics = QtWidgets.QMenu(self.menubar)
self.menuStatistics.setObjectName("menuStatistics")
self.menuT_TESTS = QtWidgets.QMenu(self.menuStatistics)
self.menuT_TESTS.setObjectName("menuT_TESTS")
self.menuTemporal = QtWidgets.QMenu(self.menuT_TESTS)
self.menuTemporal.setObjectName("menuTemporal")
self.menuResults = QtWidgets.QMenu(self.menubar)
self.menuResults.setObjectName("menuResults")
self.menuHelp = QtWidgets.QMenu(self.menubar)
self.menuHelp.setObjectName("menuHelp")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.toolBar = QtWidgets.QToolBar(MainWindow)
self.toolBar.setObjectName("toolBar")
MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
self.actionSpatio_Temporal = QtWidgets.QAction(MainWindow)
self.actionSpatio_Temporal.setObjectName("actionSpatio_Temporal")
self.actionSpatio_Temporal_2 = QtWidgets.QAction(MainWindow)
self.actionSpatio_Temporal_2.setObjectName("actionSpatio_Temporal_2")
self.actionNew_Analysis = QtWidgets.QAction(MainWindow)
self.actionNew_Analysis.setObjectName("actionNew_Analysis")
self.actionOpen_Analysis = QtWidgets.QAction(MainWindow)
self.actionOpen_Analysis.setObjectName("actionOpen_Analysis")
self.actionPTHreshold = QtWidgets.QAction(MainWindow)
self.actionPTHreshold.setObjectName("actionPTHreshold")
self.actionTFCE = QtWidgets.QAction(MainWindow)
self.actionTFCE.setObjectName("actionTFCE")
self.actionWindow = QtWidgets.QAction(MainWindow)
self.actionWindow.setObjectName("actionWindow")
self.actionImport_File = QtWidgets.QAction(MainWindow)
self.actionImport_File.setObjectName("actionImport_File")
self.actionExport_File = QtWidgets.QAction(MainWindow)
self.actionExport_File.setObjectName("actionExport_File")
self.actionQuit = QtWidgets.QAction(MainWindow)
self.actionQuit.setObjectName("actionQuit")
self.menuFile.addAction(self.actionNew_Analysis)
self.menuFile.addAction(self.actionOpen_Analysis)
self.menuFile.addAction(self.actionImport_File)
self.menuFile.addAction(self.actionExport_File)
self.menuFile.addAction(self.actionQuit)
self.menuTemporal.addSeparator()
self.menuTemporal.addAction(self.actionPTHreshold)
self.menuTemporal.addAction(self.actionTFCE)
self.menuTemporal.addAction(self.actionWindow)
self.menuT_TESTS.addSeparator()
self.menuT_TESTS.addAction(self.menuTemporal.menuAction())
self.menuT_TESTS.addAction(self.actionSpatio_Temporal_2)
self.menuStatistics.addAction(self.actionSpatio_Temporal)
self.menuStatistics.addAction(self.menuT_TESTS.menuAction())
self.menubar.addAction(self.menuFile.menuAction())
self.menubar.addAction(self.menuEdit.menuAction())
self.menubar.addAction(self.menuData.menuAction())
self.menubar.addAction(self.menuGraphics.menuAction())
self.menubar.addAction(self.menuStatistics.menuAction())
self.menubar.addAction(self.menuResults.menuAction())
self.menubar.addAction(self.menuHelp.menuAction())
self.retranslateUi(MainWindow)
self.actionQuit.triggered.connect(MainWindow.close)
self.form1 = ttestwindow()
#self.Filedial = QtWidgets.QFileDialog.getExistingDirectory(self, "Find Files",
# QtCore.QDir.currentPath())
self.actionPTHreshold.triggered.connect(self.form1.show)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
class Explorer(QDialog):
def __init__(
self, parent, window_title=_("Select resources"), subtitle=_("Select files and/or folders to include")
):
super().__init__(parent)
self.logger = logging.getLogger(__name__)
self.setModal(True)
self.setSizeGripEnabled(True)
self.setWindowTitle(window_title)
self.subtitle = subtitle
self.file_set = set()
self.config = Configuration()
self.__init_ui__()
self.filename_filter = FilenameFilter()
# self.show()
def __init_ui__(self):
# layout
vert = QVBoxLayout(self)
vert.setContentsMargins(0, 0, 0, 0)
resource_dir = self.config.cfg_resource_dir()
p_top = QVBoxLayout()
lb_subtitle = QLabel(self.subtitle)
lb_subtitle.setContentsMargins(10, 10, 10, 0)
p_top.addWidget(lb_subtitle)
self.model = QFileSystemModel()
self.model.setRootPath(resource_dir)
self.view = QTreeView()
self.view.setModel(self.model)
self.view.setRootIndex(self.model.index(self.model.rootPath()))
self.view.setAlternatingRowColors(True)
self.view.setSelectionMode(QAbstractItemView.MultiSelection)
self.view.selectionModel().selectionChanged.connect(self.selection_changed)
self.view.collapsed.connect(self.item_collapsed)
self.view.expanded.connect(self.item_expanded)
p_top.addWidget(self.view)
p_info = QHBoxLayout()
lb_resource = QLabel(_("resource dir") + ": " + resource_dir)
lb_resource.setContentsMargins(10, 0, 10, 0)
self.lb_selection_count = QLabel(str(self.selected_file_count()) + " " + _("resources selected"))
self.lb_selection_count.setContentsMargins(10, 0, 10, 0)
p_info.addWidget(self.lb_selection_count)
p_info.addStretch(1)
p_info.addWidget(lb_resource)
p_top.addLayout(p_info)
p_bottom = QHBoxLayout()
self.pb_deselect = QPushButton(_("Deselect all"))
self.pb_deselect.clicked.connect(self.pb_deselect_clicked)
self.pb_deselect.setEnabled(self.selected_file_count() > 0)
p_bottom.addWidget(self.pb_deselect)
p_bottom.addStretch(1)
self.pb_ok = QPushButton(_("OK"))
self.pb_ok.setAutoDefault(True)
self.pb_ok.clicked.connect(self.accept)
p_bottom.addWidget(self.pb_ok)
pb_cancel = QPushButton(_("Cancel"))
pb_cancel.clicked.connect(self.reject)
p_bottom.addWidget(pb_cancel)
vert.addLayout(p_top)
vert.addLayout(p_bottom)
self.setLayout(vert)
self.resize(self.config.explorer_width(), self.config.explorer_height())
width = self.view.width() - 50
self.view.setColumnWidth(0, width / 2)
self.view.setColumnWidth(1, width / 6)
self.view.setColumnWidth(2, width / 6)
self.view.setColumnWidth(3, width / 6)
def __persist__(self):
# persist properties of the explorer
self.config.set_explorer_width(self.width())
self.config.set_explorer_height(self.height())
self.config.persist()
def __compute_filenames__(self, item_selection):
# item_selection: a QItemSelection
# return corresponding absolute filenames as a set, including filenames in underlying folders
s = set()
for index in item_selection.indexes():
# we have an index for each column in the model
if index.column() == 0:
path = index.model().filePath(index)
if os.path.isdir(path):
for root, directories, filenames in os.walk(path):
for filename in filenames:
if self.filename_filter.accept(filename):
s.add(os.path.join(root, filename))
elif os.path.isfile(path):
s.add(path)
else:
self.logger.warn("isUnknownThing", path)
return s
def showEvent(self, QShowEvent):
# self.pb_ok.setFocus()
pass
def set_filename_filter(self, filename_filter):
# set the FilenameFilter
self.filename_filter = filename_filter
def selected_file_count(self):
return len(self.file_set)
def selected_file_set(self):
return frozenset(self.file_set)
def selection_changed(self, selected, deselected):
# selected, deselected: PyQt5.QtCore.QItemSelection
selected_filenames = self.__compute_filenames__(selected)
self.file_set.update(selected_filenames)
deselected_filenames = self.__compute_filenames__(deselected)
self.file_set.difference_update(deselected_filenames)
self.pb_deselect.setEnabled(self.selected_file_count() > 0)
self.lb_selection_count.setText(str(self.selected_file_count()) + " " + _("resources selected"))
def item_expanded(self, index):
# index: a QModelIndex
# show all child items selected/deselected in accordance with state of parent folder
pass
def item_collapsed(self, index):
pass
def pb_deselect_clicked(self):
self.view.selectionModel().clear()
def hideEvent(self, QHideEvent):
self.__persist__()
class FileSelect(QMainWindow, QWidget):
def __init__(self):
super(FileSelect, self).__init__()
self.setWindowTitle("Printing Booth Systems")
global file, pagecount, total, enabler, copies, colormode, page
file = ""
pagecount = 0
total = 0.0
copies = "1"
colormode = ""
page = ""
widget = QWidget()
layout = QVBoxLayout()
self.index = QModelIndex()
self.model = QFileSystemModel()
self.tree = QTreeView()
self.model.setRootPath(QDir.currentPath()) #ignore
self.model.setNameFilters(["*.pdf"])
idx = self.model.index("/media/pi/")
self.tree.setModel(self.model)
self.tree.setRootIndex(idx)
self.tree.setColumnWidth(0, 250)
self.tree.setAlternatingRowColors(True)
layout.addWidget(self.tree)
widget.setLayout(layout)
self.setCentralWidget(widget)
widget.setFixedWidth(600)
self.tree.setFont(QFont('Arial', 30))
self.tree.hideColumn(1)
self.tree.hideColumn(2)
self.tree.hideColumn(3)
self.tree.clicked.connect(self.on_treeView_clicked)
self.btn1 = QPushButton('Select', self)
self.btn1.setGeometry(620, 120, 150, 90)
self.btn1.clicked.connect(self.slot_btn1_function)
self.btn2 = QPushButton('Cancel', self)
self.btn2.setGeometry(620, 300, 150, 90)
self.btn2.clicked.connect(self.slot_btn2_function)
def slot_btn1_function(self):
if file.lower().endswith('.pdf'):
self.p = Preview()
self.p.showFullScreen()
self.hide()
else:
pass
def slot_btn2_function(self):
self.mw = MainWindow()
self.mw.showFullScreen()
self.hide()
def on_treeView_clicked(self, index):
global file
indexItem = self.model.index(index.row(), 0, index.parent())
filePath = self.model.filePath(indexItem)
file = filePath
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(800, 600)
MainWindow.setLayoutDirection(QtCore.Qt.LeftToRight)
self.MRATcentralwidget = QtWidgets.QWidget(MainWindow)
self.MRATcentralwidget.setObjectName("MRATcentralwidget")
self.widget = QtWidgets.QWidget(self.MRATcentralwidget)
self.widget.setGeometry(QtCore.QRect(10, 0, 201, 480))
#test = PThresholdTempSourceTTest.Results
#if PThresholdTempSourceTTest.Results != "":
data = {'col1':['0','0','0'], 'col2':['0','0','0'], 'col3':['7','8','9']}
self.table = MyTable(data, 5, 3)
#self.table.show()
#self.table.show()
#tree.resize(340, 480)
#tree.show()
MainWindow.setCentralWidget(self.MRATcentralwidget)
self.dockWidget = QtWidgets.QDockWidget(MainWindow)
self.dockWidget.setObjectName("dockWidget")
self.dockWidget= QDockWidget("MRAT work space", self)
self.dockWidgetContents = QtWidgets.QWidget()
self.dockWidgetContents.setObjectName("dockWidgetContents")
self.dockWidget.setWidget(self.dockWidgetContents)
MainWindow.addDockWidget(QtCore.Qt.DockWidgetArea(1), self.dockWidget)
self.dockWidget.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
self.table = QTableWidget()
#self.widget.setObjectName("widget")
self.treeView = QtWidgets.QTreeView(self.dockWidget)
self.treeView.setGeometry(QtCore.QRect(10, 20, 191, 480))
self.treeView.sizeAdjustPolicy = "AdjustToContents"
self.treeView.setObjectName("treeView")
self.model = QFileSystemModel()
self.rootPath = ''
self.model.setRootPath(self.rootPath)
self.treeView.setModel(self.model)
self.treeView.setAnimated(True)
self.treeView.setIndentation(5)
self.treeView.setSortingEnabled(True)
self.treeView.setWindowTitle("MRAT workspace")
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 22))
self.menubar.setMinimumSize(QtCore.QSize(10, 10))
self.menubar.setDefaultUp(False)
self.menubar.setNativeMenuBar(False)
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.menuData = QtWidgets.QMenu(self.menubar)
self.menuData.setObjectName("menuData")
self.menuGraphics = QtWidgets.QMenu(self.menubar)
self.menuGraphics.setObjectName("menuGraphics")
self.menuStatistics = QtWidgets.QMenu(self.menubar)
self.menuStatistics.setObjectName("menuStatistics")
self.menuT_TESTS = QtWidgets.QMenu(self.menuStatistics)
self.menuT_TESTS.setObjectName("menuT_TESTS")
self.menuTemporal = QtWidgets.QMenu(self.menuT_TESTS)
self.menuTemporal.setObjectName("menuTemporal")
self.menuResults = QtWidgets.QMenu(self.menubar)
self.menuResults.setObjectName("menuResults")
self.menuHelp = QtWidgets.QMenu(self.menubar)
self.menuHelp.setObjectName("menuHelp")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.toolBar = QtWidgets.QToolBar(MainWindow)
self.toolBar.setObjectName("toolBar")
MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
self.actionSpatio_Temporal = QtWidgets.QAction(MainWindow)
self.actionSpatio_Temporal.setObjectName("actionSpatio_Temporal")
self.actionSpatio_Temporal_2 = QtWidgets.QAction(MainWindow)
self.actionSpatio_Temporal_2.setObjectName("actionSpatio_Temporal_2")
self.actionNew_Analysis = QtWidgets.QAction(MainWindow)
self.actionNew_Analysis.setObjectName("actionNew_Analysis")
self.actionOpen_Analysis = QtWidgets.QAction(MainWindow)
self.actionOpen_Analysis.setObjectName("actionOpen_Analysis")
self.actionPTHreshold = QtWidgets.QAction(MainWindow)
self.actionPTHreshold.setObjectName("actionPTHreshold")
self.actionTFCE = QtWidgets.QAction(MainWindow)
self.actionTFCE.setObjectName("actionTFCE")
self.actionWindow = QtWidgets.QAction(MainWindow)
self.actionWindow.setObjectName("actionWindow")
self.actionImport_File = QtWidgets.QAction(MainWindow)
self.actionImport_File.setObjectName("actionImport_File")
self.actionExport_File = QtWidgets.QAction(MainWindow)
self.actionExport_File.setObjectName("actionExport_File")
self.actionQuit = QtWidgets.QAction(MainWindow)
self.actionQuit.setObjectName("actionQuit")
self.menuFile.addAction(self.actionNew_Analysis)
self.menuFile.addAction(self.actionOpen_Analysis)
self.menuFile.addAction(self.actionImport_File)
self.menuFile.addAction(self.actionExport_File)
self.menuFile.addAction(self.actionQuit)
self.menuTemporal.addSeparator()
self.menuTemporal.addAction(self.actionPTHreshold)
self.menuTemporal.addAction(self.actionTFCE)
self.menuTemporal.addAction(self.actionWindow)
self.menuT_TESTS.addSeparator()
self.menuT_TESTS.addAction(self.menuTemporal.menuAction())
self.menuT_TESTS.addAction(self.actionSpatio_Temporal_2)
self.menuStatistics.addAction(self.actionSpatio_Temporal)
self.menuStatistics.addAction(self.menuT_TESTS.menuAction())
self.menubar.addAction(self.menuFile.menuAction())
self.menubar.addAction(self.menuEdit.menuAction())
self.menubar.addAction(self.menuData.menuAction())
self.menubar.addAction(self.menuGraphics.menuAction())
self.menubar.addAction(self.menuStatistics.menuAction())
self.menubar.addAction(self.menuResults.menuAction())
self.menubar.addAction(self.menuHelp.menuAction())
self.retranslateUi(MainWindow)
self.actionQuit.triggered.connect(MainWindow.close)
self.form1 = ttestwindow()
#self.Filedial = QtWidgets.QFileDialog.getExistingDirectory(self, "Find Files",
# QtCore.QDir.currentPath())
self.actionPTHreshold.triggered.connect(self.form1.show)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
######
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "Multi Region Analysis Tool"))
self.menuFile.setTitle(_translate("MainWindow", "File"))
self.menuEdit.setTitle(_translate("MainWindow", "Edit"))
self.menuData.setTitle(_translate("MainWindow", "Data"))
self.menuGraphics.setTitle(_translate("MainWindow", "Graphics"))
self.menuStatistics.setTitle(_translate("MainWindow", "Statistics"))
self.menuT_TESTS.setTitle(_translate("MainWindow", "T-TESTS"))
self.menuTemporal.setTitle(_translate("MainWindow", "Temporal"))
self.menuResults.setTitle(_translate("MainWindow", "Results"))
self.menuHelp.setTitle(_translate("MainWindow", "Help"))
self.toolBar.setWindowTitle(_translate("MainWindow", "toolBar"))
self.actionSpatio_Temporal.setText(_translate("MainWindow", "ANOVAs"))
self.actionSpatio_Temporal_2.setText(_translate("MainWindow", "Spatio-Temporal"))
self.actionNew_Analysis.setText(_translate("MainWindow", "New Analysis"))
self.actionOpen_Analysis.setText(_translate("MainWindow", "Open Analysis"))
self.actionPTHreshold.setText(_translate("MainWindow", "PTHreshold"))
self.actionPTHreshold.setStatusTip(_translate("MainWindow", "Run PTHRESHOLD temporal t-test analysis"))
self.actionTFCE.setText(_translate("MainWindow", "TFCE"))
self.actionWindow.setText(_translate("MainWindow", "window"))
self.actionImport_File.setText(_translate("MainWindow", "Import File"))
self.actionExport_File.setText(_translate("MainWindow", "Export File"))
self.actionQuit.setText(_translate("MainWindow", "Quit"))
parser.setApplicationDescription("Qt Dir View Example")
parser.addHelpOption()
parser.addVersionOption()
dontUseCustomDirectoryIconsOption = QCommandLineOption('c',
"Set QFileIconProvider.DontUseCustomDirectoryIcons")
parser.addOption(dontUseCustomDirectoryIconsOption)
parser.addPositionalArgument('directory', "The directory to start in.")
parser.process(app)
try:
rootPath = parser.positionalArguments().pop(0)
except IndexError:
rootPath = None
model = QFileSystemModel()
model.setRootPath('')
if parser.isSet(dontUseCustomDirectoryIconsOption):
model.iconProvider().setOptions(
QFileIconProvider.DontUseCustomDirectoryIcons)
tree = QTreeView()
tree.setModel(model)
if rootPath is not None:
rootIndex = model.index(QDir.cleanPath(rootPath))
if rootIndex.isValid():
tree.setRootIndex(rootIndex)
# Demonstrating look and feel features.
tree.setAnimated(False)
tree.setIndentation(20)
tree.setSortingEnabled(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 Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(824, 723)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(":/res/res/mainLogo4.ico"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
MainWindow.setWindowIcon(icon)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.gridLayout = QtWidgets.QGridLayout(self.centralwidget)
self.gridLayout.setObjectName("gridLayout")
self.frame_2 = QtWidgets.QFrame(self.centralwidget)
self.frame_2.setMinimumSize(QtCore.QSize(200, 265))
self.frame_2.setMaximumSize(QtCore.QSize(388, 500))
self.frame_2.setFrameShape(QtWidgets.QFrame.Box)
self.frame_2.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_2.setObjectName("frame_2")
self.gridLayout_3 = QtWidgets.QGridLayout(self.frame_2)
self.gridLayout_3.setObjectName("gridLayout_3")
self.scrollArea_2 = QtWidgets.QScrollArea(self.frame_2)
self.scrollArea_2.setWidgetResizable(True)
self.scrollArea_2.setObjectName("scrollArea_2")
self.scrollAreaWidgetContents_2 = QtWidgets.QWidget()
self.scrollAreaWidgetContents_2.setGeometry(
QtCore.QRect(0, 0, 178, 270))
self.scrollAreaWidgetContents_2.setObjectName(
"scrollAreaWidgetContents_2")
self.horizontalLayout_4 = QtWidgets.QHBoxLayout(
self.scrollAreaWidgetContents_2)
self.horizontalLayout_4.setObjectName("horizontalLayout_4")
# self.listWidget_3 = QtWidgets.QListWidget(self.scrollAreaWidgetContents_2)
# self.listWidget_3.setObjectName("listWidget_3")
self.scrollArea_2.setWidget(self.scrollAreaWidgetContents_2)
self.gridLayout_3.addWidget(self.scrollArea_2, 1, 0, 1, 1)
self.label_2 = QtWidgets.QLabel(self.frame_2)
self.label_2.setObjectName("label_2")
self.gridLayout_3.addWidget(self.label_2, 0, 0, 1, 1)
self.gridLayout.addWidget(self.frame_2, 2, 0, 1, 1)
self.frame = QtWidgets.QFrame(self.centralwidget)
sizePolicy = QtWidgets.QSizePolicy(
QtWidgets.QSizePolicy.MinimumExpanding,
QtWidgets.QSizePolicy.MinimumExpanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.frame.sizePolicy().hasHeightForWidth())
self.frame.setSizePolicy(sizePolicy)
self.frame.setMinimumSize(QtCore.QSize(200, 265))
self.frame.setMaximumSize(QtCore.QSize(388, 500))
self.frame.setFrameShape(QtWidgets.QFrame.Box)
self.frame.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame.setObjectName("frame")
self.gridLayout_2 = QtWidgets.QGridLayout(self.frame)
self.gridLayout_2.setObjectName("gridLayout_2")
self.scrollArea = QtWidgets.QScrollArea(self.frame)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setObjectName("scrollArea")
self.scrollAreaWidgetContents = QtWidgets.QWidget()
self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 178, 270))
self.scrollAreaWidgetContents.setObjectName("scrollAreaWidgetContents")
self.horizontalLayout_5 = QtWidgets.QHBoxLayout(
self.scrollAreaWidgetContents)
self.horizontalLayout_5.setObjectName("horizontalLayout_5")
self.listWidget = QtWidgets.QListWidget(
self.scrollAreaWidgetContents_2)
self.listWidget.setObjectName("listWidget")
self.model = QFileSystemModel()
self.model.setRootPath("D:\Work\PatrolGIS\PatrolGis")
self.model.setReadOnly(False)
self.view = QtWidgets.QTreeView(self.scrollAreaWidgetContents)
self.view.setModel(self.model)
self.view.setRootIndex(self.model.index("../"))
self.view.setDragEnabled(True)
self.view.setDragDropMode(QAbstractItemView.InternalMove)
# self.view.setEditTriggers(QAbstractItemView.OnViewport(self.canvas))
self.horizontalLayout_4.addWidget(self.listWidget)
self.horizontalLayout_5.addWidget(self.view)
self.scrollArea.setWidget(self.scrollAreaWidgetContents)
self.gridLayout_2.addWidget(self.scrollArea, 1, 0, 1, 1)
self.label = QtWidgets.QLabel(self.frame)
self.label.setObjectName("label")
self.gridLayout_2.addWidget(self.label, 0, 0, 1, 1)
self.gridLayout.addWidget(self.frame, 1, 0, 1, 1)
self.frame_3 = QtWidgets.QFrame(self.centralwidget)
self.frame_3.setMinimumSize(QtCore.QSize(600, 608))
self.frame_3.setFrameShape(QtWidgets.QFrame.Box)
self.frame_3.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_3.setObjectName("frame_3")
self.gridLayout_4 = QtWidgets.QGridLayout(self.frame_3)
self.gridLayout_4.setObjectName("gridLayout_4")
# self.graphicsView = QtWidgets.QGraphicsView(self.frame_3)
# self.graphicsView.setMinimumSize(QtCore.QSize(580, 445))
# self.graphicsView.setObjectName("graphicsView")
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.canvas.setParent(self.frame_3)
self.canvas.setMinimumSize(QtCore.QSize(570, 435))
self.canvas.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding,
QtWidgets.QSizePolicy.MinimumExpanding))
self.gridLayout_4.addWidget(self.canvas, 1, 0, 1, 1)
self.toolbar = NavigationToolbar(self.canvas, self.canvas)
# self.frame_5 = QtWidgets.QFrame(self.frame_3)
# self.frame_5.setMinimumSize(QtCore.QSize(0, 94))
# self.frame_5.setMaximumSize(QtCore.QSize(16777215, 135))
# self.frame_5.setFrameShape(QtWidgets.QFrame.StyledPanel)
# self.frame_5.setFrameShadow(QtWidgets.QFrame.Raised)
# self.frame_5.setObjectName("frame_5")
# self.horizontalLayout_2 = QtWidgets.QHBoxLayout(self.frame_5)
# self.horizontalLayout_2.setObjectName("horizontalLayout_2")
# self.scrollArea_3 = QtWidgets.QScrollArea(self.frame_5)
# self.scrollArea_3.setWidgetResizable(True)
# self.scrollArea_3.setObjectName("scrollArea_3")
# self.scrollAreaWidgetContents_3 = QtWidgets.QWidget()
# self.scrollAreaWidgetContents_3.setGeometry(QtCore.QRect(0, 0, 558, 113))
# self.scrollAreaWidgetContents_3.setObjectName("scrollAreaWidgetContents_3")
# self.horizontalLayout_3 = QtWidgets.QHBoxLayout(self.scrollAreaWidgetContents_3)
# self.horizontalLayout_3.setObjectName("horizontalLayout_3")
# self.tableWidget = QtWidgets.QTableWidget(self.scrollAreaWidgetContents_3)
# self.tableWidget.setMinimumSize(QtCore.QSize(0, 65))
# self.tableWidget.setObjectName("tableWidget")
# self.tableWidget.setColumnCount(0)
# self.tableWidget.setRowCount(0)
# self.horizontalLayout_3.addWidget(self.tableWidget)
# self.scrollArea_3.setWidget(self.scrollAreaWidgetContents_3)
# self.horizontalLayout_2.addWidget(self.scrollArea_3)
# self.gridLayout_4.addWidget(self.frame_5, 4, 0, 1, 1)
# self.label_3 = QtWidgets.QLabel(self.frame_3)
# self.label_3.setObjectName("label_3")
# self.gridLayout_4.addWidget(self.label_3, 2, 0, 1, 1)
self.gridLayout.addWidget(self.frame_3, 1, 1, 2, 1)
self.frame_4 = QtWidgets.QFrame(self.centralwidget)
self.frame_4.setMinimumSize(QtCore.QSize(800, 32))
self.frame_4.setMaximumSize(QtCore.QSize(16777215, 32))
self.frame_4.setFrameShape(QtWidgets.QFrame.Box)
self.frame_4.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_4.setObjectName("frame_4")
self.horizontalLayoutWidget = QtWidgets.QWidget(self.frame_4)
self.horizontalLayoutWidget.setGeometry(QtCore.QRect(10, 0, 111, 31))
self.horizontalLayoutWidget.setObjectName("horizontalLayoutWidget")
self.horizontalLayout = QtWidgets.QHBoxLayout(
self.horizontalLayoutWidget)
self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout.setObjectName("horizontalLayout")
self.openButton = QtWidgets.QPushButton(self.horizontalLayoutWidget)
self.openButton.setText("")
icon1 = QtGui.QIcon()
icon1.addPixmap(QtGui.QPixmap(":/res/res/open2.ico"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.openButton.setIcon(icon1)
self.openButton.setObjectName("openButton")
self.horizontalLayout.addWidget(self.openButton)
self.saveButton = QtWidgets.QPushButton(self.horizontalLayoutWidget)
self.saveButton.setText("")
icon2 = QtGui.QIcon()
icon2.addPixmap(QtGui.QPixmap(":/res/res/save.ico"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.saveButton.setIcon(icon2)
self.saveButton.setObjectName("saveButton")
self.horizontalLayout.addWidget(self.saveButton)
self.saveasButton = QtWidgets.QPushButton(self.horizontalLayoutWidget)
self.saveasButton.setText("")
icon3 = QtGui.QIcon()
icon3.addPixmap(QtGui.QPixmap(":/res/res/saveas.ico"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.saveasButton.setIcon(icon3)
self.saveasButton.setObjectName("saveasButton")
self.horizontalLayout.addWidget(self.saveasButton)
self.gridLayout.addWidget(self.frame_4, 0, 0, 1, 2)
MainWindow.setCentralWidget(self.centralwidget)
# self.graphicsView = QtWidgets.QGraphicsView(self.frame_3)
# self.graphicsView.setMinimumSize(QtCore.QSize(580, 445))
# self.graphicsView.setObjectName("graphicsView")
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 824, 21))
self.menubar.setObjectName("menubar")
self.menuProject = QtWidgets.QMenu(self.menubar)
self.menuProject.setObjectName("menuProject")
self.menuEdit = QtWidgets.QMenu(self.menubar)
self.menuEdit.setObjectName("menuEdit")
self.menuPatrolling = QtWidgets.QMenu(self.menubar)
self.menuPatrolling.setObjectName("menuPatrolling")
self.menuSettings = QtWidgets.QMenu(self.menubar)
self.menuSettings.setObjectName("menuSettings")
self.menuHelp = QtWidgets.QMenu(self.menubar)
self.menuHelp.setObjectName("menuHelp")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.menubar.addAction(self.menuProject.menuAction())
self.menubar.addAction(self.menuEdit.menuAction())
self.menubar.addAction(self.menuPatrolling.menuAction())
self.menubar.addAction(self.menuSettings.menuAction())
self.menubar.addAction(self.menuHelp.menuAction())
self.menuCreatePath = QtWidgets.QAction(MainWindow)
self.menuCreatePath.setObjectName("menuCreatePath")
self.menuSplit = QtWidgets.QAction(MainWindow)
self.menuSplit.setObjectName("menuSplit")
self.menuPatrolling.addAction(self.menuSplit)
self.menuPatrolling.addAction(self.menuCreatePath)
self.retranslateUi(MainWindow)
# self.label.setDragEnabled(True)
# self.label_2.setDragEnabled(True)
# self.label_3.setDragEnabled(True)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "PatrolGIS"))
self.label_2.setText(_translate("MainWindow", "Layers"))
self.label.setText(_translate("MainWindow", "Explorer"))
self.menuProject.setTitle(_translate("MainWindow", "Project"))
self.menuEdit.setTitle(_translate("MainWindow", "Edit"))
self.menuPatrolling.setTitle(_translate("MainWindow", "Patrolling"))
self.menuSettings.setTitle(_translate("MainWindow", "Settings"))
self.menuHelp.setTitle(_translate("MainWindow", "Help"))
self.menuCreatePath.setText(_translate("MainWindow", "Generate Path"))
self.menuSplit.setText(_translate("MainWindow", "Start Processing"))
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 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 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 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])
def displayFiles(
self
): #show the xls files on the treeview for the selected library
"""
called when a library is selected
"""
#check we have a selection
if len(self.tableView.selectionModel().selectedRows()) == 0:
return
log = self.logger.getChild('displayFiles')
#=======================================================================
# retrieve selection
#=======================================================================
#get the selection index
"""should only allow 1 row.. but taking the first regardless"""
sindex = self.tableView.selectionModel().selectedRows()[0]
row = sindex.row()
#get this value
libName = self.dfModel.data(self.dfModel.index(row, 0))
#log.debug('user selected \'%s\''%libName)
#=======================================================================
# data setup
#=======================================================================
focus_dir = self.vdata_d[libName]['basedir']
#focus_dir = r'C:\LS\03_TOOLS\CanFlood\_git\canflood\_pars\vfunc'
#=======================================================================
# #build the model
#=======================================================================
assert os.path.exists(focus_dir)
fsModel = QFileSystemModel()
fsModel.setRootPath(focus_dir)
fsModel.setNameFilters(['*.xls'])
self.fsModel = fsModel
#=======================================================================
# #tree view
#=======================================================================
self.treeView.setModel(fsModel)
self.treeView.setRootIndex(fsModel.index(focus_dir))
log.debug('connected treeView to QFileSystemModel w/: \n %s' %
focus_dir)
#adjust columns
header = self.treeView.header()
header.setSectionResizeMode(0, QHeaderView.ResizeToContents)
header.setStretchLastSection(False)
#self.treeView.resizeColumnToContents(0)
#=======================================================================
# connect it
#=======================================================================
self.treeView.selectionModel().selectionChanged.connect(
self.dislpayCsDetails)
"""
if not self.dfModel3 is None:
self.dfModel3.clear()
#self.tableView_bottomRight.clearSpans() #clear the table view until next trigger
"""
try: #cleanup the model
self.tableView_bottomRight.setModel(pandasModel(
pd.DataFrame())) #set a dummy model
del self.dfModel3
except:
pass
class MainWindow(QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
# sys.stdout = EmittingStream(textWritten=self.normalOutputWritten)
self.actionAutoencoder.setChecked(True)
# Connect the menu action
self.actionSelect_Data_Path.triggered.connect(self.selectPath)
self.actionLoad_from_Data_Path.triggered.connect(self.loadtifFile)
# Connect the model selections
self.actionAutoencoder.triggered.connect(self.createAE_Model)
self.actionAE_CS.triggered.connect(self.createAECS_Model)
self.actionOpen_Model.triggered.connect(self.openModel)
# Connect the treeView action
self.treeView.clicked.connect(self.on_treeView_clicked)
# Connect the Label action
self.actionAddLabel.triggered.connect(self.addCategory)
self.actionDel_Label.triggered.connect(self.delCategory)
self.actionUpdate_Setting.triggered.connect(self.updateLabelSetting)
# Connect the Function action
self.actionStart_Training.triggered.connect(self.Training)
self.actionStop_Training.triggered.connect(self.stopTraining)
self.actionNew_tSNE.triggered.connect(self.New_tSNE)
# Gif
self.movie = QtGui.QMovie("cube.gif")
self.movie.setCacheMode(QtGui.QMovie.CacheAll)
self.movie.setSpeed(80)
self.movie.setScaledSize(QSize(256, 320))
self.Gif.setMovie(self.movie)
self.movie.start()
self.movie.stop()
import wmi
computer = wmi.WMI()
computer_info = computer.Win32_ComputerSystem()[0]
os_info = computer.Win32_OperatingSystem()[0]
proc_info = computer.Win32_Processor()[0]
gpu_info = computer.Win32_VideoController()[0]
os_name = os_info.Name.encode('utf-8').split(b'|')[0]
os_version = ' '.join([os_info.Version, os_info.BuildNumber])
system_ram = float(
os_info.TotalVisibleMemorySize) / 1048576 # KB to GB
print('OS Name: {0}'.format(os_name))
print('OS Version: {0}'.format(os_version))
print('CPU: {0}'.format(proc_info.Name))
print('RAM: {0} GB'.format(system_ram))
print('Graphics Card: {0}'.format(gpu_info.Name))
self.setWindowIcon(QIcon('Icon.png'))
self.System_textEdit.setText('OS Name: {}\n'
'OS Version: {}\n'
'CPU: {}\n'
'RAM: {} GB\n'
'Graphics Card: {}'.format(
os_name.decode("utf-8"), os_version,
proc_info.Name, system_ram,
gpu_info.Name))
def Training(self):
global file_loaded
if file_loaded:
self.label_7.setText('Training')
self.label_7.setStyleSheet("color: rgb(200, 0, 0);\n"
"font: 75 14pt \"MS Shell Dlg 2\";")
self.movie.setSpeed(100)
self.movie.start()
self.training_thread = Training_Thread()
self.training_thread.start()
self.training_thread.finished.connect(self.DrawtSNE)
self.training_thread.finished.connect(self.DrawLog)
self.training_thread.quit()
else:
pass
def New_tSNE(self):
self.movie.start()
self.tSNE_thread = tSNE_Thread()
self.tSNE_thread.start()
self.tSNE_thread.finished.connect(self.DrawtSNE)
pass
def stopTraining(self):
self.training_thread = Training_Thread()
if self.training_thread.isRunning():
self.training_thread.terminate()
self.movie.stop()
self.label_7.setText('Stopped')
self.label_7.setStyleSheet("color: rgb(200, 0, 0);\n"
"font: 75 14pt \"MS Shell Dlg 2\";")
def DrawtSNE(self):
global imagesavepath, currentdate, labels, cavans, groups, labels_dict, groups3D, test_data, test_annotation
from matplotlib.offsetbox import OffsetImage, AnnotationBbox
global df, df_3D, Y, Y_3D
print("DrawtSNE Start ")
test_annotation = test_data.reshape(-1, 190, 190)
# 2D tSNE
plt.cla()
fig, ax = plt.subplots()
ax.margins(0.05) # Optional, just adds 5% padding to the autoscaling
points_with_annotation = []
for label, group in groups:
name = labels_dict[label]
point, = ax.plot(group.x,
group.y,
marker='o',
linestyle='',
ms=5,
label=name,
alpha=0.5)
points_with_annotation.append([point])
plt.title('t-SNE Scattering Plot')
ax.legend()
cavans2D = FigureCanvas(fig)
#Annotation
# create the annotations box
im = OffsetImage(test_annotation[0, :, :], zoom=0.25, cmap='gray')
xybox = (10., 10.)
ab = AnnotationBbox(im, (10, 10),
xybox=xybox,
xycoords='data',
boxcoords="offset points",
pad=0.3,
arrowprops=dict(arrowstyle="->"))
# add it to the axes and make it invisible
ax.add_artist(ab)
ab.set_visible(False)
tsneprelabel = int(len(test_data) / len(labels))
def hover(event):
global df, test_annotation
i = 0
ispointed = np.zeros((len(groups), ), dtype=bool)
for point in points_with_annotation:
if point[0].contains(event)[0]:
ispointed[i] = True
cont, ind = point[0].contains(event)
image_index = ind["ind"][0] + i * tsneprelabel
# get the figure size
w, h = fig.get_size_inches() * fig.dpi
ws = (event.x > w / 2.) * -1 + (event.x <= w / 2.)
hs = (event.y > h / 2.) * -1 + (event.y <= h / 2.)
# if event occurs in the top or right quadrant of the figure,
# change the annotation box position relative to mouse.
ab.xybox = (xybox[0] * ws, xybox[1] * hs)
# place it at the position of the hovered scatter point
global df, test_annotation
df = df
ab.xy = (df['x'][image_index], df['y'][image_index])
# set the image corresponding to that point
im.set_data(test_annotation[image_index, :, :])
ab.set_visible(True)
else:
ispointed[i] = False
i = i + 1
ab.set_visible(max(ispointed))
fig.canvas.draw_idle()
cid = fig.canvas.mpl_connect('motion_notify_event', hover)
rows = int(self.tSNE_Layout.count())
if rows == 1:
myWidget = self.tSNE_Layout.itemAt(0).widget()
myWidget.deleteLater()
self.tSNE_Layout.addWidget(cavans2D)
print("tSNE 2D Finished")
# 3D tSNE
fig_3D = plt.figure()
cavans3D = FigureCanvas(fig_3D)
ax_3D = Axes3D(fig_3D)
ax_3D.margins(
0.05) # Optional, just adds 5% padding to the autoscaling
test_annotation = test_data.reshape(-1, 190, 190)
for label, group in groups3D:
name = labels_dict[label]
ax_3D.scatter(group.x,
group.y,
group.z,
marker='o',
label=name,
alpha=0.8)
ax_3D.legend()
ax_3D.patch.set_visible(False)
ax_3D.set_axis_off()
ax_3D._axis3don = False
from matplotlib.offsetbox import OffsetImage, AnnotationBbox
im_3D = OffsetImage(test_annotation[0, :, :], zoom=0.25, cmap='gray')
xybox = (10., 10.)
ab_3D = AnnotationBbox(im_3D, (10, 10),
xybox=xybox,
xycoords='data',
boxcoords="offset points",
pad=0.3,
arrowprops=dict(arrowstyle="->"))
# add it to the axes and make it invisible
ax_3D.add_artist(ab_3D)
ab_3D.set_visible(False)
def onMouseMotion(event):
global Y_3D
distances = []
for i in range(Y_3D.shape[0]):
x2, y2, _ = proj3d.proj_transform(Y_3D[i, 0], Y_3D[i, 1],
Y_3D[i, 2], ax_3D.get_proj())
x3, y3 = ax_3D.transData.transform((x2, y2))
distance = np.sqrt((x3 - event.x)**2 + (y3 - event.y)**2)
distances.append(distance)
closestIndex = np.argmin(distances)
print(closestIndex)
x2, y2, _ = proj3d.proj_transform(Y_3D[closestIndex,
0], Y_3D[closestIndex, 1],
Y_3D[closestIndex, 2],
ax_3D.get_proj())
ab_3D.xy = (x2, y2)
im_3D.set_data(test_annotation[closestIndex, :, :])
ab_3D.set_visible(True)
fig_3D.canvas.draw_idle()
cid3d = fig_3D.canvas.mpl_connect('motion_notify_event',
onMouseMotion) # on mouse motion
rows = int(self.tSNE3D_Layout.count())
if rows == 1:
myWidget = self.tSNE3D_Layout.itemAt(0).widget()
myWidget.deleteLater()
self.tSNE3D_Layout.addWidget(cavans3D)
self.movie.stop()
self.movie.jumpToFrame(0)
self.label_7.setText('Finished')
self.label_7.setStyleSheet("color: rgb(70, 70, 70);\n"
"font: 75 14pt \"MS Shell Dlg 2\";")
def DrawLog(self):
global history, CSfunction
if CSfunction:
train_history = history
loss = 'class_output_loss'
fig = plt.figure()
plt.plot(range(1,
len(train_history.history[loss]) + 1),
train_history.history[loss])
plt.title('Train History')
plt.ylabel(loss)
plt.xlabel('Epoch')
plt.legend([loss])
loss_cavans = FigureCanvas(fig)
rows = int(self.Log_Layout.count())
if rows == 1:
myWidget = self.Log_Layout.itemAt(0).widget()
myWidget.deleteLater()
self.Log_Layout.addWidget(loss_cavans)
else:
train_history = history
loss = 'decoder_output_loss'
fig = plt.figure()
plt.plot(range(1,
len(train_history.history[loss]) + 1),
train_history.history[loss])
plt.title('Train History')
plt.ylabel(loss)
plt.xlabel('Epoch')
plt.legend([loss])
loss_cavans = FigureCanvas(fig)
rows = int(self.Log_Layout.count())
if rows == 1:
myWidget = self.Log_Layout.itemAt(0).widget()
myWidget.deleteLater()
self.Log_Layout.addWidget(loss_cavans)
def DrawDecoded(self):
global test_data, decoded_imgs
n = 5
fig = plt.figure()
plt.subplots_adjust(wspace=0, hspace=0)
for i in range(n):
# display original
ax = plt.subplot(2, n, i + 1)
plt.imshow(test_data[i].reshape(190, 190))
plt.gray()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
# display reconstruction
ax = plt.subplot(2, n, i + n + 1)
plt.imshow(decoded_imgs[1][i].reshape(190, 190))
plt.gray()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.subplot(2, n, round(n / 2))
plt.tight_layout()
# plt.title('Raw Images &Decoded Images')
cavans = FigureCanvas(fig)
# rows = int(self.Decoded_layout.count())
# if rows == 1:
# myWidget = self.Decoded_layout.itemAt(0).widget()
# myWidget.deleteLater()
# self.Decoded_layout.addWidget(cavans)
def addCategory(self):
global folder_layers, layers_of_folders, file_readed, label_setting, file_loaded
if file_readed:
cat_cont = int(self.Category_Layout.count() / 2)
location = self.Category_Layout.count()
self.Category_new = QtWidgets.QLabel(self.formLayoutWidget)
self.Category_new.setText('Label {} :'.format(cat_cont + 1))
self.Category_new.setStyleSheet("font: 14pt \"Lucida Console\";")
self.Category_new.setObjectName("Category_{}".format(cat_cont + 1))
self.Category_Layout.setWidget(location,
QtWidgets.QFormLayout.LabelRole,
self.Category_new)
self.Category_box_new = QtWidgets.QComboBox(self.formLayoutWidget)
self.Category_box_new.setStyleSheet(
"background-color: rgb(255, 255, 255);\n"
"color: rgb(65, 65, 65);")
self.Category_box_new.setObjectName(
"Category_box{}".format(cat_cont + 1))
self.Category_Layout.setWidget(location,
QtWidgets.QFormLayout.FieldRole,
self.Category_box_new)
self.Category_box_new.clear()
for a in range(0, layers_of_folders):
self.Category_box_new.addItems(folder_layers[a])
self.label_3.setStyleSheet(
"color: rgb(200, 200, 200);\n"
"font: 75 14pt \"MS Shell Dlg 2\";") # Light the Label
label_setting = False
file_loaded = False
def delCategory(self):
global label_setting, file_loaded
rows = int(self.Category_Layout.count() / 1)
if rows / 2 > 2:
box = self.Category_Layout.itemAt(rows - 2,
QtWidgets.QFormLayout.FieldRole)
label = self.Category_Layout.itemAt(
rows - 2, QtWidgets.QFormLayout.LabelRole)
box.widget().deleteLater()
label.widget().deleteLater()
self.label_3.setStyleSheet(
"color: rgb(200, 200, 200);\n"
"font: 75 14pt \"MS Shell Dlg 2\";") # Light the Label
label_setting = False
file_loaded = False
def updateLabelSetting(self):
global labels, label_setting
if str(self.Category_box1.currentText()):
label_numbers = int(self.Category_Layout.count() / 2)
print('\nThere are {} labels.'.format(label_numbers))
rows = int(self.Category_Layout.count())
labels = []
i = 0
for index in range(0, rows, 2):
box = self.Category_Layout.itemAt(
index, QtWidgets.QFormLayout.FieldRole)
print('Label {} :{}'.format(i + 1,
str(box.widget().currentText())))
labels.append(str(box.widget().currentText()))
i = i + 1
self.label_3.setText('Label Updated')
self.label_3.setStyleSheet(
"color: rgb(70, 70, 70);\n"
"font: 75 14pt \"MS Shell Dlg 2\";") # Light the Label
label_setting = True
print(labels)
def readimgFile(self):
global base_path, folder_layers, layers_of_folders, file_readed, folder_list
if base_path:
folder_layers = []
folder_list = []
layers_of_folders = 0
files = os.scandir(base_path)
# %% Get the 1st layer of folder
first_folder = []
first_folder_kind = []
for entry in files:
if entry.is_dir():
first_folder.append(entry.path)
first_folder_kind.append(entry.name)
folder_layers.append(first_folder_kind)
folder_list.append(first_folder)
# %% Get the 2nd layer of folder
second_folder = []
if first_folder:
second_folder = []
second_folder_kind = []
layers_of_folders += 1
for fldr in first_folder:
files = os.scandir(fldr)
for entry in files:
if entry.is_dir():
second_folder.append(entry.path)
second_folder_kind.append(entry.name)
second_folder_kind = second_folder_kind[
0:int(len(second_folder_kind) / len(first_folder_kind))]
folder_layers.append(second_folder_kind)
folder_list.append(second_folder)
# %% Get the 3rd layer of folder
third_folder = []
if second_folder:
third_folder = []
third_folder_kind = []
layers_of_folders += 1
for fldr in second_folder:
files = os.scandir(fldr)
for entry in files:
if entry.is_dir():
third_folder.append(entry.path)
third_folder_kind.append(entry.name)
third_folder_kind = third_folder_kind[0:int(
len(third_folder_kind) /
(len(second_folder_kind) * len(first_folder_kind)))]
folder_layers.append(third_folder_kind)
folder_list.append(third_folder)
# %% Get the 4th layer of folder
forth_folder = []
if third_folder:
forth_folder = []
forth_folder_kind = []
layers_of_folders += 1
for fldr in third_folder:
files = os.scandir(fldr)
for entry in files:
if entry.is_dir():
forth_folder.append(entry.path)
forth_folder_kind.append(entry.name)
forth_folder_kind = forth_folder_kind[0:int(
len(forth_folder_kind) /
(len(third_folder_kind) * len(second_folder_kind) *
len(first_folder_kind)))]
folder_layers.append(forth_folder_kind)
folder_list.append(forth_folder)
# %% Get the 5th layer of folder
fifth_folder = []
if forth_folder:
fifth_folder = []
fifth_folder_kind = []
layers_of_folders += 1
for fldr in third_folder:
files = os.scandir(fldr)
for entry in files:
if entry.is_dir():
fifth_folder.append(entry.path)
fifth_folder_kind.append(entry.name)
fifth_folder_kind = fifth_folder_kind[0:int(
len(fifth_folder_kind) /
(len(forth_folder_kind) * len(third_folder_kind) *
len(second_folder_kind) * len(first_folder_kind)))]
folder_layers.append(fifth_folder_kind)
folder_list.append(fifth_folder)
print('\nThere are {} Layers in the Data Path.'.format(
layers_of_folders))
import fnmatch
file_list = []
for root, dirs, files in os.walk(base_path, topdown=False):
for name in files:
if fnmatch.fnmatch(name, '*.tif'):
file_list.append(os.path.join(root, name))
print('\nThere are {} .Tif files in the Data Path.'.format(
len(file_list)))
rows = int(self.Category_Layout.count())
print(rows)
for index in range(0, rows, 2):
print(index)
box = self.Category_Layout.itemAt(
index, QtWidgets.QFormLayout.FieldRole)
print(box.widget().objectName())
box.widget().clear()
for a in range(0, layers_of_folders):
for labels in folder_layers[a]:
box.widget().addItem(labels)
file_readed = True
def loadtifFile(self):
global datanumber, file_loaded
datanumber = int(self.spinBox.value())
self.thread = Thread_1()
self.label_5.setText('Data Loading')
self.label_5.setStyleSheet(
"color: rgb(200, 0, 0);\n"
"font: 75 14pt \"MS Shell Dlg 2\";") # Light the Label
self.thread.start()
self.thread.finished.connect(self.DataCreated)
self.thread.quit()
file_loaded = True
def DataCreated(self):
self.label_5.setText('Data Loaded')
self.label_5.setStyleSheet(
"color: rgb(70, 70, 70);\n"
"font: 75 14pt \"MS Shell Dlg 2\";") # Light the Label
def selectPath(self):
global base_path
repfldr = []
celltypefldr = []
self.statusBar().showMessage('Now Loading Files')
base_path = str(
QFileDialog.getExistingDirectory(self, "Select Directory", '/'))
print(base_path)
if base_path:
files = os.scandir(base_path)
# %% Get the 1st layer of folder
for entry in files:
if entry.is_dir():
if 'replicate' in entry.name:
repfldr.append(entry.path)
# %% Get the 2nd layer of folder
for fldr in repfldr:
files = os.scandir(fldr)
for entry in files:
if entry.is_dir():
celltypefldr.append(entry.path)
self.readimgFile()
self.model = QFileSystemModel()
self.model.setRootPath(base_path)
self.treeView.setModel(self.model)
self.treeView.setRootIndex(self.model.index(base_path))
self.treeView.hideColumn(2)
self.treeView.hideColumn(3)
return base_path
def keyPressEvent(self, e): # Use ESC to Close the APP
from PyQt5.QtCore import Qt
if e.key() == Qt.Key_Escape:
self.close()
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)
from PyQt5.QtGui import QIcon, QPixmap
pixmap = QPixmap(filePath)
self.Cell_Image.setPixmap(pixmap.scaled(256, 256))
def createAE_Model(self, state):
global CSfunction
if state:
self.actionAE_CS.setChecked(False)
CSfunction = False
def createAECS_Model(self, state):
global CSfunction
if state:
self.actionAutoencoder.setChecked(False)
CSfunction = True
def openModel(self):
global model_path
model_path = QFileDialog.getOpenFileName(self, "Select Model", '/')
print(model_path)
def runExample(self):
global base_path, folder_layers, layers_of_folders, file_readed, folder_list
class Broswer_Img(QMainWindow):
"""
选择图片文件并且预览，自动匹配多图的情况和背景图片
"""
Close_Signal = pyqtSignal(list)
def __init__(self, *args, **kwargs):
QMainWindow.__init__(self, *args, **kwargs)
self.Current_Dir = QDir.home().absolutePath()
#self.Current_Dir = Wk_Dir
self.setWindowTitle("Select Imags")
self.setWindowModality(Qt.ApplicationModal)
self.Left_Dock_Code()
self.Central_Frame_Code()
self.Right_Dock_Code()
self.connect_Signals()
self.wb_nav_left.setEnabled(False)
self.wb_nav_right.setEnabled(False)
self.bkgd_nav_left.setEnabled(False)
self.bkgd_nav_right.setEnabled(False)
#self.setGeometry(200, 200, 1000, 600)
#self.setMaximumSize(QSize(1000, 600))
def Left_Dock_Code(self):
self.Left_Frame = QFrame(self)
self.Model = QFileSystemModel()
self.Model.setNameFilterDisables(False)
self.Model.setRootPath(self.Current_Dir)
#self.Model.setSorting(QDir.DirsFirst | QDir.IgnoreCase | QDir.Name)
self.Model.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs
| QDir.AllEntries)
self.Model.setNameFilters(['*.tif'])
self.Tree = QTreeView(self.Left_Frame)
self.Tree.setModel(self.Model)
self.Tree.setRootIndex(self.Model.index(self.Current_Dir))
self.Tree.expandAll()
self.Dir_Select = QPushButton("Select a Folder", self.Left_Frame)
layout = QVBoxLayout()
layout.addWidget(self.Tree)
layout.addWidget(self.Dir_Select)
self.Left_Frame.setLayout(layout)
self.Left_Dock = QDockWidget('Broswer Images', self)
self.Left_Dock.setWidget(self.Left_Frame)
self.Left_Dock.setFeatures(QDockWidget.NoDockWidgetFeatures)
self.Dir_Select.clicked.connect(self.dir_selection)
self.addDockWidget(Qt.LeftDockWidgetArea, self.Left_Dock)
def Central_Frame_Code(self):
self.Central_Frame = QFrame(self)
layout = QGridLayout()
self.wb_label = QLabel(self.Central_Frame)
self.bkgd_label = QLabel(self.Central_Frame)
#self.wb_label.setMaximumHeight(30)
self.wb_label.setWordWrap(True)
self.wb = QLabel(self.Central_Frame)
self.wb.setScaledContents(True)
self.bkgd = QLabel(self.Central_Frame)
self.bkgd.setScaledContents(True)
self.wb.setMaximumSize(QSize(300, 300))
self.bkgd.setMaximumSize(QSize(300, 300))
self.wb_navigator = QFrame(self.Central_Frame)
self.wb_nav_left = QPushButton('<--', self.wb_navigator)
self.wb_nav_right = QPushButton('-->', self.wb_navigator)
nav_layout = QHBoxLayout()
nav_layout.addWidget(self.wb_nav_left)
nav_layout.addWidget(self.wb_nav_right)
self.wb_navigator.setLayout(nav_layout)
self.wb_navigator.setMaximumHeight(60)
self.bkgd_navigator = QFrame(self.Central_Frame)
self.bkgd_nav_left = QPushButton('<--', self.bkgd_navigator)
self.bkgd_nav_right = QPushButton('-->', self.bkgd_navigator)
nav_layout2 = QHBoxLayout()
nav_layout2.addWidget(self.bkgd_nav_left)
nav_layout2.addWidget(self.bkgd_nav_right)
self.bkgd_navigator.setLayout(nav_layout2)
self.bkgd_navigator.setMaximumHeight(60)
self.btns = QFrame(self.Central_Frame)
self.btns.setMaximumHeight(60)
self.Btn_Add = QPushButton('Add', self.btns)
self.Btn_Close = QPushButton('Close', self.btns)
btn_layout = QHBoxLayout()
btn_layout.addWidget(self.Btn_Add)
btn_layout.addWidget(self.Btn_Close)
self.btns.setLayout(btn_layout)
# 根据具体的传入参数构建不同的视图
layout.addWidget(self.wb_label, 0, 0)
layout.addWidget(self.bkgd_label, 0, 1)
layout.addWidget(self.wb, 1, 0)
layout.addWidget(self.bkgd, 1, 1)
layout.addWidget(self.wb_navigator, 2, 0)
layout.addWidget(self.bkgd_navigator, 2, 1)
layout.addWidget(self.btns, 3, 0, 2, 0)
layouts = QVBoxLayout()
layouts.addLayout(layout)
self.Central_Frame.setLayout(layouts)
self.setCentralWidget(self.Central_Frame)
#self.setStyleSheet('border:1px solid red')
def Right_Dock_Code(self):
self.Added_Img_tree = Img_Tree([], self)
self.Right_Dock = QDockWidget('Selected Images', self)
self.Right_Dock.setWidget(self.Added_Img_tree)
self.Right_Dock.setFeatures(QDockWidget.NoDockWidgetFeatures)
self.addDockWidget(Qt.RightDockWidgetArea, self.Right_Dock)
def connect_Signals(self):
self.Tree.clicked.connect(self.Load_Img_to_Central_Frame)
self.wb_nav_left.clicked.connect(self.change_img_index)
self.wb_nav_right.clicked.connect(self.change_img_index)
self.bkgd_nav_left.clicked.connect(self.change_img_index)
self.bkgd_nav_right.clicked.connect(self.change_img_index)
self.Btn_Add.clicked.connect(self.Add_Btn_Action)
self.Btn_Close.clicked.connect(self.Close_Btn_Action)
def Load_Img_to_Central_Frame(self, Index):
select_file = self.Tree.model().filePath(Index)
_, ext = os.path.splitext(select_file)
if ext in ['.tif', '.jpeg', '.png', '.jpg']:
self.Related_Imgs = BioRad_Imgs(select_file)
self.set_Central_Frame()
def set_Central_Frame(self):
self.wb_nav_left.setEnabled(False)
self.wb_nav_right.setEnabled(False)
self.bkgd_nav_left.setEnabled(False)
self.bkgd_nav_right.setEnabled(False)
self.current_wb = self.Related_Imgs.WB_list[self.Related_Imgs.wb_index]
self.current_bkgd = self.Related_Imgs.BKGD_list[
self.Related_Imgs.bkgd_index]
self.wb_label.setText(
self.current_wb.replace(self.Related_Imgs.Dir, '.'))
self.bkgd_label.setText(
self.current_bkgd.replace(self.Related_Imgs.Dir, '.'))
wb, _ = CV_Img_to_QImage(cv2.imread(self.current_wb))
bkgd, _ = CV_Img_to_QImage(cv2.imread(self.current_bkgd))
self.wb.setPixmap(wb)
self.wb.setScaledContents(True)
self.bkgd.setPixmap(bkgd)
wb_len = len(self.Related_Imgs.WB_list)
bkgd_len = len(self.Related_Imgs.BKGD_list)
if self.Related_Imgs.wb_index > 0:
self.wb_nav_left.setEnabled(True)
if wb_len - self.Related_Imgs.wb_index > 1:
self.wb_nav_right.setEnabled(True)
if self.Related_Imgs.bkgd_index > 0:
self.bkgd_nav_left.setEnabled(True)
if bkgd_len - self.Related_Imgs.bkgd_index > 1:
self.bkgd_nav_right.setEnabled(True)
def change_img_index(self):
sender = self.sender()
if sender == self.wb_nav_left:
self.Related_Imgs.wb_index = self.Related_Imgs.wb_index - 1
if sender == self.wb_nav_right:
self.Related_Imgs.wb_index = self.Related_Imgs.wb_index + 1
if sender == self.bkgd_nav_left:
self.Related_Imgs.bkgd_index = self.Related_Imgs.bkgd_index - 1
if sender == self.bkgd_nav_right:
self.Related_Imgs.bkgd_index = self.Related_Imgs.bkgd_index + 1
self.set_Central_Frame()
def Add_Btn_Action(self):
list = [{'wb': self.current_wb, 'bkgd': self.current_bkgd}]
self.Added_Img_tree.Add_top_Level_Item(list)
print(self.Added_Img_tree.imgs)
def Close_Btn_Action(self):
self.close()
def closeEvent(self, event):
self.Close_Signal.emit(self.Added_Img_tree.imgs)
def dir_selection(self):
global Wk_Dir
dir = QFileDialog.getExistingDirectory(self, "Choose a Directory",
Wk_Dir)
self.Current_Dir = dir
Wk_Dir = dir
self.Tree.setRootIndex(self.Model.index(self.Current_Dir))
self.Left_Dock.setWindowTitle(dir)
def __init__(self, controller_events: dict):
super().__init__(controller_events=controller_events)
# self.show()
self.has_webcam = False
self.loggedIn = False
self.camera_elements_row = 0
self.camera_elements_column = 0
self.locations = []
self.camera_elements = {}
self.location_elements = {}
self.settings = Settings()
self.settings_map = deepcopy(self.settings.settings)
self.video_settings_map = deepcopy(self.settings.video)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Login Dialog ========================================
self.login_dialog = QtWidgets.QDialog()
self.login_dialog.ui = Ui_Login()
self.login_dialog.ui.setupUi(self.login_dialog)
# self.login_dialog.ui.progressBar.hide()
self.login_dialog.ui.login.clicked.connect(self.__login_event)
# Repair Camera Dialog ========================================
self.repair_camera_dialog = QtWidgets.QDialog()
self.repair_camera_dialog.ui = Ui_RepairCamera()
self.repair_camera_dialog.ui.setupUi(self.repair_camera_dialog)
self.repair_camera_dialog.ui.progressBar.hide()
self.repair_camera_dialog.ui.fixCamera.clicked.connect(
self.__repair_camera_event)
# Add Camera Dialog ========================================
self.add_camera_dialog = QtWidgets.QDialog()
self.add_camera_dialog.ui = Ui_AddCamera()
self.add_camera_dialog.ui.setupUi(self.add_camera_dialog)
self.add_camera_dialog.ui.progressBar.hide()
self.add_camera_dialog.ui.addCamera.clicked.connect(
self.__add_camera_event)
# Add Locations Dialog ========================================
self.add_location_dialog = QtWidgets.QDialog()
self.add_location_dialog.ui = Ui_AddLocation()
self.add_location_dialog.ui.setupUi(self.add_location_dialog)
self.add_location_dialog.ui.addLocation.clicked.connect(
self.__add_location_event)
self.add_location_dialog.ui.progressBar.hide()
# Add Recordings View ========================================
self.recordings_view = QtWidgets.QDialog()
self.recordings_view.ui = Ui_RecordingsView()
self.recordings_view.ui.setupUi(self.recordings_view)
model = QFileSystemModel()
model.setRootPath(os.path.abspath('data/temp/video/'))
self.recordings_view.ui.directory.setModel(model)
self.recordings_view.ui.directory.setRootIndex(
model.index(os.path.abspath('data/temp/video/')))
# Add Settings Dialog ========================================
self.settings_dialog = QtWidgets.QDialog()
self.settings_dialog.ui = Ui_Settings()
self.settings_dialog.ui.setupUi(self.settings_dialog)
self.settings_dialog.ui.recordingRatio.setValue(
int(float(self.settings.settings['recording_ratio']) * 100))
self.settings_dialog.ui.recordingRatioValue.setText(
str(int(float(self.settings.settings['recording_ratio']) * 100)))
self.settings_dialog.ui.recordingRatio.valueChanged.connect(
lambda: self.__settings_value_updated('recordingRatio'))
self.settings_dialog.ui.height.valueChanged.connect(
lambda: self.__settings_value_updated('height'))
self.settings_dialog.ui.width.valueChanged.connect(
lambda: self.__settings_value_updated('width'))
self.settings_dialog.ui.clipLength.valueChanged.connect(
lambda: self.__settings_value_updated('clipLength'))
self.settings_dialog.ui.framesPerSecond.valueChanged.connect(
lambda: self.__settings_value_updated('framesPerSecond'))
self.settings_dialog.ui.site.textChanged.connect(
lambda: self.__settings_value_updated('site'))
self.settings_dialog.ui.address.textChanged.connect(
lambda: self.__settings_value_updated('site'))
self.settings_dialog.ui.live.currentIndexChanged.connect(
lambda: self.__settings_value_updated('live'))
self.settings_dialog.ui.updateSettings.clicked.connect(
self.update_settings)
self.settings_dialog.ui.progressBar.hide()
# Connect UI events to controller_events ========================================
self.ui.actionAdd_New.triggered.connect(self.trigger_add_camera)
self.ui.actionView_Recordings.triggered.connect(
self.trigger_view_recordings)
self.ui.actionAdd_New_Location.triggered.connect(
self.trigger_add_location)
self.ui.actionPreferences.triggered.connect(self.trigger_show_settings)
self.ui.actionAdd_Webcam.triggered.connect(self.add_webcam)
self.add_camera_dialog.ui.cancel.clicked.connect(
self.__cancel_add_camera)
self.add_location_dialog.ui.cancel.clicked.connect(
self.__cancel_add_location)
self.recordings_view.ui.exit.clicked.connect(
self.__exit_recordings_view)
self.repair_camera_dialog.ui.cancel.clicked.connect(
self.__exit_repair_camera_dialog)
# Start Controller ==============================
self.controller_events["set_context_manager"](self.update_status)
self.controller_events["start"]()
self.loading(False)
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 PBTKGUI(QApplication):
def __init__(self):
super().__init__(argv)
signal(SIGINT, SIG_DFL)
if '__file__' in globals():
views = dirname(realpath(__file__)) + '/views/'
else:
views = dirname(realpath(executable)) + '/views/'
self.welcome = loadUi(views + 'welcome.ui')
self.choose_extractor = loadUi(views + 'choose_extractor.ui')
self.choose_proto = loadUi(views + 'choose_proto.ui')
self.create_endpoint = loadUi(views + 'create_endpoint.ui')
self.choose_endpoint = loadUi(views + 'choose_endpoint.ui')
self.fuzzer = loadUi(views + 'fuzzer.ui')
self.welcome.step1.clicked.connect(self.load_extractors)
self.choose_extractor.rejected.connect(
partial(self.set_view, self.welcome))
self.choose_extractor.extractors.itemClicked.connect(
self.prompt_extractor)
self.welcome.step2.clicked.connect(self.load_protos)
self.proto_fs = QFileSystemModel()
self.choose_proto.protos.setModel(self.proto_fs)
self.proto_fs.directoryLoaded.connect(
self.choose_proto.protos.expandAll)
for i in range(1, self.proto_fs.columnCount()):
self.choose_proto.protos.hideColumn(i)
self.choose_proto.protos.setRootIndex(
self.proto_fs.index(str(BASE_PATH / 'protos')))
self.choose_proto.rejected.connect(partial(self.set_view,
self.welcome))
self.choose_proto.protos.clicked.connect(self.new_endpoint)
self.create_endpoint.transports.itemClicked.connect(
self.pick_transport)
self.create_endpoint.loadRespPbBtn.clicked.connect(
self.load_another_pb)
self.create_endpoint.rejected.connect(
partial(self.set_view, self.choose_proto))
self.create_endpoint.buttonBox.accepted.connect(self.write_endpoint)
self.welcome.step3.clicked.connect(self.load_endpoints)
self.choose_endpoint.rejected.connect(
partial(self.set_view, self.welcome))
self.choose_endpoint.endpoints.itemClicked.connect(self.launch_fuzzer)
self.fuzzer.rejected.connect(
partial(self.set_view, self.choose_endpoint))
self.fuzzer.fuzzFields.clicked.connect(self.fuzz_endpoint)
self.fuzzer.deleteThis.clicked.connect(self.delete_endpoint)
self.fuzzer.comboBox.activated.connect(self.launch_fuzzer)
self.fuzzer.urlField.setWordWrapMode(QTextOption.WrapAnywhere)
for tree in (self.fuzzer.pbTree, self.fuzzer.getTree):
tree.itemEntered.connect(lambda item, _: item.edit()
if hasattr(item, 'edit') else None)
tree.itemClicked.connect(
lambda item, col: item.updateCheck(col=col))
tree.header().setSectionResizeMode(QHeaderView.ResizeToContents)
self.welcome.mydirLabel.setText(self.welcome.mydirLabel.text() %
BASE_PATH)
self.welcome.mydirBtn.clicked.connect(
partial(QDesktopServices.openUrl,
QUrl.fromLocalFile(str(BASE_PATH))))
self.set_view(self.welcome)
self.exec_()
"""
Step 1 - Extract .proto structures from apps
"""
def load_extractors(self):
self.choose_extractor.extractors.clear()
for name, meta in extractors.items():
item = QListWidgetItem(meta['desc'],
self.choose_extractor.extractors)
item.setData(Qt.UserRole, name)
self.set_view(self.choose_extractor)
def prompt_extractor(self, item):
extractor = extractors[item.data(Qt.UserRole)]
inputs = []
if not assert_installed(self.view, **extractor.get('depends', {})):
return
if not extractor.get('pick_url', False):
files, mime = QFileDialog.getOpenFileNames()
for path in files:
inputs.append((path, Path(path).stem))
else:
text, good = QInputDialog.getText(self.view, ' ', 'Input an URL:')
if text:
url = urlparse(text)
inputs.append((url.geturl(), url.netloc))
if inputs:
wait = QProgressDialog('Extracting .proto structures...', None, 0,
0)
wait.setWindowTitle(' ')
self.set_view(wait)
self.worker = Worker(inputs, extractor)
self.worker.progress.connect(self.extraction_progress)
self.worker.finished.connect(self.extraction_done)
self.worker.signal_proxy.connect(self.signal_proxy)
self.worker.start()
def extraction_progress(self, info, progress):
self.view.setLabelText(info)
if progress is not None:
self.view.setRange(0, 100)
self.view.setValue(progress * 100)
else:
self.view.setRange(0, 0)
def extraction_done(self, outputs):
nb_written_all, wrote_endpoints = 0, False
for folder, output in outputs.items():
nb_written, wrote_endpoints = extractor_save(
BASE_PATH, folder, output)
nb_written_all += nb_written
if wrote_endpoints:
self.set_view(self.welcome)
QMessageBox.information(
self.view, ' ',
'%d endpoints and their <i>.proto</i> structures have been extracted! You can now reuse the <i>.proto</i>s or fuzz the endpoints.'
% nb_written_all)
elif nb_written_all:
self.set_view(self.welcome)
QMessageBox.information(
self.view, ' ',
'%d <i>.proto</i> structures have been extracted! You can now reuse the <i>.protos</i> or define endpoints for them to fuzz.'
% nb_written_all)
else:
self.set_view(self.choose_extractor)
QMessageBox.warning(
self.view, ' ',
'This extractor did not find Protobuf structures in the corresponding format for specified files.'
)
"""
Step 2 - Link .protos to endpoints
"""
# Don't load .protos from the filesystem until asked to, in order
# not to slow down startup.
def load_protos(self):
self.proto_fs.setRootPath(str(BASE_PATH / 'protos'))
self.set_view(self.choose_proto)
def new_endpoint(self, path):
if not self.proto_fs.isDir(path):
path = self.proto_fs.filePath(path)
if assert_installed(self.choose_proto, binaries=['protoc']):
if not getattr(self, 'only_resp_combo', False):
self.create_endpoint.pbRequestCombo.clear()
self.create_endpoint.pbRespCombo.clear()
has_msgs = False
for name, cls in load_proto_msgs(path):
has_msgs = True
if not getattr(self, 'only_resp_combo', False):
self.create_endpoint.pbRequestCombo.addItem(
name, (path, name))
self.create_endpoint.pbRespCombo.addItem(
name, (path, name))
if not has_msgs:
QMessageBox.warning(
self.view, ' ',
'There is no message defined in this .proto.')
return
self.create_endpoint.reqDataSubform.hide()
if not getattr(self, 'only_resp_combo', False):
self.create_endpoint.endpointUrl.clear()
self.create_endpoint.transports.clear()
self.create_endpoint.sampleData.clear()
self.create_endpoint.pbParamKey.clear()
self.create_endpoint.parsePbCheckbox.setChecked(False)
for name, meta in transports.items():
item = QListWidgetItem(meta['desc'],
self.create_endpoint.transports)
item.setData(Qt.UserRole,
(name, meta.get('ui_data_form')))
elif getattr(self, 'saved_transport_choice'):
self.create_endpoint.transports.setCurrentItem(
self.saved_transport_choice)
self.pick_transport(self.saved_transport_choice)
self.saved_transport_choice = None
self.only_resp_combo = False
self.set_view(self.create_endpoint)
def pick_transport(self, item):
name, desc = item.data(Qt.UserRole)
self.has_pb_param = desc and 'regular' in desc
self.create_endpoint.reqDataSubform.show()
if self.has_pb_param:
self.create_endpoint.pbParamSubform.show()
else:
self.create_endpoint.pbParamSubform.hide()
self.create_endpoint.sampleDataLabel.setText(
'Sample request data, one per line (in the form of %s):' % desc)
def load_another_pb(self):
self.only_resp_combo = True
self.saved_transport_choice = self.create_endpoint.transports.currentItem(
)
self.set_view(self.choose_proto)
def write_endpoint(self):
request_pb = self.create_endpoint.pbRequestCombo.itemData(
self.create_endpoint.pbRequestCombo.currentIndex())
url = self.create_endpoint.endpointUrl.text()
transport = self.create_endpoint.transports.currentItem()
sample_data = self.create_endpoint.sampleData.toPlainText()
pb_param = self.create_endpoint.pbParamKey.text()
has_resp_pb = self.create_endpoint.parsePbCheckbox.isChecked()
resp_pb = self.create_endpoint.pbRespCombo.itemData(
self.create_endpoint.pbRespCombo.currentIndex())
if not (request_pb and urlparse(url).netloc and transport and
(not self.has_pb_param or pb_param) and
(not has_resp_pb or resp_pb)):
QMessageBox.warning(
self.view, ' ', 'Please fill all relevant information fields.')
else:
json = {
'request': {
'transport':
transport.data(Qt.UserRole)[0],
'proto_path':
request_pb[0].replace(str(BASE_PATH / 'protos'),
'').strip('/\\'),
'proto_msg':
request_pb[1],
'url':
url
}
}
if self.has_pb_param:
json['request']['pb_param'] = pb_param
sample_data = list(filter(None, sample_data.split('\n')))
if sample_data:
transport_obj = transports[transport.data(Qt.UserRole)[0]]
transport_obj = transport_obj['func'](pb_param, url)
for sample_id, sample in enumerate(sample_data):
try:
sample = transport_obj.serialize_sample(sample)
except Exception:
return QMessageBox.warning(
self.view, ' ',
'Some of your sample data is not in the specified format.'
)
if not sample:
return QMessageBox.warning(
self.view, ' ',
"Some of your sample data didn't contain the Protobuf parameter key you specified."
)
sample_data[sample_id] = sample
json['request']['samples'] = sample_data
if has_resp_pb:
json['response'] = {
'format':
'raw_pb',
'proto_path':
resp_pb[0].replace(str(BASE_PATH / 'protos'),
'').strip('/\\'),
'proto_msg':
resp_pb[1]
}
insert_endpoint(BASE_PATH / 'endpoints', json)
QMessageBox.information(self.view, ' ',
'Endpoint created successfully.')
self.set_view(self.welcome)
def load_endpoints(self):
self.choose_endpoint.endpoints.clear()
for name in listdir(str(BASE_PATH / 'endpoints')):
if name.endswith('.json'):
item = QListWidgetItem(
name.split('.json')[0], self.choose_endpoint.endpoints)
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
pb_msg_to_endpoints = defaultdict(list)
with open(str(BASE_PATH / 'endpoints' / name)) as fd:
for endpoint in load(fd):
pb_msg_to_endpoints[endpoint['request']['proto_msg'].
split('.')[-1]].append(endpoint)
for pb_msg, endpoints in pb_msg_to_endpoints.items():
item = QListWidgetItem(' ' * 4 + pb_msg,
self.choose_endpoint.endpoints)
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
for endpoint in endpoints:
item = QListWidgetItem(
' ' * 8 +
(urlparse(endpoint['request']['url']).path or '/'),
self.choose_endpoint.endpoints)
item.setData(Qt.UserRole, endpoint)
self.set_view(self.choose_endpoint)
"""
Step 3: Fuzz and test endpoints live
"""
def launch_fuzzer(self, item):
if type(item) == int:
data, sample_id = self.fuzzer.comboBox.itemData(item)
else:
data, sample_id = item.data(Qt.UserRole), 0
if data and assert_installed(self.view, binaries=['protoc']):
self.current_req_proto = BASE_PATH / 'protos' / data['request'][
'proto_path']
self.pb_request = load_proto_msgs(self.current_req_proto)
self.pb_request = dict(
self.pb_request)[data['request']['proto_msg']]()
if data.get('response') and data['response']['format'] == 'raw_pb':
self.pb_resp = load_proto_msgs(BASE_PATH / 'protos' /
data['response']['proto_path'])
self.pb_resp = dict(
self.pb_resp)[data['response']['proto_msg']]
self.pb_param = data['request'].get('pb_param')
self.base_url = data['request']['url']
self.endpoint = data
self.transport_meta = transports[data['request']['transport']]
self.transport = self.transport_meta['func'](self.pb_param,
self.base_url)
sample = ''
if data['request'].get('samples'):
sample = data['request']['samples'][sample_id]
self.get_params = self.transport.load_sample(
sample, self.pb_request)
# Get initial data into the Protobuf tree view
self.fuzzer.pbTree.clear()
self.parse_desc(self.pb_request.DESCRIPTOR, self.fuzzer.pbTree)
self.parse_fields(self.pb_request)
# Do the same for transport-specific data
self.fuzzer.getTree.clear()
if self.transport_meta.get('ui_tab'):
self.fuzzer.tabs.setTabText(1, self.transport_meta['ui_tab'])
if self.get_params:
for key, val in self.get_params.items():
ProtocolDataItem(self.fuzzer.getTree, key, val, self)
else:
self.fuzzer.tabs.setTabText(1, '(disabled)')
# how to hide it ?
# Fill the request samples combo box if we're loading a new
# endpoint.
if type(item) != int:
if len(data['request'].get('samples', [])) > 1:
self.fuzzer.comboBox.clear()
for sample_id, sample in enumerate(
data['request']['samples']):
self.fuzzer.comboBox.addItem(
sample[self.pb_param] if self.pb_param else
str(sample), (data, sample_id))
self.fuzzer.comboBoxLabel.show()
self.fuzzer.comboBox.show()
else:
self.fuzzer.comboBoxLabel.hide()
self.fuzzer.comboBox.hide()
self.set_view(self.fuzzer)
self.fuzzer.frame.setUrl(QUrl("about:blank"))
self.update_fuzzer()
"""
Parsing and rendering the Protobuf message to a tree view:
Every Protobuf field is fed to ProtobufItem (a class inheriting
QTreeWidgetItem), and the created object is saved in the _items
property of the corresponding descriptor.
"""
# First, parse the descriptor (structure) of the Protobuf message.
def parse_desc(self, msg, item, path=[]):
for ds in msg.fields:
new_item = ProtobufItem(item, ds, self, path)
if ds.type == ds.TYPE_MESSAGE and ds.full_name not in path:
self.parse_desc(ds.message_type, new_item,
path + [ds.full_name])
# Then, parse the fields (contents) of the Protobuf message.
def parse_fields(self, msg, path=[]):
for ds, val in msg.ListFields():
if ds.label == ds.LABEL_REPEATED:
for val_index, val_value in enumerate(val):
if ds.type == ds.TYPE_MESSAGE:
ds._items[tuple(path)].setExpanded(True)
ds._items[tuple(path)].setDefault(parent=msg,
msg=val,
index=val_index)
self.parse_fields(val_value, path + [ds.full_name])
else:
ds._items[tuple(path)].setDefault(val_value,
parent=msg,
msg=val,
index=val_index)
ds._items[tuple(path)].duplicate(True)
else:
if ds.type == ds.TYPE_MESSAGE:
ds._items[tuple(path)].setExpanded(True)
ds._items[tuple(path)].setDefault(parent=msg, msg=val)
self.parse_fields(val, path + [ds.full_name])
else:
ds._items[tuple(path)].setDefault(val, parent=msg, msg=val)
def update_fuzzer(self):
resp = self.transport.perform_request(self.pb_request, self.get_params)
data, text, url, mime = resp.content, resp.text, resp.url, resp.headers[
'Content-Type'].split(';')[0]
meta = '%s %d %08x\n%s' % (mime, len(data), crc32(data) & 0xffffffff,
resp.url)
self.fuzzer.urlField.setText(meta)
self.fuzzer.frame.update_frame(data, text, url, mime,
getattr(self, 'pb_resp', None))
def fuzz_endpoint(self):
QMessageBox.information(self.view, ' ',
'Automatic fuzzing is not implemented yet.')
def delete_endpoint(self):
if QMessageBox.question(self.view, ' ',
'Delete this endpoint?') == QMessageBox.Yes:
path = str(BASE_PATH / 'endpoints' /
(urlparse(self.base_url).netloc + '.json'))
with open(path) as fd:
json = load(fd)
json.remove(self.endpoint)
with open(path, 'w') as fd:
dump(json, fd, ensure_ascii=False, indent=4)
if not json:
remove(path)
self.load_endpoints()
"""
Utility methods follow
"""
def set_view(self, view):
if hasattr(self, 'view'):
self.view.hide()
view.show()
self.view = view
resolution = QDesktopWidget().screenGeometry()
view.move((resolution.width() / 2) - (view.frameSize().width() / 2),
(resolution.height() / 2) - (view.frameSize().height() / 2))
"""
signal() can't be called from inside a thread, and some
extractors need it in order not to have their GUI child process
interrupt signal catched by our main thread, so here is an ugly
way to reach signal() through a slot.
"""
def signal_proxy(self, *args):
signal(*args)
class MainWindow(QMainWindow):
inputReceived = pyqtSignal(str)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Left Browser tabs
self.ui.tabWidgetBrowser.removeTab(1)
self.ui.tabWidgetBrowser.removeTab(1)
self.ui.tabWidgetBrowser.setTabsClosable(True)
self.ui.tabWidgetBrowser.tabCloseRequested.connect(self.closeBrowserTab)
self.ui.tabWidgetBrowser.tabBarDoubleClicked.connect(lambda: self.maximizeTabs(self.ui.tabWidgetBrowser))
# Left tree views
self.fileTreeModel = QFileSystemModel(self)
self.fileTreeModel.setRootPath(QDir.currentPath() + QDir.separator() + 'test')
self.ui.treeViewFile.setModel(self.fileTreeModel)
self.ui.treeViewFile.setRootIndex(self.fileTreeModel.index(QDir.currentPath() + QDir.separator() + 'test'))
self.ui.treeViewFile.hideColumn(1)
self.ui.treeViewFile.hideColumn(2)
self.ui.treeViewFile.hideColumn(3)
self.ui.treeViewFile.doubleClicked.connect(self.openFileFromTree)
self.ui.treeViewFile.setAnimated(True)
self.ui.treeViewSyntax.setAnimated(True)
self.ui.treeViewToken.setAnimated(True)
self.ui.treeViewFile.setHeaderHidden(True)
self.ui.treeViewSyntax.setHeaderHidden(True)
self.ui.treeViewToken.setHeaderHidden(True)
# Editor tabs
self.currentEditor = self.ui.codeEditor
self.currentEditor.file = None
self.currentEditorTab = self.ui.tabEditor
self.openedEditors = [self.currentEditor]
self.openedEditorTabs = [self.currentEditorTab]
self.currentEditor.setFocus() # set focus
self.ui.tabWidgetEditor.tabCloseRequested.connect(self.closeEditorTab)
self.ui.tabWidgetEditor.tabBarClicked.connect(self.switchEditorTab)
self.ui.tabWidgetEditor.tabBarDoubleClicked.connect(lambda: self.maximizeTabs(self.ui.tabWidgetEditor))
# Bottom console
font = QFont()
font.setFamily("Courier")
font.setStyleHint(QFont.Monospace)
font.setFixedPitch(True)
font.setPointSize(10)
self.ui.console.setFont(font)
self.ui.console.setReadOnly(True)
self.waitInputCond = QWaitCondition()
self.oldConsoleText = None
# Bottom output tabs
self.ui.tabWidgetOutput.hide()
self.ui.tabWidgetOutput.tabCloseRequested.connect(self.closeOutputTab)
self.ui.tabWidgetOutput.tabBarDoubleClicked.connect(lambda: self.maximizeTabs(self.ui.tabWidgetOutput))
self.ui.tabWidgetOutput.setTabText(0, 'Console')
# Previous opened tabs,for maximizing
self.preOpenedTabs = None
# Initial size of inner splitter
self.ui.splitterInner.setSizes([180, 459 * 2 - 180])
# Menu "File"
self.ui.actionOpen.triggered.connect(self.openFile)
self.ui.actionNew.triggered.connect(self.newFile)
self.ui.actionSave.triggered.connect(self.saveFile)
self.ui.actionSaveAs.triggered.connect(self.saveFileAs)
self.ui.actionQuit.triggered.connect(self.close)
# Menu "Edit"
self.connectMenuEditSlots()
# Menu "View"
self.ui.menuView.triggered.connect(self.manageMenuView)
self.ui.actionAboutQt.triggered.connect(QApplication.aboutQt)
# Menu "Run"
self.ui.actionRun.triggered.connect(self.run)
self.ui.actionBuild.triggered.connect(self.runCompile)
self.ui.actionShowStable.triggered.connect(self.runSemantic)
self.ui.actionRunParser.triggered.connect(self.runParser)
self.ui.actionRunLexer.triggered.connect(self.runLexer)
@pyqtSlot(bool)
def runLexer(self, checked):
"""
Run lexer and present result on self.ui.tabToken Tree
:return:
"""
p = self.genParser(Parser.mode_lexer)
tokenNode = p.lexse() if p else None
if not tokenNode:
self.endEcho(False)
return
self.showBrowserTree(self.ui.tabToken, tokenNode)
self.endEcho(True)
@pyqtSlot(bool)
def runParser(self, checked):
"""
Run parser and present result on self.ui.tabSyntax Tree
:return:
"""
# Begin parse
p = self.genParser(Parser.mode_parser)
result = p.parse() if p else None
if not result:
self.endEcho(False)
return
syntaxNode, tokenNode = result
# self.showBrowserTree(self.ui.tabToken, tokenNode)
self.ui.treeViewToken.setModel(TreeModel(tokenNode))
self.showBrowserTree(self.ui.tabSyntax, syntaxNode)
self.endEcho(True)
@pyqtSlot(bool)
def runSemantic(self, checked):
"""
run semantics analysing and print symbol table
:return:
"""
p = self.genParser(Parser.mode_stable)
result = p.semantic() if p else None
if not result:
self.endEcho(False)
return
stable, syntaxNode, tokenNode = result
self.ui.treeViewToken.setModel(TreeModel(tokenNode))
self.ui.treeViewSyntax.setModel(TreeModel(syntaxNode))
self.endEcho(True)
@pyqtSlot(bool)
def runCompile(self, checked):
"""
Run compiler and print Intermediate code
:return:
"""
p = self.genParser(Parser.mode_compile)
result = p.compile() if p else None
if not result:
self.endEcho(False)
return
codes, stable, syntaxNode, tokenNode = result
self.ui.treeViewToken.setModel(TreeModel(tokenNode))
self.ui.treeViewSyntax.setModel(TreeModel(syntaxNode))
self.endEcho(True)
@pyqtSlot(bool)
def run(self, checked):
"""
compile and run the source code
compile in main thread and run in a worker thread
"""
p = self.genParser(Parser.mode_execute)
result = p.compile() if p else None
if not result:
self.endEcho(False)
return
codes, stable, syntaxNode, tokenNode = result
self.ui.treeViewToken.setModel(TreeModel(tokenNode))
self.ui.treeViewSyntax.setModel(TreeModel(syntaxNode))
console = Console(self.ui.console, parent=self, waitCond=self.waitInputCond)
console.update.connect(self.updateOutput)
self.inputReceived.connect(console.receivedInput)
self.ui.console.blockCountChanged.connect(self.waitInput)
self.ui.console.textChanged.connect(self.disableBack)
interp = Interpreter(codes, stdin=console, stdout=console, stderr=console)
thread = ExecuteThread(interp.inter, self)
thread.start()
def genParser(self, mode=Parser.mode_execute):
"""
Generate a parser instance
:param mode:
:return:
"""
if not self.saveFile():
return
self.showOutputPanel()
self.ui.actionViewConsole.setChecked(True)
self.beginEcho()
stdin = open(self.currentEditor.file, 'r')
console = Console(self.ui.console, parent=self)
console.update.connect(self.updateOutput)
return Parser(stdin, stdout=console, stderr=console, mode=mode)
def beginEcho(self):
self.updateOutput('%s\n' % self.currentEditor.file)
def endEcho(self, success=True):
msg = 'successfully' if success else 'unsuccessfully'
self.updateOutput('Process finished %s\n' % msg)
@pyqtSlot(str)
def updateOutput(self, content):
"""
Update bottom text browser when content is writen to it.
:param content:
:return:
"""
self.ui.console.moveCursor(QTextCursor.End)
self.ui.console.insertPlainText('%s' % content)
self.oldConsoleText = self.ui.console.toPlainText()
@pyqtSlot(int)
def waitInput(self, newBlockCount):
"""
:param newBlockCount: line count
:return:
"""
if not self.ui.console.isReadOnly():
self.inputReceived.emit(self.ui.console.toPlainText()
.replace(self.oldConsoleText, ''))
self.waitInputCond.wakeAll()
self.ui.console.setReadOnly(True)
@pyqtSlot()
def disableBack(self):
"""
disable backspace when waiting for input
:return:
"""
if not self.ui.console.isReadOnly():
if len(self.oldConsoleText) > len(self.ui.console.toPlainText()):
self.ui.console.setPlainText(self.oldConsoleText)
self.ui.console.moveCursor(QTextCursor.End)
def closeEvent(self, event):
"""
Override. When Close Event Triggered.
Ask user for saving modified files
:param event:
:return:
"""
for i in range(len(self.openedEditors)):
editor = self.openedEditors[i]
editorTab = self.openedEditorTabs[i]
if editor.document().isModified():
name = ntpath.basename(editor.file) if editor.file else 'New File'
ret = QMessageBox.warning(
self, name,
'The document has been modified.\nDo you want to save your changes?',
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
if ret == QMessageBox.Save:
event.accept() if self.saveFile() else event.ignore()
elif ret == QMessageBox.Discard:
index = self.ui.tabWidgetEditor.indexOf(editorTab)
self.ui.tabWidgetEditor.removeTab(index)
event.accept()
else:
event.ignore()
def showOutputPanel(self):
"""
Clear previous output and show the ouput panel
:return:
"""
self.ui.console.clear()
self.ui.tabWidgetOutput.show()
def showBrowserTree(self, tab, rootNode):
"""
Show treeView on tabWidgetBrowser
:param tab:
:param rootNode:
"""
model = TreeModel(rootNode)
if tab == self.ui.tabSyntax:
treeView = self.ui.treeViewSyntax
name = 'Syntax'
self.ui.actionViewSystaxTree.setChecked(True)
else:
treeView = self.ui.treeViewToken
name = 'Token'
self.ui.actionViewTokenTree.setChecked(True)
treeView.setModel(model)
# show the tab
index = self.ui.tabWidgetBrowser.indexOf(tab)
if index == -1:
self.ui.tabWidgetBrowser.addTab(tab, name)
index = self.ui.tabWidgetBrowser.indexOf(tab)
self.ui.tabWidgetBrowser.setCurrentIndex(index)
self.addjustBrowserWidth()
def connectMenuEditSlots(self):
"""
set menu "Edit" signals connect to current editor slots
:return:
"""
self.ui.actionCopy.triggered.connect(self.currentEditor.copy)
self.ui.actionCut.triggered.connect(self.currentEditor.cut)
self.ui.actionPaste.triggered.connect(self.currentEditor.paste)
self.ui.actionUndo.triggered.connect(self.currentEditor.undo)
self.ui.actionRedo.triggered.connect(self.currentEditor.redo)
self.ui.actionSelectAll.triggered.connect(self.currentEditor.selectAll)
def disconnectMenuEditSlots(self):
"""
disconnect menu "Edit" signals
:return:
"""
self.ui.actionCopy.triggered.disconnect(self.currentEditor.copy)
self.ui.actionCut.triggered.disconnect(self.currentEditor.cut)
self.ui.actionPaste.triggered.disconnect(self.currentEditor.paste)
self.ui.actionUndo.triggered.disconnect(self.currentEditor.undo)
self.ui.actionRedo.triggered.disconnect(self.currentEditor.redo)
self.ui.actionSelectAll.triggered.disconnect(self.currentEditor.selectAll)
def createEditorTab(self):
"""
Create a new Editor tab and set as current editor
Should reconnect the signal on menu 'Edit' actions
:return:
"""
# add a new editor
self.currentEditorTab = QtWidgets.QWidget()
horizontalLayout = QtWidgets.QHBoxLayout(self.currentEditorTab)
horizontalLayout.setContentsMargins(0, 0, 0, 0)
horizontalLayout.setSpacing(6)
codeEditor = CodeEditor(self.currentEditorTab)
horizontalLayout.addWidget(codeEditor)
self.ui.tabWidgetEditor.addTab(self.currentEditorTab, "")
# disconnect signals
self.disconnectMenuEditSlots()
# change current tab and editors
self.currentEditor = codeEditor
self.currentEditor.file = None
self.openedEditors.append(self.currentEditor)
self.openedEditorTabs.append(self.currentEditorTab)
# connect signals
self.connectMenuEditSlots()
# set tab closeable
if len(self.openedEditorTabs) > 1:
self.ui.tabWidgetEditor.setTabsClosable(True)
@pyqtSlot(int)
def switchEditorTab(self, index):
"""
Switch current active editor tab to index
Should reconnect the signal on menu 'Edit' actions
:param index:
:return:
"""
self.disconnectMenuEditSlots()
self.currentEditorTab = self.openedEditorTabs[index]
self.currentEditor = self.openedEditors[index]
self.connectMenuEditSlots()
@pyqtSlot(int)
def closeEditorTab(self, index):
"""
Triggered when closing the editor tab at index requested
:param index:
:return:
"""
self.ui.tabWidgetEditor.removeTab(index)
self.openedEditorTabs.pop(index)
self.openedEditors.pop(index)
self.switchEditorTab(0) # choose the beginning tab as current active
if len(self.openedEditorTabs) == 1:
self.ui.tabWidgetEditor.setTabsClosable(False)
@pyqtSlot(int)
def closeBrowserTab(self, index):
"""
Close Left Browser Tab at index
:param index:
:return:
"""
# make menu "View" corresponding
w = self.ui.tabWidgetBrowser.widget(index)
if w == self.ui.tabFile:
self.ui.actionViewFiles.setChecked(False)
elif w == self.ui.tabToken:
self.ui.actionViewTokenTree.setChecked(False)
else:
self.ui.actionViewSystaxTree.setChecked(False)
# remove tab
self.ui.tabWidgetBrowser.removeTab(index)
if self.ui.tabWidgetBrowser.count() == 0:
self.ui.tabWidgetBrowser.hide()
@pyqtSlot(int)
def closeOutputTab(self, index):
"""
Close(hide) the output tab widget
:param index:
"""
# make menu "View" corresponding
self.ui.actionViewConsole.setChecked(False)
self.ui.tabWidgetOutput.hide()
def recoverTabWidgets(self):
"""
recover tabs when cancel maximizing
:return:
"""
for tab in self.preOpenedTabs:
tab.show()
self.preOpenedTabs = None
def storeOpenedTabs(self):
"""
store tabs opened before maximize
:return:
"""
self.preOpenedTabs = []
if not self.ui.tabWidgetOutput.isHidden():
self.preOpenedTabs.append(self.ui.tabWidgetOutput)
if not self.ui.tabWidgetEditor.isHidden():
self.preOpenedTabs.append(self.ui.tabWidgetEditor)
if not self.ui.tabWidgetBrowser.isHidden():
self.preOpenedTabs.append(self.ui.tabWidgetBrowser)
def maximizeTabs(self, widget):
if self.preOpenedTabs:
self.recoverTabWidgets()
else:
self.storeOpenedTabs()
for w in [self.ui.tabWidgetBrowser, self.ui.tabWidgetOutput, self.ui.tabWidgetEditor]:
if w != widget:
w.hide()
@pyqtSlot(QAction)
def manageMenuView(self, action):
"""
Handle the action on menu "View"
:param action:
:return:
"""
if action == self.ui.actionViewToolbar:
self.ui.toolBar.show() if action.isChecked() else self.ui.toolBar.hide()
return
pair = {
self.ui.actionViewFiles: (self.ui.tabWidgetBrowser, self.ui.tabFile, 'File'),
self.ui.actionViewTokenTree: (self.ui.tabWidgetBrowser, self.ui.tabToken, 'Token'),
self.ui.actionViewSystaxTree: (self.ui.tabWidgetBrowser, self.ui.tabSyntax, 'Syntax'),
self.ui.actionViewConsole: (self.ui.tabWidgetOutput, self.ui.tabConsole, 'Console'),
}
p = pair[action]
widget = p[0]
tab = p[1]
name = p[2]
if action.isChecked():
widget.addTab(tab, name)
widget.setCurrentWidget(tab)
if widget == self.ui.tabWidgetBrowser: # reset tab inner splitter size
self.addjustBrowserWidth()
if widget.isHidden():
widget.show()
else:
widget.removeTab(
widget.indexOf(tab))
if widget.count() == 0:
widget.hide()
def addjustBrowserWidth(self):
w = self.ui.tabWidgetBrowser.count() * 80
self.ui.splitterInner.setSizes([w, self.ui.splitterInner.width() - w])
@pyqtSlot(bool)
def openFile(self, checked=True, path=None):
"""
Open a new file.
If current editor is associated with a file or its content is not null,
Then create a new editor tab
:return:
"""
path = QFileDialog.getOpenFileName()[0] if not path else path
if len(path) != 0:
qfile = QFile(path)
if not qfile.open(QFile.ReadOnly or QFile.Text):
QMessageBox.warning(self, 'Application',
'Cannot read file %s:\n%s.' % (path, qfile.errorString()))
return
with open(path, 'r') as _file:
content = _file.read()
if self.currentEditor.file or len(self.currentEditor.document().toPlainText()) > 0:
self.createEditorTab()
# associate file on disk with editor
self.currentEditor.file = path
# update tab name
index = self.ui.tabWidgetEditor.indexOf(self.currentEditorTab)
_translate = QCoreApplication.translate
self.ui.tabWidgetEditor.setTabText(
index, _translate("MainWindow", ntpath.basename(path)))
self.ui.tabWidgetEditor.setCurrentIndex(index)
self.currentEditor.setPlainText(content)
@pyqtSlot(int)
def openFileFromTree(self, index):
f = self.fileTreeModel.fileInfo(index)
if f.isFile():
self.openFile(path=f.filePath())
@pyqtSlot(bool)
def newFile(self, checked):
"""
create a new editor tab
:param action:
:return:
"""
self.createEditorTab()
index = self.ui.tabWidgetEditor.indexOf(self.currentEditorTab)
_translate = QCoreApplication.translate
self.ui.tabWidgetEditor.setTabText(
index, _translate("MainWindow", 'New File'))
self.ui.tabWidgetEditor.setCurrentIndex(index)
@pyqtSlot(bool)
def saveFile(self, checked=None):
"""
Save file.
If current editor is associated with a file on the disk,
then save it. Or save file as...
:param checked:
:return: Saved or canceled
"""
if self.currentEditor.file:
if self.currentEditor.document().isModified():
with open(self.currentEditor.file, 'w') as f:
f.write(self.currentEditor.document().toPlainText())
self.currentEditor.document().setModified(False)
return True
else:
return self.saveFileAs()
@pyqtSlot(bool)
def saveFileAs(self, checked=None):
"""
Save File As...
:param checked:
:return: If saved or canceled
"""
dialog = QFileDialog()
dialog.setWindowModality(Qt.WindowModal)
dialog.setAcceptMode(QFileDialog.AcceptSave)
if dialog.exec_():
filepath = dialog.selectedFiles()[0]
with open(filepath, 'w') as f:
f.write(self.currentEditor.document().toPlainText())
self.currentEditor.document().setModified(False)
self.currentEditor.file = filepath
return True
else:
return False
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 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 = None
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):
viewer = ImageViewer(self.db, parent=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 = [f for f in files if os.path.isfile(f)]
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 Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(680, 482)
self.centralWidget = QtWidgets.QWidget(MainWindow)
self.centralWidget.setObjectName("centralWidget")
self.frame = E(self.centralWidget)
self.frame.setGeometry(QtCore.QRect(9, 9, 431, 411))
self.frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame.setObjectName("frame")
self.c = Communicate()
self.c.spriteDrawMsg.connect(self.frame.spriteDrawController)
self.c.rectDrawMsg.connect(self.frame.rectDrawController)
self.c.circleDrawMsg.connect(self.frame.circleDrawController)
self.tabWidget = QtWidgets.QTabWidget(self.centralWidget)
self.tabWidget.setGeometry(QtCore.QRect(450, 10, 221, 411))
self.tabWidget.setObjectName("tabWidget")
self.tab = QtWidgets.QWidget()
self.tab.setObjectName("tab")
self.tabWidget.addTab(self.tab, "")
self.tab_2 = QtWidgets.QWidget()
self.tab_2.setObjectName("tab_2")
self.treeView = QtWidgets.QTreeView(self.tab_2)
self.treeView.setGeometry(QtCore.QRect(0, 0, 221, 221))
self.treeView.setObjectName("treeView")
########################################### get selected sprite file path and send signal to frame
def sendSpriteDrawMsg(item):
index = self.treeView.currentIndex()
p = self.model.filePath(index)
self.c.spriteDrawMsg.emit(p, "sprite")
self.treeView.doubleClicked.connect(sendSpriteDrawMsg)
##################################################################################################
########################################### send drawRect signal to frame
def sendRectDrawMsg(item):
# do needed things here
self.c.spriteDrawMsg.emit("rect")
# send a signal to sendRectDrawMsg here
##########################################################################
########################################### send drawCircle signal to frame
def sendCircleDrawMsg(item):
# do needed things here
self.c.spriteDrawMsg.emit("circle")
# send a signal to sendCircleDrawMsg here
#############################################################################
self.model = QFileSystemModel()
self.path = "."
self.model.setRootPath(self.path)
# self.filter = Iterable("*.png")
# self.model.setNameFilters(self.filter)
# self.model.removeColumn(1)
# self.model.removeColumn(2)
# self.model.removeColumn(3)
# self.model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot | QDir.AllEntries)
#
# self.proxyModel = QSortFilterProxyModel()
# self.proxyModel.setSourceModel(model)
# self.proxyModel.removeColumn(1)
# self.proxyModel.removeColumn(2)
# self.proxyModel.removeColumn(3)
self.treeView.setModel(self.model)
self.treeView.setRootIndex(self.model.index(self.path))
self.treeView.expandAll()
self.listView = QtWidgets.QListView(self.tab_2)
self.listView.setGeometry(QtCore.QRect(0, 240, 221, 141))
self.listView.setObjectName("listView")
self.line = QtWidgets.QFrame(self.tab_2)
self.line.setGeometry(QtCore.QRect(30, 220, 151, 20))
self.line.setFrameShape(QtWidgets.QFrame.HLine)
self.line.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line.setObjectName("line")
self.tabWidget.addTab(self.tab_2, "")
MainWindow.setCentralWidget(self.centralWidget)
self.menuBar = QtWidgets.QMenuBar(MainWindow)
self.menuBar.setGeometry(QtCore.QRect(0, 0, 680, 25))
self.menuBar.setObjectName("menuBar")
self.menuChert_Engine = QtWidgets.QMenu(self.menuBar)
self.menuChert_Engine.setObjectName("menuChert_Engine")
MainWindow.setMenuBar(self.menuBar)
self.mainToolBar = QtWidgets.QToolBar(MainWindow)
self.mainToolBar.setObjectName("mainToolBar")
MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.mainToolBar)
self.statusBar = QtWidgets.QStatusBar(MainWindow)
self.statusBar.setObjectName("statusBar")
MainWindow.setStatusBar(self.statusBar)
self.menuBar.addAction(self.menuChert_Engine.menuAction())
self.retranslateUi(MainWindow)
self.tabWidget.setCurrentIndex(1)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab), _translate("MainWindow", "Tab 1"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2), _translate("MainWindow", "Tab 2"))
self.menuChert_Engine.setTitle(_translate("MainWindow", "Chert Engine"))
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])
