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])