def mousePressEvent(self, event):
if event.button() == Qt.RightButton:
# Capture mouse press so that selection doesn't change
# on right click
pass
else:
QTreeView.mousePressEvent(self, event)
def setModel(self, model):
QTreeView.setModel(self, model)
# Setting delegates
self.outlineTitleDelegate = outlineTitleDelegate(self)
# self.outlineTitleDelegate.setView(self)
self.setItemDelegateForColumn(Outline.title, self.outlineTitleDelegate)
self.outlineCharacterDelegate = outlineCharacterDelegate(self.modelCharacters)
self.setItemDelegateForColumn(Outline.POV, self.outlineCharacterDelegate)
self.outlineCompileDelegate = outlineCompileDelegate()
self.setItemDelegateForColumn(Outline.compile, self.outlineCompileDelegate)
self.outlineStatusDelegate = outlineStatusDelegate(self.modelStatus)
self.setItemDelegateForColumn(Outline.status, self.outlineStatusDelegate)
self.outlineGoalPercentageDelegate = outlineGoalPercentageDelegate()
self.setItemDelegateForColumn(Outline.goalPercentage, self.outlineGoalPercentageDelegate)
self.outlineLabelDelegate = outlineLabelDelegate(self.modelLabels)
self.setItemDelegateForColumn(Outline.label, self.outlineLabelDelegate)
# Hiding columns
self.hideColumns()
self.header().setSectionResizeMode(Outline.title, QHeaderView.Stretch)
self.header().setSectionResizeMode(Outline.POV, QHeaderView.ResizeToContents)
self.header().setSectionResizeMode(Outline.status, QHeaderView.ResizeToContents)
self.header().setSectionResizeMode(Outline.label, QHeaderView.ResizeToContents)
self.header().setSectionResizeMode(Outline.compile, QHeaderView.ResizeToContents)
self.header().setSectionResizeMode(Outline.wordCount, QHeaderView.ResizeToContents)
self.header().setSectionResizeMode(Outline.goal, QHeaderView.ResizeToContents)
self.header().setSectionResizeMode(Outline.goalPercentage, QHeaderView.ResizeToContents)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.fileMenu = self.menuBar().addMenu("&File")
self.fileMenu.addAction("&Open...", self.openFile, "Ctrl+O")
self.fileMenu.addAction("E&xit", self.close, "Ctrl+Q")
self.xmlPath = ""
self.model = DomModel(QDomDocument(), self)
self.view = QTreeView(self)
self.view.setModel(self.model)
self.setCentralWidget(self.view)
self.setWindowTitle("Simple DOM Model")
def openFile(self):
filePath, _ = QFileDialog.getOpenFileName(self, "Open File",
self.xmlPath, "XML files (*.xml);;HTML files (*.html);;"
"SVG files (*.svg);;User Interface files (*.ui)")
if filePath:
f = QFile(filePath)
if f.open(QIODevice.ReadOnly):
document = QDomDocument()
if document.setContent(f):
newModel = DomModel(document, self)
self.view.setModel(newModel)
self.model = newModel
self.xmlPath = filePath
f.close()
class GetNodeDialog(QDialog):
def __init__(self, parent, startnode, currentnode=None):
QDialog.__init__(self, parent)
layout = QVBoxLayout(self)
self.treeview = QTreeView(self)
self.treeview.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.tree = TreeWidget(self.treeview)
self.tree.set_root_node(startnode)
layout.addWidget(self.treeview)
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal, self)
layout.addWidget(self.buttons)
self.resize(800, 600)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.treeview.activated.connect(self.accept)
if currentnode:
self.tree.expand_to_node(currentnode)
def get_node(self):
return self.tree.get_current_node()
@staticmethod
def getNode(parent, startnode, currentnode=None):
dialog = GetNodeDialog(parent, startnode, currentnode)
result = dialog.exec_()
node = dialog.get_node()
return node, result == QDialog.Accepted
def __init__(self, parent=None, cols=None, **kwargs):
QTreeView.__init__(self, parent=parent, **kwargs)
self.setSortingEnabled(True)
self.setAlternatingRowColors(True)
if cols != None:
model = VQTreeModel(parent=self, columns=cols)
self.setModel( model )
def blockSignals(self, block):
"""
Blocks the signals from this class. Subclassed in order to also block
selectionChanged "signal" (callback) options
@param block: whether to block signal (True) or not (False)
"""
self.signals_blocked = block
QTreeView.blockSignals(self, block)
def setModel(self, model):
QTreeView.setModel(self, model)
# Hiding columns
for c in range(1, self.model().columnCount()):
self.hideColumn(c)
# Setting delegate
self.titleDelegate = treeTitleDelegate()
self.setItemDelegateForColumn(Outline.title.value, self.titleDelegate)
def __init__(self, parent=None, modelCharacters=None, modelLabels=None, modelStatus=None):
QTreeView.__init__(self, parent)
dndView.__init__(self)
outlineBasics.__init__(self, parent)
self.modelCharacters = modelCharacters
self.modelLabels = modelLabels
self.modelStatus = modelStatus
self.header().setStretchLastSection(False)
def selectionChanged(self, selected, deselected):
"""
Function called by QT when the selection has changed for this treeView.
Subclassed in order to call a callback function options
@param selected: list of selected items
@param deselected: list of deselected items
print("\033[32;1mselectionChanged selected count = {0} ; deselected count = {1}\033[m".format(selected.count(), deselected.count()))
"""
QTreeView.selectionChanged(self, selected, deselected)
if self.selectionChangedcallback and not self.signals_blocked:
self.selectionChangedcallback(self, selected, deselected)
def __init__(self, fileBrowser):
QTreeView.__init__(self, fileBrowser)
self._fileBrowser = fileBrowser
self.setAttribute(Qt.WA_MacShowFocusRect, False)
self.setAttribute(Qt.WA_MacSmallSize)
self.setContextMenuPolicy(Qt.ActionsContextMenu)
self.setHeaderHidden(True)
self.setUniformRowHeights(True)
self.setTextElideMode(Qt.ElideMiddle)
# dir model
self._dirsModel = _FileSystemModel(self)
self._dirsModel.setNameFilterDisables(False)
self._dirsModel.setFilter(QDir.AllDirs | QDir.AllEntries | QDir.CaseSensitive | QDir.NoDotAndDotDot)
# self._dirsModel.directoryLoaded.connect(self.setFocus) TODO don't have this signal in my Qt version
# create proxy model
self._filteredModel = FileBrowserFilteredModel(self)
self._filteredModel.setSourceModel(self._dirsModel)
self.setModel(self._filteredModel)
if not sys.platform.startswith('win'):
self._dirsModel.setRootPath("/")
else:
self._dirsModel.setRootPath('')
# shortcut accessible only when self._tree has focus
self._upShortcut = QShortcut(QKeySequence("BackSpace"), self)
self._upShortcut.setContext(Qt.WidgetShortcut)
self._upShortcut.activated.connect(self.moveUp)
# shortcut accessible only when self._tree has focus
self._homeShortcut = QShortcut(QKeySequence("`"), self)
self._homeShortcut.setContext(Qt.WidgetShortcut)
self._homeShortcut.activated.connect(self._goUserHomeDir)
# shortcut accessible only when self._tree has focus
self._homeShortcut = QShortcut(QKeySequence("."), self)
self._homeShortcut.setContext(Qt.WidgetShortcut)
self._homeShortcut.activated.connect(self._goCurrentDir)
self.activated.connect(self._onActivated)
self._fileActivated.connect(fileBrowser.fileActivated)
# QDirModel loads item asynchronously, therefore we need timer for setting focus to the first item
self._setFocusTimer = QTimer()
self._setFocusTimer.timeout.connect(self._setFirstItemAsCurrent)
self._setFocusTimer.setInterval(50)
self._timerAttempts = 0
def __init__(self, parent = None):
"""
Initialization of the TreeView class.
"""
QTreeView.__init__(self, parent)
self.dragged_element = False #No item is currently dragged & dropped
self.dragged_element_model_index = None
self.selectionChangedcallback = None
self.keyPressEventcallback = None
self.signals_blocked = False #Transmit events between classes
self.pressed.connect(self.elementPressed)
def _mock_view_index(model, category_idx, child_idx, qtbot):
"""Create a tree view from a model and set the current index.
Args:
model: model to create a fake view for.
category_idx: index of the category to select.
child_idx: index of the child item under that category to select.
"""
view = QTreeView()
qtbot.add_widget(view)
view.setModel(model)
idx = model.indexFromItem(model.item(category_idx).child(child_idx))
view.setCurrentIndex(idx)
return view
def keyPressEvent(self, keyEvent):
"""
Function called by QT when a key has been pressed inside the treeView.
Subclassed in order to call a callback function
@param keyEvent: keyboard event
print("\033[31;1mkeyPressEvent() key = {0}\033[m".format(keyEvent.key()))
"""
if self.keyPressEventcallback and not self.signals_blocked:
if not self.keyPressEventcallback(keyEvent):
# key not accepted => send it back to the parent
QTreeView.keyPressEvent(self, keyEvent)
else:
QTreeView.keyPressEvent(self, keyEvent)
def __init__(self, projects, parent=None):
super(AddToProject, self).__init__(parent)
#pathProjects must be a list
self._projects = projects
self.setWindowTitle(translations.TR_ADD_FILE_TO_PROJECT)
self.pathSelected = ''
vbox = QVBoxLayout(self)
hbox = QHBoxLayout()
self._list = QListWidget()
for project in self._projects:
self._list.addItem(project.name)
self._list.setCurrentRow(0)
self._tree = QTreeView()
#self._tree.header().setHidden(True)
self._tree.setSelectionMode(QTreeView.SingleSelection)
self._tree.setAnimated(True)
self.load_tree(self._projects[0])
hbox.addWidget(self._list)
hbox.addWidget(self._tree)
vbox.addLayout(hbox)
hbox2 = QHBoxLayout()
btnAdd = QPushButton(translations.TR_ADD_HERE)
btnCancel = QPushButton(translations.TR_CANCEL)
hbox2.addWidget(btnCancel)
hbox2.addWidget(btnAdd)
vbox.addLayout(hbox2)
btnCancel.connect(self.close)
btnAdd.connect(self._select_path)
self._list.currentItemChanged['QTreeWidgetItem*', 'QTreeWidgetItem*'].connect(self._project_changed)
def _createUi(self):
self.setWindowTitle(core.project().path().replace(os.sep, '/') or 'Locator')
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(1)
biggerFont = self.font()
biggerFont.setPointSizeF(biggerFont.pointSizeF() * 2)
self.setFont(biggerFont)
self._edit = _CompletableLineEdit(self)
self._edit.updateCurrentCommand.connect(self._updateCurrentCommand)
self._edit.enterPressed.connect(self._onEnterPressed)
self._edit.installEventFilter(self) # catch Up, Down
self._edit.setFont(biggerFont)
self.layout().addWidget(self._edit)
self.setFocusProxy(self._edit)
self._table = QTreeView(self)
self._table.setFont(biggerFont)
self._model = _CompleterModel()
self._table.setModel(self._model)
self._table.setItemDelegate(HTMLDelegate(self._table))
self._table.setRootIsDecorated(False)
self._table.setHeaderHidden(True)
self._table.clicked.connect(self._onItemClicked)
self._table.setAlternatingRowColors(True)
self._table.installEventFilter(self) # catch focus and give to the edit
self.layout().addWidget(self._table)
width = QFontMetrics(self.font()).width('x' * 64) # width of 64 'x' letters
self.resize(width, width * 0.62)
def __init__(self, parent):
DockWidget.__init__(self, parent, "&Search Results", QIcon(":/enkiicons/search.png"), "Alt+S")
# actions
widget = QWidget(self)
self._model = searchresultsmodel.SearchResultsModel(self)
self.onResultsHandledByReplaceThread.connect(self._model.onResultsHandledByReplaceThread)
self._view = QTreeView(self)
self._view.setHeaderHidden(True)
self._view.setUniformRowHeights(True)
self._view.setModel(self._model)
self._delegate = HTMLDelegate()
self._view.setItemDelegate(self._delegate)
self._layout = QHBoxLayout(widget)
self._layout.setContentsMargins(5, 5, 5, 5)
self._layout.setSpacing(5)
self._layout.addWidget(self._view)
self.setWidget(widget)
self.setFocusProxy(self._view)
# connections
self._model.firstResultsAvailable.connect(self.show)
self._view.activated.connect(self._onResultActivated)
core.actionManager().addAction("mView/aSearchResults", self.showAction())
self._expandCollapseAll = ExpandCollapseAllButton(self.titleBarWidget(), self._view, self._model)
self._checkUncheckAll = None
def _setupUi(self):
self.setWindowTitle(self.app.NAME)
self.resize(420, 338)
self.centralwidget = QWidget(self)
self.verticalLayout = QVBoxLayout(self.centralwidget)
self.promptLabel = QLabel(tr("Select folders to scan and press \"Scan\"."), self.centralwidget)
self.verticalLayout.addWidget(self.promptLabel)
self.treeView = QTreeView(self.centralwidget)
self.treeView.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.treeView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.treeView.setAcceptDrops(True)
triggers = QAbstractItemView.DoubleClicked | QAbstractItemView.EditKeyPressed\
| QAbstractItemView.SelectedClicked
self.treeView.setEditTriggers(triggers)
self.treeView.setDragDropOverwriteMode(True)
self.treeView.setDragDropMode(QAbstractItemView.DropOnly)
self.treeView.setUniformRowHeights(True)
self.verticalLayout.addWidget(self.treeView)
hl = QHBoxLayout()
hl.setAlignment(Qt.AlignLeft)
label = QLabel(tr("Scan Type:"), self)
label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
hl.addWidget(label)
self.scanTypeComboBox = QComboBox(self)
self.scanTypeComboBox.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed))
self.scanTypeComboBox.setMaximumWidth(400)
for scan_option in self.app.model.SCANNER_CLASS.get_scan_options():
self.scanTypeComboBox.addItem(scan_option.label)
hl.addWidget(self.scanTypeComboBox)
self.showPreferencesButton = QPushButton(tr("Options"), self.centralwidget)
self.showPreferencesButton.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
hl.addWidget(self.showPreferencesButton)
self.verticalLayout.addLayout(hl)
self.horizontalLayout = QHBoxLayout()
self.removeFolderButton = QPushButton(self.centralwidget)
self.removeFolderButton.setIcon(QIcon(QPixmap(":/minus")))
self.removeFolderButton.setShortcut("Del")
self.horizontalLayout.addWidget(self.removeFolderButton)
self.addFolderButton = QPushButton(self.centralwidget)
self.addFolderButton.setIcon(QIcon(QPixmap(":/plus")))
self.horizontalLayout.addWidget(self.addFolderButton)
spacerItem1 = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem1)
self.loadResultsButton = QPushButton(self.centralwidget)
self.loadResultsButton.setText(tr("Load Results"))
self.horizontalLayout.addWidget(self.loadResultsButton)
self.scanButton = QPushButton(self.centralwidget)
self.scanButton.setText(tr("Scan"))
self.scanButton.setDefault(True)
self.horizontalLayout.addWidget(self.scanButton)
self.verticalLayout.addLayout(self.horizontalLayout)
self.setCentralWidget(self.centralwidget)
self._setupActions()
self._setupMenu()
if self.app.prefs.directoriesWindowRect is not None:
self.setGeometry(self.app.prefs.directoriesWindowRect)
else:
moveToScreenCenter(self)
def createTreeView(self):
dockWidget = QDockWidget()
dockWidget.setAllowedAreas(Qt.LeftDockWidgetArea)
dockWidget.setFeatures(QDockWidget.NoDockWidgetFeatures)
dockWidget.setTitleBarWidget(QWidget())
self.treeView = QTreeView()
self.treeView.clicked.connect(self.treeItemClicked)
self.treeModel = TreeModel()
self.treeView.setModel(self.treeModel)
self.logo = QLabel()
logoPixmap = QPixmap(CMAKE_INSTALL_PREFIX + '/share/jderobot/resources/jderobot.png')
self.logo.setPixmap(logoPixmap)
self.upButton = QPushButton()
self.upButton.setText('Up')
self.upButton.clicked.connect(self.upButtonClicked)
leftContainer = QWidget()
leftLayout = QVBoxLayout()
leftLayout.addWidget(self.treeView)
leftLayout.addWidget(self.upButton)
leftLayout.addWidget(self.logo)
leftContainer.setLayout(leftLayout)
dockWidget.setWidget(leftContainer)
self.addDockWidget(Qt.LeftDockWidgetArea, dockWidget)
def __init__(self, workspace):
DockWidget.__init__(self, workspace, "&Opened Files", QIcon(":/enkiicons/filtered.png"), "Alt+O")
self._workspace = workspace
self.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
self.tvFiles = QTreeView(self)
self.tvFiles.setHeaderHidden(True)
self.tvFiles.setEditTriggers(QAbstractItemView.SelectedClicked)
self.tvFiles.setContextMenuPolicy(Qt.CustomContextMenu)
self.tvFiles.setDragEnabled(True)
self.tvFiles.setDragDropMode(QAbstractItemView.InternalMove)
self.tvFiles.setRootIsDecorated(False)
self.tvFiles.setTextElideMode(Qt.ElideMiddle)
self.tvFiles.setUniformRowHeights(True)
self.tvFiles.customContextMenuRequested.connect(self._onTvFilesCustomContextMenuRequested)
self.setWidget(self.tvFiles)
self.setFocusProxy(self.tvFiles)
self.model = _OpenedFileModel(self) # Not protected, because used by Configurator
self.tvFiles.setModel(self.model)
self.tvFiles.setAttribute(Qt.WA_MacShowFocusRect, False)
self.tvFiles.setAttribute(Qt.WA_MacSmallSize)
self._workspace.currentDocumentChanged.connect(self._onCurrentDocumentChanged)
# disconnected by startModifyModel()
self.tvFiles.selectionModel().selectionChanged.connect(self._onSelectionModelSelectionChanged)
self.tvFiles.activated.connect(self._workspace.focusCurrentDocument)
core.actionManager().addAction("mView/aOpenedFiles", self.showAction())
def contextMenuEvent(self, event):
menu = QMenu(self)
attachAction = menu.addAction(_("Add sheet"))
attachAction.triggered.connect(self.add_sheet)
menu.exec_(self.mapToGlobal(event.pos()))
return QTreeView.contextMenuEvent(self, event)
def setModel(self, model):
smodel = QtCore.QSortFilterProxyModel(parent=self)
smodel.setSourceModel(model)
ret = QTreeView.setModel(self, smodel)
c = len(model.columns)
for i in xrange(c):
self.resizeColumnToContents(i)
return ret
def __init__(self, project, type_, parent=None):
"""
Constructor
@param project reference to the project object
@param type_ project browser type (string)
@param parent parent widget of this browser
"""
QTreeView.__init__(self, parent)
self.project = project
self._model = project.getModel()
self._sortModel = ProjectBrowserSortFilterProxyModel(type_)
self._sortModel.setSourceModel(self._model)
self.setModel(self._sortModel)
self.selectedItemsFilter = [ProjectBrowserFileItem]
# contains codes for special menu entries
# 1 = specials for Others browser
self.specialMenuEntries = []
self.isTranslationsBrowser = False
self.expandedNames = []
self.SelectFlags = QItemSelectionModel.SelectionFlags(
QItemSelectionModel.Select | QItemSelectionModel.Rows)
self.DeselectFlags = QItemSelectionModel.SelectionFlags(
QItemSelectionModel.Deselect | QItemSelectionModel.Rows)
self._activating = False
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self._contextMenuRequested)
self.activated.connect(self._openItem)
self._model.rowsInserted.connect(self.__modelRowsInserted)
self._connectExpandedCollapsed()
self._createPopupMenus()
self.currentItemName = None
self._init() # perform common initialization tasks
self._initHookMethods() # perform initialization of the hooks
self.hooksMenuEntries = {}
def __init__(self, parent):
super(ScorePartsWidget, self).__init__(parent)
self.typesLabel = QLabel()
self.typesView = QTreeView(
selectionMode=QTreeView.ExtendedSelection,
selectionBehavior=QTreeView.SelectRows,
animated=True,
headerHidden=True)
self.scoreLabel = QLabel()
self.scoreView = widgets.treewidget.TreeWidget(
selectionMode=QTreeView.ExtendedSelection,
selectionBehavior=QTreeView.SelectRows,
headerHidden=True,
animated=True,
dragDropMode=QTreeView.InternalMove)
self.addButton = QPushButton(icon = icons.get("list-add"))
self.removeButton = QPushButton(icon = icons.get("list-remove"))
self.upButton = QToolButton(icon = icons.get("go-up"))
self.downButton = QToolButton(icon = icons.get("go-down"))
self.partSettings = QStackedWidget()
w = QWidget()
self.addWidget(w)
layout = QVBoxLayout(spacing=0)
w.setLayout(layout)
layout.addWidget(self.typesLabel)
layout.addWidget(self.typesView)
layout.addWidget(self.addButton)
w = QWidget()
self.addWidget(w)
layout = QVBoxLayout(spacing=0)
w.setLayout(layout)
layout.addWidget(self.scoreLabel)
layout.addWidget(self.scoreView)
box = QHBoxLayout(spacing=0)
layout.addLayout(box)
box.addWidget(self.removeButton)
box.addWidget(self.upButton)
box.addWidget(self.downButton)
self.addWidget(self.partSettings)
self.typesView.setModel(parts.model())
app.translateUI(self)
# signal connections
self.addButton.clicked.connect(self.slotAddButtonClicked)
self.removeButton.clicked.connect(self.slotRemoveButtonClicked)
self.typesView.doubleClicked.connect(self.slotDoubleClicked)
self.scoreView.currentItemChanged.connect(self.slotCurrentItemChanged)
self.upButton.clicked.connect(self.scoreView.moveSelectedChildrenUp)
self.downButton.clicked.connect(self.scoreView.moveSelectedChildrenDown)
def connect(self):
#http://doc.qt.io/qt-5/qtwidgets-itemviews-simpletreemodel-example.html
#http://ftp.ics.uci.edu/pub/centos0/ics-custom-build/BUILD/PyQt-x11-gpl-4.7.2/examples/itemviews/simpletreemodel/simpletreemodel.py
con = qsq.QSqlDatabase.addDatabase("QSQLITE", 'Base') # делаем подключение к БД
con.setDatabaseName("fn.sqlite") # устанавливаем имя базы
if not con.open(): # если не открылось
print ("База данных не открылась!")
print ("-"+con.lastError().text()+"-")
print (str(con.lastError().type()))
return
# cur = qsq.QSqlQuery(con) # это прямое открытие
# cur.exec("SELECT * FROM cases")
# print (cur.lastError().text())
#self.view = QTableView() # создаём табличный вид
self.view = QTreeView()
self.model2 = TableToTreeModel2(self, con) # создаём модельку - стандартную для БД, табличную
self.view.setModel(self.model2) # устанавливаем модель для вида
self.model2.setTable("cases") # устанавливаем таблицу и селектим из неё всё
self.model2.select() # вот на этом этапе модель заполняется данными
self.view.header().moveSection(11,1)
self.view.header().moveSection(12,2)
self.view.header().moveSection(13,3)
self.view.hideColumn(1)
self.view.hideColumn(6)
self.view.hideColumn(7)
self.view.hideColumn(8)
#self.view.hideColumn(9)
self.view.header().hideSection(9)
#
# print (self.model2.rowCount()) # возвращает количество строк
# for i in range (self.model2.rowCount()):
# print (self.model2.data ( self.model2.index(i,1) ))
#self.model2.setFilter('_id>1') # установка фильтра на селект
#self.model2.setFilter('') # и снятие оного
#print (self.model2.record(0).value('_shortText')) # так можно получить данные
#print (self.model2.index(0,0))
# print (self.model2.data ( self.model2.index(0,0) ))
self.layout = QVBoxLayout() # пихаем вид в интерфейс
self.layout.addWidget(self.view)
self.setLayout(self.layout)
con.close() # закрываем соединение
def __init__(self, data):
QWidget.__init__(self)
self.treeView = QTreeView()
self.model = QStandardItemModel()
self.addItems(self.model, data)
self.treeView.setModel(self.model)
layout = QVBoxLayout()
layout.addWidget(self.treeView)
self.setLayout(layout)
def __init_tree_view(self):
self.__treeView = QTreeView()
self.__treeView.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
rect = self.__treeView.geometry()
rect.setWidth(self.__WINDOW_WIDTH / 4)
self.__treeView.setGeometry(rect)
model = QStandardItemModel()
model.setHorizontalHeaderItem(0, QStandardItem(self.__DATABASE))
self.__treeView.setModel(model)
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)
class GUI_values(QWidget):
def __init__(self, data):
QWidget.__init__(self)
self.treeView = QTreeView()
self.model = QStandardItemModel()
self.addItems(self.model, data)
self.treeView.setModel(self.model)
layout = QVBoxLayout()
layout.addWidget(self.treeView)
self.setLayout(layout)
def addItems(self, parent, elements):
for k in sorted(elements.keys()):
item = QStandardItem(k)
parent.appendRow(item)
if type(elements[k]) == dict:
self.addItems(item, elements[k])
else:
child = QStandardItem(str(elements[k]))
item.appendRow(child)
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
target_group = parent.siblingAtColumn(GroupModel.KEY).data()
itemData = data.data('tagit-item')
item_group = int(str(itemData, encoding='utf-8'))
# target group should not be the original group which the dragging items belong to
if item_group==target_group:
return False
# target group should only be TRASH if target is default group
if self.isDefaultGroup(parent) and target_group!=GroupModel.TRASH:
return False
# target group should only be TRASH if item group is UNREFERENCED
if item_group==GroupModel.UNREFERENCED and target_group!=GroupModel.TRASH:
return False
return True
if __name__ == '__main__':
import sys
from PyQt5.QtWidgets import QApplication, QTreeView
app = QApplication(sys.argv)
model = GroupModel()
tree = QTreeView()
tree.setModel(model)
tree.show()
sys.exit(app.exec_())
class App(QWidget):
FROM, SUBJECT, DATE = range(3)
def __init__(self):
super().__init__()
self.title = 'PyQt5 Treeview Example - pythonspot.com'
self.left = 10
self.top = 10
self.width = 640
self.height = 240
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.dataGroupBox = QGroupBox("Inbox")
self.dataView = QTreeView()
self.dataView.setRootIsDecorated(False)
self.dataView.setAlternatingRowColors(True)
self.dataView.clicked.connect(self.test_print)
dataLayout = QHBoxLayout()
dataLayout.addWidget(self.dataView)
self.dataGroupBox.setLayout(dataLayout)
model = self.createMailModel(self)
self.dataView.setModel(model)
self.addMail(model, '*****@*****.**', 'Your Github Donation',
'03/25/2017 02:05 PM')
self.addMail(model, '*****@*****.**', 'Github Projects',
'02/02/2017 03:05 PM')
self.addMail(model, '*****@*****.**', 'Your Phone Bill',
'01/01/2017 04:05 PM')
self.addMail2(model, '*****@*****.**', 'Your Phone Bill',
'01/01/2017 04:05 PM')
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.dataGroupBox)
self.setLayout(mainLayout)
self.show()
def createMailModel(self, parent):
model = QStandardItemModel(0, 3, parent)
model.setHeaderData(self.FROM, Qt.Horizontal, "From")
model.setHeaderData(self.SUBJECT, Qt.Horizontal, "Subject")
model.setHeaderData(self.DATE, Qt.Horizontal, "Date")
return model
def addMail(self, model: QStandardItemModel, mailFrom, subject, date):
model.insertRow(0)
model.setData(model.index(0, self.FROM), mailFrom)
model.setData(model.index(0, self.SUBJECT), subject)
model.setData(model.index(0, self.DATE), date)
def addMail2(self, model: QStandardItemModel, mailFrom, subject, date):
model.insertRow(0)
model.setData(model.index(1, self.FROM), mailFrom)
model.setData(model.index(1, self.SUBJECT), subject)
model.setData(model.index(1, self.DATE), date)
def test_print(self, index: QModelIndex):
print(f"foo name: {__name__}")
print(f"index: {index}")
print(f"index: {index.data()}")
print(f"index: {index.parent()}")
print(f"index: {index.parent().data()}")
def _setupUi(self):
self.setWindowTitle(self.app.NAME)
self.resize(420, 338)
self.centralwidget = QWidget(self)
self.verticalLayout = QVBoxLayout(self.centralwidget)
self.verticalLayout.setContentsMargins(4, 0, 4, 0)
self.verticalLayout.setSpacing(0)
hl = QHBoxLayout()
label = QLabel(tr("Application Mode:"), self)
label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
hl.addWidget(label)
self.appModeRadioBox = RadioBox(
self,
items=[tr("Standard"), tr("Music"),
tr("Picture")],
spread=False)
hl.addWidget(self.appModeRadioBox)
self.verticalLayout.addLayout(hl)
hl = QHBoxLayout()
hl.setAlignment(Qt.AlignLeft)
label = QLabel(tr("Scan Type:"), self)
label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
hl.addWidget(label)
self.scanTypeComboBox = QComboBox(self)
self.scanTypeComboBox.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed))
self.scanTypeComboBox.setMaximumWidth(400)
hl.addWidget(self.scanTypeComboBox)
self.showPreferencesButton = QPushButton(tr("More Options"),
self.centralwidget)
self.showPreferencesButton.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.Fixed)
hl.addWidget(self.showPreferencesButton)
self.verticalLayout.addLayout(hl)
self.promptLabel = QLabel(
tr('Select folders to scan and press "Scan".'), self.centralwidget)
self.verticalLayout.addWidget(self.promptLabel)
self.treeView = QTreeView(self.centralwidget)
self.treeView.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.treeView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.treeView.setAcceptDrops(True)
triggers = (QAbstractItemView.DoubleClicked
| QAbstractItemView.EditKeyPressed
| QAbstractItemView.SelectedClicked)
self.treeView.setEditTriggers(triggers)
self.treeView.setDragDropOverwriteMode(True)
self.treeView.setDragDropMode(QAbstractItemView.DropOnly)
self.treeView.setUniformRowHeights(True)
self.verticalLayout.addWidget(self.treeView)
self.horizontalLayout = QHBoxLayout()
self.removeFolderButton = QPushButton(self.centralwidget)
self.removeFolderButton.setIcon(QIcon(QPixmap(":/minus")))
self.removeFolderButton.setShortcut("Del")
self.horizontalLayout.addWidget(self.removeFolderButton)
self.addFolderButton = QPushButton(self.centralwidget)
self.addFolderButton.setIcon(QIcon(QPixmap(":/plus")))
self.horizontalLayout.addWidget(self.addFolderButton)
spacerItem1 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem1)
self.loadResultsButton = QPushButton(self.centralwidget)
self.loadResultsButton.setText(tr("Load Results"))
self.horizontalLayout.addWidget(self.loadResultsButton)
self.scanButton = QPushButton(self.centralwidget)
self.scanButton.setText(tr("Scan"))
self.scanButton.setDefault(True)
self.horizontalLayout.addWidget(self.scanButton)
self.verticalLayout.addLayout(self.horizontalLayout)
self.setCentralWidget(self.centralwidget)
self._setupActions()
self._setupMenu()
if self.app.prefs.directoriesWindowRect is not None:
self.setGeometry(self.app.prefs.directoriesWindowRect)
else:
moveToScreenCenter(self)
def __init__(self, parent=None):
QTreeView.__init__(self, parent)
self.setItemDelegateForColumn(1, PropertyDelegate(self))
class ResultTable(QDialog):
FROM, SUBJECT, DATE = range(3)
ID, BRAND, MODEL, YEAR, POWER, GEARBOX, COND, FEAT, PRICE = range(9)
C_ID, C_NAME, C_ADDR, C_BRAND, C_MODEL, C_YEAR, C_COND, C_PRICE = range(8)
def __init__(self):
super(ResultTable, self).__init__()
self.title = 'Результаты поиска'
self.left = 10
self.top = 10
self.width = 720
self.height = 480
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.dataGroupBox = QGroupBox()
self.dataView = QTreeView()
self.dataView.setRootIsDecorated(False)
self.dataView.setAlternatingRowColors(True)
dataLayout = QHBoxLayout()
dataLayout.addWidget(self.dataView)
self.dataGroupBox.setLayout(dataLayout)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.dataGroupBox)
self.setLayout(mainLayout)
self.show()
def showClientsResult(self, _list):
self.dataView.setModel(None)
modelCl = self.createModelCl(self)
self.dataView.setModel(modelCl)
for cl in _list:
self.addClEntry(modelCl, cl.id, cl.name, cl.address, cl.brand,
cl.model, cl.year, cl.condition, cl.price)
def showCarsResult(self, _list):
self.dataView.setModel(None)
model = self.createModel(self)
self.dataView.setModel(model)
for car in _list:
self.addCarEntry(model, car.id, car.brand, car.model, car.year,
car.engine_power, car.auto_gearbox, car.condition,
car.features, car.price)
def createModel(self, parent):
model = QStandardItemModel(0, 9, parent)
model.setHeaderData(self.ID, Qt.Horizontal, "id")
model.setHeaderData(self.BRAND, Qt.Horizontal, "Марка")
model.setHeaderData(self.MODEL, Qt.Horizontal, "Модель")
model.setHeaderData(self.YEAR, Qt.Horizontal, "Год")
model.setHeaderData(self.POWER, Qt.Horizontal, "Мощность")
model.setHeaderData(self.GEARBOX, Qt.Horizontal, "Коробка")
model.setHeaderData(self.COND, Qt.Horizontal, "Пробег")
model.setHeaderData(self.FEAT, Qt.Horizontal, "Информ")
model.setHeaderData(self.PRICE, Qt.Horizontal, "Цена")
return model
def addCarEntry(self, model, _id, brand, _model, year, power, gear, cond,
feat, price):
model.insertRow(0)
model.setData(model.index(0, self.ID), _id)
model.setData(model.index(0, self.BRAND), brand)
model.setData(model.index(0, self.MODEL), _model)
model.setData(model.index(0, self.YEAR), year)
model.setData(model.index(0, self.POWER), power)
model.setData(model.index(0, self.GEARBOX), gear)
model.setData(model.index(0, self.COND), cond)
model.setData(model.index(0, self.FEAT), feat)
model.setData(model.index(0, self.PRICE), price)
def createModelCl(self, parent):
model = QStandardItemModel(0, 8, parent)
model.setHeaderData(self.C_ID, Qt.Horizontal, "id")
model.setHeaderData(self.C_NAME, Qt.Horizontal, "ФИО")
model.setHeaderData(self.C_ADDR, Qt.Horizontal, "Адрес")
model.setHeaderData(self.C_BRAND, Qt.Horizontal, "Марка")
model.setHeaderData(self.C_MODEL, Qt.Horizontal, "Модель")
model.setHeaderData(self.C_COND, Qt.Horizontal, "Пробег")
model.setHeaderData(self.C_PRICE, Qt.Horizontal, "Цена")
return model
def addClEntry(self, model, _id, name, addr, brand, _model, year, cond,
price):
model.insertRow(0)
model.setData(model.index(0, self.C_ID), _id)
model.setData(model.index(0, self.C_NAME), name)
model.setData(model.index(0, self.C_ADDR), addr)
model.setData(model.index(0, self.C_BRAND), brand)
model.setData(model.index(0, self.C_MODEL), _model)
model.setData(model.index(0, self.C_YEAR), year)
model.setData(model.index(0, self.C_COND), cond)
model.setData(model.index(0, self.C_PRICE), price)
class HistoryWidget(QWidget):
def __init__(self, parent=None):
super(HistoryWidget, self).__init__(parent=parent)
self.historyView = QTreeView(self)
self.proxyModel = HistorySortModel(self)
self.sourceModel = QStandardItemModel()
self.initUI()
def initUI(self):
self.historyView.setRootIsDecorated(False)
self.historyView.setAlternatingRowColors(True)
self.historyView.setModel(self.proxyModel)
self.historyView.setSortingEnabled(True)
self.historyView.sortByColumn(1, Qt.AscendingOrder)
self.historyView.setFixedWidth(750)
self.sourceModel = QStandardItemModel(0, 6, self)
self.sourceModel.setHeaderData(0, Qt.Horizontal, "Model Name")
self.sourceModel.setHeaderData(1, Qt.Horizontal, "Algorithm")
self.sourceModel.setHeaderData(2, Qt.Horizontal, "Score")
self.sourceModel.setHeaderData(3, Qt.Horizontal, "TrainSet")
self.sourceModel.setHeaderData(4, Qt.Horizontal, "Running Time")
self.sourceModel.setHeaderData(5, Qt.Horizontal, "Param")
self.proxyModel.setSourceModel(self.sourceModel)
self.historyView.setModel(self.sourceModel)
def addItem(self, result: modelResult):
self.sourceModel.insertRow(self.sourceModel.rowCount())
self.sourceModel.setData(self.sourceModel.index(0, 0),
result.modelName) # string
self.sourceModel.setData(self.sourceModel.index(0, 1),
result.algorithm) # string
self.sourceModel.setData(self.sourceModel.index(0, 2),
result.score) # float
self.sourceModel.setData(self.sourceModel.index(0, 3),
result.trainSet) # string
self.sourceModel.setData(self.sourceModel.index(0, 4),
result.runTime) # second
self.sourceModel.setData(self.sourceModel.index(0, 5),
result.param) # dict
class FileTree(QWidget):
def __init__(self, filter=['*.czi'], defaultfolder=r'c:\Zen_Output'):
super(QWidget, self).__init__()
# define filter to allowed file extensions
#filter = ['*.czi', '*.ome.tiff', '*ome.tif' '*.tiff' '*.tif']
# define the style for the FileTree via s style sheet
self.setStyleSheet("""
QTreeView: : item {
background - color: rgb(38, 41, 48);
font-weight: bold;}
QTreeView: : item: : selected {
background - color: rgb(38, 41, 48);
color: rgb(0, 255, 0); }
QTreeView QHeaderView: section {
background - color: rgb(38, 41, 48);
color: rgb(255, 255, 255);}
""")
self.model = QFileSystemModel()
self.model.setRootPath(defaultfolder)
self.model.setFilter(QtCore.QDir.AllDirs | QDir.Files | QtCore.QDir.NoDotAndDotDot)
self.model.setNameFilterDisables(False)
self.model.setNameFilters(filter)
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setRootIndex(self.model.index(defaultfolder))
self.tree.setAnimated(True)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(False)
header = self.tree.header()
header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.tree.clicked.connect(self.on_treeView_clicked)
def on_treeView_clicked(self, index):
indexItem = self.model.index(index.row(), 0, index.parent())
filename = self.model.fileName(indexItem)
filepath = self.model.filePath(indexItem)
# open the file when clicked
print('Opening ImageFile : ', filepath)
open_image_stack(filepath)
class Watch(QWidget):
def __init__(self, parent=None):
super(QWidget, self).__init__(parent)
self.initUI()
self.initVariables()
def initUI(self):
mainlayout = QFormLayout()
self.model = CheckableDirModel()
#self.model = QFileSystemModel()
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setColumnHidden(1, True)
self.tree.setColumnHidden(2, True)
self.tree.setColumnHidden(3, True)
self.tree.setSortingEnabled(False)
self.tree.setHeaderHidden(True)
self.model.updateCheckBoxSignal.connect(self.updateCheckBoxes)
buttonLayout = QHBoxLayout()
self.applyButton = QPushButton("Apply", self)
self.applyButton.clicked.connect(self.apply)
self.applyButton.setEnabled(False)
self.resetButton = QPushButton("Reset", self)
hspacer = QWidget()
hspacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
buttonLayout.addWidget(hspacer)
buttonLayout.addWidget(self.applyButton)
buttonLayout.addWidget(self.resetButton)
vspacer = QWidget()
vspacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
# Add to layout
mainlayout.addRow(self.tree)
mainlayout.addRow(vspacer)
mainlayout.addRow(buttonLayout)
self.setLayout(mainlayout)
def initVariables(self):
settings = readSettingItems(['Watched'])
if 'Watched' in settings.keys():
if len(settings['Watched']):
self.watchList = settings['Watched']
if len(self.watchList):
for watchItem in self.watchList:
tempPath = watchItem[0]
tempIndex = self.model.index(tempPath, 0)
retData = self.model.filePath(tempIndex)
# Set checkbox
if len(retData):
self.model.setData(tempIndex, watchItem[1], Qt.CheckStateRole)
# Expand path
while tempIndex.parent().isValid():
tempIndex = tempIndex.parent()
self.tree.expand(tempIndex)
else:
self.watchList = []
def updateCheckBoxes(self, index, value):
changeFlag = False
fullpath = self.model.filePath(index)
newWatchMission = [fullpath, value]
if newWatchMission in self.watchList:
pass
else:
if len(self.watchList):
tempList = list(filter(lambda x: fullpath in x, self.watchList))
if len(tempList) == 1:
tempMissionIndex = self.watchList.index(tempList[0])
if value == 0:
self.watchList.pop(tempMissionIndex)
else:
self.watchList[tempMissionIndex] = newWatchMission
elif len(tempList) == 0:
if value != 0:
self.watchList.append(newWatchMission)
changeFlag = True
self.applyButton.setEnabled(changeFlag)
# to do: update checkboxes states: 0, 1, 2.
def apply(self):
data = {'Watched': self.watchList }
writeSettingItems(data)
self.applyButton.setEnabled(False)
def setupTab6(self, tab):
"""Advance widgets for preview panel"""
container = QHBoxLayout()
scrollArea = QScrollArea()
scrollArea.setWidgetResizable(True)
w = QWidget()
w.setMinimumSize(QSize(400, 500))
layout = QVBoxLayout()
w.setLayout(layout)
scrollArea.setWidget(w)
container.addWidget(scrollArea)
tab.setLayout(container)
# List
lay = QHBoxLayout()
layout.addLayout(lay)
list1 = QListWidget()
list1.addItems(["aaa", "bbb", "ccc"])
list2 = QListWidget()
list2.addItem(
QListWidgetItem(QIcon(":appres.img/Flag_blueHS.png"), "blue"))
list2.addItem(
QListWidgetItem(QIcon(":appres.img/Flag_redHS.png"), "red"))
list2.addItem(
QListWidgetItem(QIcon(":appres.img/Flag_greenHS.png"), "green"))
list2.setViewMode(QListWidget.IconMode)
lay.addWidget(list1)
lay.addWidget(list2)
# Table
lay = QHBoxLayout()
layout.addLayout(lay)
t1 = QTableWidget()
t1.setRowCount(3)
t1.setColumnCount(3)
for i in range(3):
for j in range(3):
t1.setItem(i, j, QTableWidgetItem(str((i + 1) * (j + 1))))
t1.item(i, j).setTextAlignment(Qt.AlignCenter)
t1.setColumnWidth(0, 50)
t1.setColumnWidth(1, 50)
t1.setColumnWidth(2, 50)
t1.setEditTriggers(QTableWidget.AllEditTriggers)
t2 = QTableWidget()
t2.setRowCount(3)
t2.setColumnCount(3)
t2.setHorizontalHeaderLabels(["Name", "Gender", "Age"])
t2.setVerticalHeaderLabels(["1st", "2rd", "3th"])
t2.setItem(0, 0, QTableWidgetItem("july"))
c = QComboBox()
c.addItems(["Male", "Famale"])
t2.setCellWidget(0, 1, c)
t2.cellWidget(0, 1).setCurrentIndex(1)
t2.setItem(0, 2, QTableWidgetItem("10"))
t2.setItem(1, 0, QTableWidgetItem("john"))
c = QComboBox()
c.addItems(["Male", "Famale"])
c.setEditable(True)
t2.setCellWidget(1, 1, c)
t2.setItem(1, 2, QTableWidgetItem("11"))
t2.resizeColumnsToContents()
t2.setEditTriggers(QTableWidget.EditKeyPressed
| QTableWidget.SelectedClicked
| QTableWidget.AnyKeyPressed
| QTableWidget.DoubleClicked)
lay.addWidget(t1)
lay.addWidget(t2)
# Tree
lay = QHBoxLayout()
layout.addLayout(lay)
tree1 = QTreeWidget()
tree1.setColumnCount(2)
tree1.setHeaderLabels(["Key", "Value"])
node1 = QTreeWidgetItem()
node1.setText(0, "root")
node1.setText(1, "0")
node1.setIcon(0, QIcon(":appres.img/home.png"))
tree1.addTopLevelItem(node1)
node11 = QTreeWidgetItem()
node11.setText(0, "child1")
icon = QIcon(":appres.img/book_angle.png")
icon.addPixmap(QPixmap(":appres.img/book_open.png"), QIcon.Normal,
QIcon.On)
node11.setIcon(0, icon)
nodea = QTreeWidgetItem()
nodea.setText(0, "red")
nodea.setBackground(1, QBrush(Qt.red))
nodeb = QTreeWidgetItem()
nodeb.setText(0, "gray")
nodeb.setBackground(1, QBrush(Qt.gray))
nodec = QTreeWidgetItem()
nodec.setText(0, "green")
nodec.setBackground(1, QBrush(Qt.green))
node11.addChildren([nodea, nodeb, nodec])
node12 = QTreeWidgetItem()
node12.setText(0, "child2")
node12.setText(1, "child2")
node13 = QTreeWidgetItem()
node13.setText(0, "child3")
node13.setText(1, "child3")
node12.setIcon(0, icon)
node13.setIcon(0, icon)
node1.addChild(node11)
node1.addChild(node12)
node1.addChild(node13)
tree1.expand(tree1.model().index(0, 0))
tree1.expandItem(node11)
tree2 = QTreeView()
folder = QDirModel()
tree2.setModel(folder)
lay.addWidget(tree1)
lay.addWidget(tree2)
def __init__(self):
# constructor of the base class
QMainWindow.__init__(self)
QCoreApplication.setOrganizationName("RST")
QCoreApplication.setOrganizationDomain("https://tu-dresden.de/rst")
QCoreApplication.setApplicationVersion(
pkg_resources.require("PyMoskito")[0].version)
QCoreApplication.setApplicationName(globals()["__package__"])
# load settings
self._settings = QSettings()
self._read_settings()
# initialize logger
self._logger = logging.getLogger(self.__class__.__name__)
# Create Simulation Backend
self.guiProgress = None
self.cmdProgress = None
self.sim = SimulatorInteractor(self)
self.runSimulation.connect(self.sim.run_simulation)
self.stopSimulation.connect(self.sim.stop_simulation)
self.sim.simulation_finalized.connect(self.new_simulation_data)
self.currentDataset = None
self.interpolator = None
# sim setup viewer
self.targetView = SimulatorView(self)
self.targetView.setModel(self.sim.target_model)
self.targetView.expanded.connect(self.target_view_changed)
self.targetView.collapsed.connect(self.target_view_changed)
# sim results viewer
self.result_view = QTreeView()
# the docking area allows to rearrange the user interface at runtime
self.area = pg.dockarea.DockArea()
# Window properties
icon_size = QSize(25, 25)
self.setCentralWidget(self.area)
self.resize(1000, 700)
self.setWindowTitle("PyMoskito")
res_path = get_resource("mosquito.png")
icon = QIcon(res_path)
self.setWindowIcon(icon)
# create docks
self.propertyDock = pg.dockarea.Dock("Properties")
self.animationDock = pg.dockarea.Dock("Animation")
self.regimeDock = pg.dockarea.Dock("Regimes")
self.dataDock = pg.dockarea.Dock("Data")
self.logDock = pg.dockarea.Dock("Log")
self.plotDockPlaceholder = pg.dockarea.Dock("Placeholder")
# arrange docks
self.area.addDock(self.animationDock, "right")
self.area.addDock(self.regimeDock, "left", self.animationDock)
self.area.addDock(self.propertyDock, "bottom", self.regimeDock)
self.area.addDock(self.dataDock, "bottom", self.propertyDock)
self.area.addDock(self.plotDockPlaceholder, "bottom",
self.animationDock)
self.area.addDock(self.logDock, "bottom", self.dataDock)
self.non_plotting_docks = list(self.area.findAll()[1].keys())
# add widgets to the docks
self.propertyDock.addWidget(self.targetView)
if not vtk_available:
self._logger.error(
"loading vtk failed with:{}".format(vtk_error_msg))
# check if there is a registered visualizer
available_vis = get_registered_visualizers()
self._logger.info("found visualizers: {}".format(
[name for cls, name in available_vis]))
if available_vis:
# instantiate the first visualizer
self._logger.info("loading visualizer '{}'".format(
available_vis[0][1]))
self.animationLayout = QVBoxLayout()
if issubclass(available_vis[0][0], MplVisualizer):
self.animationWidget = QWidget()
self.visualizer = available_vis[0][0](self.animationWidget,
self.animationLayout)
self.animationDock.addWidget(self.animationWidget)
elif issubclass(available_vis[0][0], VtkVisualizer):
if vtk_available:
# vtk window
self.animationFrame = QFrame()
self.vtkWidget = QVTKRenderWindowInteractor(
self.animationFrame)
self.animationLayout.addWidget(self.vtkWidget)
self.animationFrame.setLayout(self.animationLayout)
self.animationDock.addWidget(self.animationFrame)
self.vtk_renderer = vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(
self.vtk_renderer)
self.visualizer = available_vis[0][0](self.vtk_renderer)
self.vtkWidget.Initialize()
else:
self._logger.warning("visualizer depends on vtk which is "
"not available on this system!")
elif available_vis:
raise NotImplementedError
else:
self.visualizer = None
# regime window
self.regime_list = QListWidget(self)
self.regime_list.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.regimeDock.addWidget(self.regime_list)
self.regime_list.itemDoubleClicked.connect(self.regime_dclicked)
self._regimes = []
self.regime_file_name = ""
self.actDeleteRegimes = QAction(self.regime_list)
self.actDeleteRegimes.setText("&Delete Selected Regimes")
# TODO shortcut works always, not only with focus on the regime list
# self.actDeleteRegimes.setShortcutContext(Qt.WindowShortcut)
self.actDeleteRegimes.setShortcut(QKeySequence(Qt.Key_Delete))
self.actDeleteRegimes.triggered.connect(self.remove_regime_items)
self.actSave = QAction(self)
self.actSave.setText('Save Results As')
self.actSave.setIcon(QIcon(get_resource("save.png")))
self.actSave.setDisabled(True)
self.actSave.setShortcut(QKeySequence.Save)
self.actSave.triggered.connect(self.export_simulation_data)
self.actLoadRegimes = QAction(self)
self.actLoadRegimes.setText("Load Regimes from File")
self.actLoadRegimes.setIcon(QIcon(get_resource("load.png")))
self.actLoadRegimes.setDisabled(False)
self.actLoadRegimes.setShortcut(QKeySequence.Open)
self.actLoadRegimes.triggered.connect(self.load_regime_dialog)
self.actExitOnBatchCompletion = QAction(self)
self.actExitOnBatchCompletion.setText("&Exit On Batch Completion")
self.actExitOnBatchCompletion.setCheckable(True)
self.actExitOnBatchCompletion.setChecked(
self._settings.value("control/exit_on_batch_completion") == "True")
self.actExitOnBatchCompletion.changed.connect(
self.update_exit_on_batch_completion_setting)
# regime management
self.runningBatch = False
self._current_regime_index = None
self._current_regime_name = None
self._regimes = []
self.regimeFinished.connect(self.run_next_regime)
self.finishedRegimeBatch.connect(self.regime_batch_finished)
# data window
self.dataList = QListWidget(self)
self.dataDock.addWidget(self.dataList)
self.dataList.itemDoubleClicked.connect(self.create_plot)
# actions for simulation control
self.actSimulateCurrent = QAction(self)
self.actSimulateCurrent.setText("&Simulate Current Regime")
self.actSimulateCurrent.setIcon(QIcon(get_resource("simulate.png")))
self.actSimulateCurrent.setShortcut(QKeySequence("F5"))
self.actSimulateCurrent.triggered.connect(self.start_simulation)
self.actSimulateAll = QAction(self)
self.actSimulateAll.setText("Simulate &All Regimes")
self.actSimulateAll.setIcon(QIcon(get_resource("execute_regimes.png")))
self.actSimulateAll.setShortcut(QKeySequence("F6"))
self.actSimulateAll.setDisabled(True)
self.actSimulateAll.triggered.connect(self.start_regime_execution)
# actions for animation control
self.actAutoPlay = QAction(self)
self.actAutoPlay.setText("&Autoplay Simulation")
self.actAutoPlay.setCheckable(True)
self.actAutoPlay.setChecked(
self._settings.value("control/autoplay_animation") == "True")
self.actAutoPlay.changed.connect(self.update_autoplay_setting)
self.actPlayPause = QAction(self)
self.actPlayPause.setText("Play Animation")
self.actPlayPause.setIcon(QIcon(get_resource("play.png")))
self.actPlayPause.setDisabled(True)
self.actPlayPause.setShortcut(QKeySequence(Qt.Key_Space))
self.actPlayPause.triggered.connect(self.play_animation)
self.actStop = QAction(self)
self.actStop.setText("Stop")
self.actStop.setIcon(QIcon(get_resource("stop.png")))
self.actStop.setDisabled(True)
self.actStop.triggered.connect(self.stop_animation)
self.actSlow = QAction(self)
self.actSlow.setText("Slowest")
self.actSlow.setIcon(QIcon(get_resource("slow.png")))
self.actSlow.setDisabled(False)
self.actSlow.triggered.connect(self.set_slowest_playback_speed)
self.actFast = QAction(self)
self.actFast.setText("Fastest")
self.actFast.setIcon(QIcon(get_resource("fast.png")))
self.actFast.setDisabled(False)
self.actFast.triggered.connect(self.set_fastest_playback_speed)
self.speedControl = QSlider(Qt.Horizontal, self)
self.speedControl.setMaximumSize(200, 25)
self.speedControl.setTickPosition(QSlider.TicksBothSides)
self.speedControl.setDisabled(False)
self.speedControl.setMinimum(0)
self.speedControl.setMaximum(12)
self.speedControl.setValue(6)
self.speedControl.setTickInterval(6)
self.speedControl.setSingleStep(2)
self.speedControl.setPageStep(3)
self.speedControl.valueChanged.connect(self.update_playback_speed)
self.timeSlider = QSlider(Qt.Horizontal, self)
self.timeSlider.setMinimum(0)
self.timeSliderRange = 1000
self.timeSlider.setMaximum(self.timeSliderRange)
self.timeSlider.setTickInterval(1)
self.timeSlider.setTracking(True)
self.timeSlider.setDisabled(True)
self.timeSlider.valueChanged.connect(self.update_playback_time)
self.playbackTime = .0
self.playbackGain = 1
self.currentStepSize = .0
self.currentEndTime = .0
self.playbackTimer = QTimer()
self.playbackTimer.timeout.connect(self.increment_playback_time)
self.playbackTimeChanged.connect(self.update_gui)
self.playbackTimeout = 33 # in [ms] -> 30 fps
self.actResetCamera = QAction(self)
self.actResetCamera.setText("Reset Camera")
self.actResetCamera.setIcon(QIcon(get_resource("reset_camera.png")))
self.actResetCamera.setDisabled(True)
if available_vis:
self.actResetCamera.setEnabled(self.visualizer.can_reset_view)
self.actResetCamera.triggered.connect(self.reset_camera_clicked)
# postprocessing
self.actPostprocessing = QAction(self)
self.actPostprocessing.setText("Launch Postprocessor")
self.actPostprocessing.setIcon(QIcon(get_resource("processing.png")))
self.actPostprocessing.setDisabled(False)
self.actPostprocessing.triggered.connect(self.postprocessing_clicked)
self.actPostprocessing.setShortcut(QKeySequence("F7"))
self.postprocessor = None
# toolbar
self.toolbarSim = QToolBar("Simulation")
self.toolbarSim.setContextMenuPolicy(Qt.PreventContextMenu)
self.toolbarSim.setMovable(False)
self.toolbarSim.setIconSize(icon_size)
self.addToolBar(self.toolbarSim)
self.toolbarSim.addAction(self.actLoadRegimes)
self.toolbarSim.addAction(self.actSave)
self.toolbarSim.addSeparator()
self.toolbarSim.addAction(self.actSimulateCurrent)
self.toolbarSim.addAction(self.actSimulateAll)
self.toolbarSim.addSeparator()
self.toolbarSim.addAction(self.actPlayPause)
self.toolbarSim.addAction(self.actStop)
self.toolbarSim.addWidget(self.timeSlider)
self.toolbarSim.addSeparator()
self.toolbarSim.addAction(self.actSlow)
self.toolbarSim.addWidget(self.speedControl)
self.toolbarSim.addAction(self.actFast)
self.toolbarSim.addSeparator()
self.toolbarSim.addAction(self.actPostprocessing)
self.toolbarSim.addAction(self.actResetCamera)
self.postprocessor = None
# log dock
self.logBox = QPlainTextEdit(self)
self.logBox.setReadOnly(True)
self.logDock.addWidget(self.logBox)
# init logger for logging box
self.textLogger = PlainTextLogger(logging.INFO)
self.textLogger.set_target_cb(self.logBox.appendPlainText)
logging.getLogger().addHandler(self.textLogger)
# menu bar
fileMenu = self.menuBar().addMenu("&File")
fileMenu.addAction(self.actLoadRegimes)
fileMenu.addAction(self.actSave)
fileMenu.addAction("&Quit", self.close)
editMenu = self.menuBar().addMenu("&Edit")
editMenu.addAction(self.actDeleteRegimes)
simMenu = self.menuBar().addMenu("&Simulation")
simMenu.addAction(self.actSimulateCurrent)
simMenu.addAction(self.actSimulateAll)
simMenu.addAction(self.actExitOnBatchCompletion)
simMenu.addAction(self.actPostprocessing)
animMenu = self.menuBar().addMenu("&Animation")
animMenu.addAction(self.actPlayPause)
animMenu.addAction("&Increase Playback Speed",
self.increment_playback_speed,
QKeySequence(Qt.CTRL + Qt.Key_Plus))
animMenu.addAction("&Decrease Playback Speed",
self.decrement_playback_speed,
QKeySequence(Qt.CTRL + Qt.Key_Minus))
animMenu.addAction("&Reset Playback Speed", self.reset_playback_speed,
QKeySequence(Qt.CTRL + Qt.Key_0))
animMenu.addAction(self.actAutoPlay)
animMenu.addAction(self.actResetCamera)
helpMenu = self.menuBar().addMenu("&Help")
helpMenu.addAction("&Online Documentation", self.show_online_docs)
helpMenu.addAction("&About", self.show_info)
# status bar
self.status = QStatusBar(self)
self.setStatusBar(self.status)
self.statusLabel = QLabel("Ready.")
self.statusBar().addPermanentWidget(self.statusLabel)
self.timeLabel = QLabel("current time: 0.0")
self.statusBar().addPermanentWidget(self.timeLabel)
self._logger.info("Simulation GUI is up and running.")
return 0
if not parent.isValid():
parentItem = self.mRootItem
else:
parentItem = parent.internalPointer()
return parentItem.childCount()
def columnCount(self, parent: QModelIndex = ...):
return 3
if __name__ == '__main__':
app = QApplication(sys.argv)
view = QTreeView()
model = QJsonModel()
view.setModel(model)
json = b"""{
"firstName": "John",
"lastName": "Smith",
"age": 25,
"address":
{
"streetAddress": "21 2nd Street",
"city": "New York",
"state": "NY",
"postalCode": "10021"
},
def _init_widget(self, listbox: QTreeView):
listbox.setModel(self)
listbox.setItemDelegate(self.item_delegate)
listbox.setContextMenuPolicy(Qt.CustomContextMenu)
# listbox.customContextMenuRequested.connect(self.context_menu)
listbox.customContextMenuRequested.connect(self.menu)
listbox.setDragEnabled(True)
listbox.setAcceptDrops(True)
listbox.setDropIndicatorShown(True)
listbox.setSelectionMode(listbox.ExtendedSelection)
# listbox.setMovement(QTreeView.Snap)
# listbox.setDragDropMode(QTreeView.InternalMove)
listbox.setDragDropMode(QAbstractItemView.DragDrop)
# listbox.setAlternatingRowColors(True)
# listbox.setDefaultDropAction(Qt.MoveAction)
# listbox.setDragDropOverwriteMode(True)
# listbox.entered.connect(self.layer_entered)
# listbox.setFont(QFont('Andale Mono', 13))
# the various signals that may result from the user changing the selections
# listbox.activated.connect(self.changedSelection)
# listbox.clicked.connect(self.changedSelection)
# listbox.doubleClicked.connect(self.changedSelection)
# listbox.pressed.connect(self.changedSelection)
listbox.selectionModel().selectionChanged.connect(self.changedSelection)
self.widgets.append(listbox)
class App(QWidget):
def __init__(self):
super(App, self).__init__()
self.title = 'IOT-POT'
self.left = 0
self.top = 0
desktop = QDesktopWidget()
self.width = desktop.geometry().width()
self.height = desktop.geometry().height()
print "width : %d height %d" % (self.width, self.height)
self.initUI()
self.showMaximized()
def initUI(self):
self.setWindowTitle(self.title)
#self.setGeometry(self.left, self.top, self.width, self.height)
# Add box layout, add table to box layout and add box layout to widget
self.mainLayout = QVBoxLayout()
#creating the topBar
self.topBar = QGroupBox()
self.horizontalLayout = QHBoxLayout()
startButton = QPushButton("开始")
stopButton = QPushButton("停止")
startButton.setFixedSize(100, 28)
stopButton.setFixedSize(100, 28)
self.horizontalLayout.addWidget(startButton, 0, Qt.AlignRight)
self.horizontalLayout.addWidget(stopButton)
self.topBar.setLayout(self.horizontalLayout)
startButton.clicked.connect(self.Start)
stopButton.clicked.connect(self.Stop)
#topBar ends here
# create centralWidet
self.createCentralWidget()
self.mainLayout.addWidget(self.topBar)
self.mainLayout.addWidget(self.centralWidget)
self.setLayout(self.mainLayout)
#self.updatePorts("23")
#self.updateAttackerIPs("192.168.8.17")
# Show widget
self.show()
def Start(self):
#self.my=thread.start_new_thread(startmiddleware,("192.168.43.152","23",self))
self.my = MyThread("192.168.1.3", "23", self)
self.my.start()
def Stop(self):
self.my.stop()
def updatePorts(self, port):
item = QStandardItem(port)
item.setEditable(False)
self.ports.appendRow(item)
def updateAttackerIPs(self, ip):
item = QStandardItem(ip)
item.setEditable(False)
self.attackerIP.appendRow(item)
def updateUIlogs(self, date, time, attackerip, attackerport, direction,
localip, localport, protocol, byte, country, payload):
global i
self.tableWidget.insertRow(i + 1)
self.tableWidget.setItem(i, 0, QTableWidgetItem(date))
self.tableWidget.setItem(i, 1, QTableWidgetItem(time))
self.tableWidget.setItem(i, 2, QTableWidgetItem(attackerip))
self.tableWidget.setItem(i, 3, QTableWidgetItem(attackerport))
self.tableWidget.setItem(i, 4, QTableWidgetItem(direction))
self.tableWidget.setItem(i, 5, QTableWidgetItem(localip))
self.tableWidget.setItem(i, 6, QTableWidgetItem(localport))
self.tableWidget.setItem(i, 7, QTableWidgetItem(protocol))
self.tableWidget.setItem(i, 8, QTableWidgetItem(byte))
self.tableWidget.setItem(i, 9, QTableWidgetItem(country))
self.tableWidget.setItem(i, 10, QTableWidgetItem(payload))
i = (i + 1) % 1500
self.tableWidget.show()
def createCentralWidget(self):
# Create table
self.centralWidget = QSplitter(Qt.Horizontal)
self.treeView = QTreeView()
self.treeView.setHeaderHidden(True)
standardModel = QStandardItemModel()
rootNode = standardModel.invisibleRootItem()
self.ports = QStandardItem("本地端口")
self.attackerIP = QStandardItem("攻击者IP")
self.ports.setEditable(False)
self.attackerIP.setEditable(False)
rootNode.appendRow(self.ports)
rootNode.appendRow(self.attackerIP)
self.treeView.setModel(standardModel)
self.tableWidget = QTableWidget(self)
self.tableWidget.setRowCount(1500)
self.tableWidget.setColumnCount(11)
self.tableWidget.verticalHeader().setVisible(False)
self.tableWidget.setHorizontalHeaderLabels([
'日期', '时间', '远程IP', '远程端口', '方向', '本地IP', '本地端口', '协议', '字节', '国家',
'数据包详细信息'
])
self.tableWidget.setColumnWidth(0, 100)
self.tableWidget.setColumnWidth(2, self.width * 0.1)
self.tableWidget.setColumnWidth(3, self.width * 0.07)
self.tableWidget.setColumnWidth(4, self.width * 0.05)
self.tableWidget.setColumnWidth(5, self.width * 0.1)
self.tableWidget.setColumnWidth(6, self.width * 0.06)
self.tableWidget.setColumnWidth(7, self.width * 0.05)
self.tableWidget.setColumnWidth(8, self.width * 0.04)
self.tableWidget.setColumnWidth(10, self.width * 0.095)
# self.tableWidget.move(30,10)
# table selection change
self.tableWidget.doubleClicked.connect(self.on_click)
self.treeView.setMinimumWidth(self.width * 0.15)
self.tableWidget.setMinimumWidth(self.width * 0.85)
self.centralWidget.addWidget(self.treeView)
self.centralWidget.addWidget(self.tableWidget)
self.centralWidget.setMinimumHeight(self.height * 0.95)
@pyqtSlot()
def on_click(self):
print("\n")
for currentQTableWidgetItem in self.tableWidget.selectedItems():
print(currentQTableWidgetItem.row(),
currentQTableWidgetItem.column(),
currentQTableWidgetItem.text())
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.setMinimumSize(QSize(480, 80))
self.setWindowTitle("PyQtSample")
central_widget = QWidget(self)
self.setCentralWidget(central_widget)
hbox_layout = QHBoxLayout(self)
central_widget.setLayout(hbox_layout)
buttons_background = QWidget(self)
buttons_layout = QHBoxLayout()
buttons_background.setLayout(buttons_layout)
self.add_button = QPushButton("Add")
buttons_layout.addWidget(self.add_button)
self.remove_button = QPushButton("Remove")
buttons_layout.addWidget(self.remove_button)
tree_layout = QVBoxLayout(self)
self.tree_view = QTreeView()
self.tree_view.header().hide()
self.tree_view.setMaximumWidth(300)
self.tree_model = ObjectsModel.TreeModel()
self.tree_view.setModel(self.tree_model)
tree_layout.addWidget(buttons_background)
tree_layout.addWidget(self.tree_view)
hbox_layout.addLayout(tree_layout)
self.graphics_view = QGraphicsView()
self.scene = QGraphicsScene()
self.graphics_view.setScene(self.scene)
hbox_layout.addWidget(self.graphics_view)
self.properties_view = QTableView()
self.properties_view.setMaximumWidth(300)
self.properties_model = PropertiesModel.TableModel()
self.properties_view.setModel(self.properties_model)
hbox_layout.addWidget(self.properties_view)
self.init_menu()
self.test()
self.connectSignals()
def connectSignals(self):
self.add_button.clicked.connect(self.onAddClicked)
self.remove_button.clicked.connect(self.onRemoveClicked)
self.tree_view.clicked.connect(self.onClicked)
self.properties_model.dataChanged.connect(self.onPropertyChanged)
def onPropertyChanged(self):
self.rebuildModel()
def rebuildModel(self):
#save index hierarhy
indexes = []
tmp_index = self.tree_view.currentIndex()
indexes.append(tmp_index)
while tmp_index.parent().isValid():
indexes.append(tmp_index.parent())
tmp_index = tmp_index.parent()
self.tree_model.initRoot(self.items)
self.tree_view.expandAll()
if len(indexes) == 0:
self.onClicked(self.tree_model.index(0, 0))
else:
last_index = indexes.pop(-1)
index = self.tree_model.index(last_index.row(),
last_index.column())
#restore index hierarchy
while len(indexes) > 0:
last_index = indexes.pop(-1)
index = self.tree_model.index(last_index.row(),
last_index.column(), index)
if index.isValid():
self.onClicked(index)
else:
self.onClicked(self.tree_model.index(0, 0))
def init_menu(self):
exit_action = QAction("&Exit", self)
exit_action.setShortcut('Ctrl+Q')
exit_action.triggered.connect(qApp.quit)
file_menu = self.menuBar().addMenu("&File")
file_menu.addAction(QAction("Open", self))
file_menu.addAction(QAction("Save", self))
file_menu.addAction(QAction("SaveAs", self))
file_menu.addSeparator()
file_menu.addAction(exit_action)
def appendObjectOnScene(self, object=DataStructures.Object):
if object.rect.isValid():
self.scene.addRect(object.rect, object.color)
for child in object.childrens:
self.appendObjectOnScene(child)
def onClicked(self, index):
object = index.data(Qt.UserRole + 1)
self.properties_model.initProperties(object)
self.scene.clear()
self.appendObjectOnScene(object)
self.tree_view.setCurrentIndex(index)
def onAddClicked(self):
index = self.tree_view.currentIndex()
print(index)
object = index.data(Qt.UserRole + 1)
print(object.description())
object.add_children(DataStructures.Object("New item"))
self.rebuildModel()
def onRemoveClicked(self):
index = self.tree_view.currentIndex()
object = index.data(Qt.UserRole + 1)
if not object.parent:
self.items.remove(object)
else:
object.parent.childrens.remove(object)
self.rebuildModel()
def test(self):
self.items = []
static = DataStructures.Object(
"Static", DataStructures.createRect(0, 0, 800, 200))
static.add_children(DataStructures.Object("child_1"))
static.add_children(DataStructures.Object("child_2"))
static.add_children(DataStructures.Object("child_3"))
static.color = QColor(200, 0, 0).name()
static.childrens[0].add_children(
DataStructures.Object("child_1.1",
DataStructures.createRect(40, 40, 80, 40)))
self.items.append(static)
dynamic = DataStructures.Object(
"Dynamic", DataStructures.createRect(0, 0, 200, 800))
dynamic.add_children(DataStructures.Object("child_1"))
dynamic.add_children(DataStructures.Object("child_2"))
dynamic.add_children(DataStructures.Object("child_3"))
dynamic.childrens[2].add_children(DataStructures.Object("child_2.1"))
dynamic.color = QColor(0, 0, 200).name()
self.items.append(dynamic)
self.rebuildModel()
parents.append(parents[-1].child(parents[-1].childCount() - 1))
indentations.append(position)
else:
while position < indentations[-1] and len(parents) > 0:
parents.pop()
indentations.pop()
# Append a new item to the current parent's list of children.
parents[-1].appendChild(TreeItem(columnData, parents[-1]))
number += 1
if __name__ == "__main__":
import sys
app = QApplication(sys.argv)
f = QFile(":/default.txt")
f.open(QIODevice.ReadOnly)
model = TreeModel(f.readAll())
f.close()
view = QTreeView()
view.setModel(model)
view.setWindowTitle("Simple Tree Model")
view.show()
sys.exit(app.exec_())
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)
class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
def __init__(self, *args, **kwargs):
# QtWidgets.QMainWindow.__init__(self, *args, **kwargs)
super().__init__()
self.model = QFileSystemModel()
self.tree = QTreeView()
self.setupUi(self)
self.title = 'Env Manager 1.0'
self.left = 500
self.top = 150
self.width = 1024
self.height = 840
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model.setRootPath('')
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setGeometry(25, 150, 975, 800)
self.tree.setWindowTitle("Dir View")
# self.tree.resize(1000, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
# self.label.setText("Selecciona el directorio donde quieres crean el env")
self.show()
class FilenamePrompt(_BasePrompt):
"""A prompt for a filename."""
def __init__(self, question, parent=None):
super().__init__(question, parent)
self._init_texts(question)
self._init_fileview()
self._set_fileview_root(question.default)
self._lineedit = LineEdit(self)
if question.default:
self._lineedit.setText(question.default)
self._lineedit.textEdited.connect(self._set_fileview_root)
self._vbox.addWidget(self._lineedit)
self.setFocusProxy(self._lineedit)
self._init_key_label()
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
@pyqtSlot(str)
def _set_fileview_root(self, path, *, tabbed=False):
"""Set the root path for the file display."""
separators = os.sep
if os.altsep is not None:
separators += os.altsep
dirname = os.path.dirname(path)
try:
if not path:
pass
elif path in separators and os.path.isdir(path):
# Input "/" -> don't strip anything
pass
elif path[-1] in separators and os.path.isdir(path):
# Input like /foo/bar/ -> show /foo/bar/ contents
path = path.rstrip(separators)
elif os.path.isdir(dirname) and not tabbed:
# Input like /foo/ba -> show /foo contents
path = dirname
else:
return
except OSError:
log.prompt.exception("Failed to get directory information")
return
root = self._file_model.setRootPath(path)
self._file_view.setRootIndex(root)
@pyqtSlot(QModelIndex)
def _insert_path(self, index, *, clicked=True):
"""Handle an element selection.
Args:
index: The QModelIndex of the selected element.
clicked: Whether the element was clicked.
"""
path = os.path.normpath(self._file_model.filePath(index))
if clicked:
path += os.sep
else:
# On Windows, when we have C:\foo and tab over .., we get C:\
path = path.rstrip(os.sep)
log.prompt.debug('Inserting path {}'.format(path))
self._lineedit.setText(path)
self._lineedit.setFocus()
self._set_fileview_root(path, tabbed=True)
if clicked:
# Avoid having a ..-subtree highlighted
self._file_view.setCurrentIndex(QModelIndex())
def _init_fileview(self):
self._file_view = QTreeView(self)
self._file_model = QFileSystemModel(self)
self._file_view.setModel(self._file_model)
self._file_view.clicked.connect(self._insert_path)
self._vbox.addWidget(self._file_view)
# Only show name
self._file_view.setHeaderHidden(True)
for col in range(1, 4):
self._file_view.setColumnHidden(col, True)
# Nothing selected initially
self._file_view.setCurrentIndex(QModelIndex())
# The model needs to be sorted so we get the correct first/last index
self._file_model.directoryLoaded.connect(
lambda: self._file_model.sort(0))
def accept(self, value=None):
text = value if value is not None else self._lineedit.text()
self.question.answer = text
return True
def item_focus(self, which):
# This duplicates some completion code, but I don't see a nicer way...
assert which in ['prev', 'next'], which
selmodel = self._file_view.selectionModel()
parent = self._file_view.rootIndex()
first_index = self._file_model.index(0, 0, parent)
row = self._file_model.rowCount(parent) - 1
last_index = self._file_model.index(row, 0, parent)
if not first_index.isValid():
# No entries
return
assert last_index.isValid()
idx = selmodel.currentIndex()
if not idx.isValid():
# No item selected yet
idx = last_index if which == 'prev' else first_index
elif which == 'prev':
idx = self._file_view.indexAbove(idx)
else:
assert which == 'next', which
idx = self._file_view.indexBelow(idx)
# wrap around if we arrived at beginning/end
if not idx.isValid():
idx = last_index if which == 'prev' else first_index
selmodel.setCurrentIndex(
idx, QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
self._insert_path(idx, clicked=False)
def _allowed_commands(self):
return [('prompt-accept', 'Accept'), ('leave-mode', 'Abort')]
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'PyQt5 file system view - pythonspot.com'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath('/home/rob/Muziek')
filter = ["*.wav", "*.ogg"]
self.model.setNameFilters(filter)
self.model.setNameFilterDisables(0)
root = self.model.setRootPath('/home/rob/Muziek')
#print(root)
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setRootIndex(root)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.doubleClicked.connect(self.test)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.show()
def test(self, signal):
file_path = self.model.filePath(signal)
print(file_path)
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'PyQt5 file system view - pythonspot.com'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath('')
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.show()
class EditScreen(QWidget):
def __init__(self, rester: Rester):
super(EditScreen, self).__init__()
self.last_item_type = ''
self.rester = rester
self.tree = QTreeView()
layout = QVBoxLayout()
layout.addWidget(self.tree)
self.model = QStandardItemModel()
self.model.setHorizontalHeaderLabels(['Name'])
self.tree.header().setDefaultSectionSize(200)
self.tree.setModel(self.model)
self.data = self.rester.list_request(list(APIEnum))
self.import_data(self.data)
self.tree.setSortingEnabled(False)
self.tree.expandAll()
self.tree.setSelectionMode(QAbstractItemView.SingleSelection)
self.tree.selectionModel().selectionChanged.connect(self.item_selected)
self.init_ui()
def init_ui(self):
hbox = QHBoxLayout()
vbox = QVBoxLayout()
left_layout = QFormLayout()
tree_group_box = QGroupBox()
self.search_field = QLineEdit()
# self.search_field.editingFinished.connect(self.search_field_changed)
self.search_field.textEdited.connect(self.search_field_changed)
left_layout.addRow(QLabel('Search:'), self.search_field)
tree_group_box.setLayout(left_layout)
vbox.addWidget(tree_group_box)
vbox.addWidget(self.tree)
gb = QGroupBox()
gb.setLayout(vbox)
self.splitter = QSplitter()
self.splitter.addWidget(gb)
self.ew = EquipmentEdit()
self.splitter.addWidget(self.ew)
hbox.addWidget(self.splitter)
self.setLayout(hbox)
def import_data(self, data, root=None):
self.model.setRowCount(0)
if root is None:
root = self.model.invisibleRootItem()
for key, value_list in data.items():
parent = TreeItem({'name': key}, '', parent=True)
parent.setEditable(False)
root.appendRow([parent])
for value in value_list:
parent.appendRow([TreeItem(value, key)])
def search_field_changed(self):
term = self.search_field.text()
data = {}
for key, value_list in self.data.items():
li = []
for value in value_list:
for k in value.keys():
if term in k:
li.append(value)
data[key] = li
self.import_data(data)
def item_selected(self):
indexes = self.tree.selectedIndexes()
selected = indexes[0]
item = self.model.itemFromIndex(selected)
if item.is_parent:
return
#if item.typ != self.last_item_type:
self.ew.hide()
self.ew.destroy()
self.ew = get_edit_widget(item.typ, self.data)
self.splitter.addWidget(self.ew)
self.last_item_type = item.typ
data_dict = item.get_data_dict()
self.ew.load_data(data_dict)
class RunTimeGui(QMainWindow):
activeStateChanged = pyqtSignal(int)
runningStateChanged = pyqtSignal(int)
loadFromRoot = pyqtSignal(int)
def __init__(self, parent=None):
super(QMainWindow, self).__init__()
self.setWindowTitle("VisualStates RunTime GUI")
self.rootState = None
# create status bar
self.statusBar()
self.createTreeView()
self.createStateCanvas()
self.setGeometry(0, 0, 800, 600)
self.show()
self.states = {}
self.transitions = {}
self.activeState = None
self.activeStateChanged.connect(self.activeStateChangedHandle)
self.runningStateChanged.connect(self.runningStateChangedHandle)
self.loadFromRoot.connect(self.loadFromRootHandle)
self.memory = None
self.ipcThread = None
def createTreeView(self):
dockWidget = QDockWidget()
dockWidget.setAllowedAreas(Qt.LeftDockWidgetArea)
dockWidget.setFeatures(QDockWidget.NoDockWidgetFeatures)
dockWidget.setTitleBarWidget(QWidget())
self.treeView = QTreeView()
self.treeView.clicked.connect(self.treeItemClicked)
self.treeModel = TreeModel()
self.treeView.setModel(self.treeModel)
self.logo = QLabel()
logoPixmap = QPixmap(CMAKE_INSTALL_PREFIX +
'/share/jderobot/resources/jderobot.png')
self.logo.setPixmap(logoPixmap)
self.upButton = QPushButton()
self.upButton.setText('Up')
self.upButton.clicked.connect(self.upButtonClicked)
leftContainer = QWidget()
leftLayout = QVBoxLayout()
leftLayout.addWidget(self.treeView)
leftLayout.addWidget(self.upButton)
leftLayout.addWidget(self.logo)
leftContainer.setLayout(leftLayout)
dockWidget.setWidget(leftContainer)
self.addDockWidget(Qt.LeftDockWidgetArea, dockWidget)
def createStateCanvas(self):
self.stateCanvas = QGraphicsView()
self.scene = QGraphicsScene()
self.scene.setSceneRect(0, 0, 2000, 2000)
self.setCentralWidget(self.stateCanvas)
self.stateCanvas.setScene(self.scene)
self.stateCanvas.setRenderHint(QPainter.Antialiasing)
def addState(self, id, name, initial, x, y, parentId):
if parentId is not None:
self.states[id] = State(id, name, initial, self.states[parentId])
self.states[parentId].addChild(self.states[id])
parentItem = self.treeModel.getByDataId(parentId)
# print('parent:' + str(parentItem))
else:
self.states[id] = State(id, name, initial, None)
if id == 0:
self.rootState = self.states[id]
self.states[id].setPos(x, y)
def addTransition(self, id, name, originId, destinationId, x, y):
self.transitions[id] = Transition(id, name, self.states[originId],
self.states[destinationId])
self.transitions[id].setPos(x, y)
def emitRunningStateById(self, id):
# print('emit running state:' + str(id))
self.runningStateChanged.emit(id)
def runningStateChangedHandle(self, id):
# print('running state:' + str(id))
if id not in self.states:
return
runningState = self.states[id]
parentId = None
if runningState.parent is not None:
for child in runningState.parent.getChildren():
child.setRunning(False)
runningState.setRunning(True)
parentId = runningState.parent.id
self.treeModel.setAllBackgroundByParentId(Qt.white, parentId)
self.treeModel.setBackgroundById(runningState.id, Qt.green)
def emitActiveStateById(self, id):
self.activeStateChanged.emit(id)
def activeStateChangedHandle(self, id):
if self.activeState is not None:
for child in self.activeState.getChildren():
child.resetGraphicsItem()
for tran in child.getOriginTransitions():
tran.resetGraphicsItem()
self.activeState = self.states[id]
# print('set active state:' + str(id))
self.scene.clear()
for childState in self.activeState.getChildren():
# print('add child to scene:' + str(childState.id))
qitem = childState.getGraphicsItem()
qitem.setAcceptHoverEvents(False)
qitem.setFlag(QGraphicsItem.ItemIsMovable, False)
qitem.doubleClicked.connect(self.stateDoubleClicked)
self.setAcceptDrops(False)
self.scene.addItem(qitem)
for tran in childState.getOriginTransitions():
# print('add transition:' + str(tran.id))
qitem = tran.getGraphicsItem()
qitem.disableInteraction()
self.scene.addItem(qitem)
def emitLoadFromRoot(self):
self.loadFromRoot.emit(0)
def loadFromRootHandle(self, id):
self.treeModel.loadFromRoot(self.states[id])
def stateDoubleClicked(self, stateItem):
if len(stateItem.stateData.getChildren()) > 0:
self.emitActiveStateById(stateItem.stateData.id)
def upButtonClicked(self):
if self.activeState is not None:
if self.activeState.parent is not None:
self.emitActiveStateById(self.activeState.parent.id)
def getStateById(self, state, id):
if state.id == id:
return state
else:
result = None
for child in state.getChildren():
result = self.getStateById(child, id)
if result is not None:
return result
return result
def treeItemClicked(self, index):
# print('clicked item.id:' + str(index.internalPointer().id))
pass
def getStateList(self, state, stateList):
if len(state.getChildren()) > 0:
stateList.append(state)
for s in state.getChildren():
self.getStateList(s, stateList)
def loopIPC(self):
while True:
msg = self.getIPCMessage()
if msg is not None:
# print('msg received:' + msg)
methodName = msg.split(' ')[0]
id = int(msg.split(' ')[1])
if methodName == 'emitRunningStateById':
self.emitRunningStateById(id)
else:
print('unknown method name')
time.sleep(1.0 / 1000)
def activateIPC(self):
try:
self.memory = sysv_ipc.SharedMemory(123456, sysv_ipc.IPC_CREX)
except:
# if memory exists just open shared memory
self.memory = sysv_ipc.SharedMemory(123456)
self.ipcThread = Thread(target=self.loopIPC)
self.ipcThread.start()
def getIPCMessage(self):
if self.memory is not None:
data = self.memory.read().decode()
if data[0] != '0':
self.memory.write('0'.encode())
i = data.find('\0')
if i != -1:
data = data[:i]
return data
return None
def __init__(self, parent):
QTreeView.__init__(self, parent)
def __init__(self):
super().__init__()
self.setWindowTitle('World Country Diagram')
self.resize(500, 700)
treeView = QTreeView()
treeView.setHeaderHidden(False)
treeModel = QStandardItemModel()
self.most_used_cat_header = [
'Nom', "Prénom", "Sexe", "Date Inscription", "Courriel Client",
"Mot de passe", "Numéro de carte", "Expiration", "Code"
]
treeModel.setHorizontalHeaderLabels(self.most_used_cat_header)
rootNode = treeModel.invisibleRootItem()
# America
america = QStandardItem('America')
california = QStandardItem('California')
america.appendRow(california)
oakland = QStandardItem('Oakland')
sanfrancisco = QStandardItem('San Francisco')
sanjose = QStandardItem('San Jose')
california.appendRow(oakland)
california.appendRow(sanfrancisco)
california.appendRow(sanjose)
texas = QStandardItem('Texas')
america.appendRow(texas)
austin = QStandardItem('Austin')
houston = QStandardItem('Houston')
dallas = QStandardItem('dallas')
testo = QStandardItem("testo")
testo2 = QStandardItem("testo2")
testo3 = QStandardItem("testo3")
vide1 = QStandardItem("")
vide2 = QStandardItem("")
vide3 = QStandardItem("")
item = (austin, houston, dallas)
america.appendRow(item)
item2 = (vide1, vide2, vide3, testo, testo2, testo3)
#texas.appendRow(austin)
#texas.appendRow(houston)
#texas.appendRow(dallas)
austin.appendRow(item2)
# Canada
canada = QStandardItem('Canada')
alberta = QStandardItem('Alberta')
bc = QStandardItem('British Columbia')
ontario = QStandardItem('Ontario')
canada.appendRows([alberta, bc, ontario])
rootNode.appendRow(america)
rootNode.appendRow(canada)
treeView.setModel(treeModel)
treeView.expandAll()
treeView.doubleClicked.connect(self.getValue)
self.setCentralWidget(treeView)
class ShellTableEditor(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.model = None
self.shell_model = ShellTableTreeModel()
self.tree_view = QTreeView(self)
self.tree_view.setModel(self.shell_model)
layout = QVBoxLayout()
self.setLayout(layout)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.init_navigation(), 0)
layout.addWidget(self.tree_view, 1)
layout.addWidget(self.init_docs(), 0)
def get_icon(self, name):
return self.style().standardIcon(name)
def init_navigation(self):
self.prev_button = QPushButton(self.get_icon(QStyle.SP_ArrowLeft), "")
self.prev_button.setFlat(True)
self.next_button = QPushButton(self.get_icon(QStyle.SP_ArrowRight), "")
self.next_button.setFlat(True)
self.prev_button.clicked.connect(self.handle_prev_button_clicked)
self.next_button.clicked.connect(self.handle_next_button_clicked)
self.current_index = QSpinBox()
self.current_index.setMinimumWidth(60)
self.current_index.valueChanged.connect(self.handle_current_index_changed)
box = QWidget(self)
box_layout = QHBoxLayout(box)
box_layout.setContentsMargins(0, 0, 0, 0)
box.setLayout(box_layout)
box_layout.addWidget(self.prev_button, 0)
box_layout.addWidget(self.next_button, 0)
box_layout.addWidget(QLabel("Index:"), 0)
box_layout.addWidget(self.current_index, 0)
box_layout.addStretch(1)
return box
def init_docs(self):
box = QWidget(self)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
box.setLayout(layout)
layout.addWidget(QLabel(DOC_CAPACITY), 0, Qt.AlignTop)
layout.addWidget(QLabel(DOC_RECOIL), 0, Qt.AlignTop)
layout.addWidget(QLabel(DOC_RELOAD), 1, Qt.AlignTop)
return box
def handle_current_index_changed(self, value):
parent_index = QModelIndex()
qindex = self.shell_model.index(self.current_index.value(), 0, parent_index)
self.tree_view.setRootIndex(qindex)
self.tree_view.expandAll()
def handle_prev_button_clicked(self):
self.current_index.setValue(self.current_index.value() - 1)
def handle_next_button_clicked(self):
self.current_index.setValue(self.current_index.value() + 1)
def set_model(self, model):
self.model = model
if model is None:
self.shell_model.update([])
self.current_index.setMaximum(0)
else:
self.shell_model.update(self.model.data.entries)
self.current_index.setMaximum(len(self.model.data.entries) - 1)
self.handle_current_index_changed(0)
self.tree_view.header().resizeSection(0, 120)
def closeEvent(self, e):
logger.debug('closeEvent')
QTreeView.closeEvent(self, e)
class Page2(QWizardPage):
timespan = ['Daily', 'Weekly', 'Yearly']
timestamp = [
'12:00', '12:30', '1:00', '1:30', '2:00', '2:30', '3:00', '3:30',
'4:00', '4:30', '5:00', '5:30', '6:00', '6:30', '7:00', '7:30', '8:00',
'8:30', '9:00', '9:30', '10:00', '10:30', '11:00', '11:30'
]
ap = ['AM', 'PM']
day = [
'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday',
'Saturday'
]
timez = []
timespancmbox = None
dayscmbox = None
timecmbox = None
ampm = None
timezonecmbox = None
model = None
view = None
def __init__(self, parent=None):
super(Page2, self).__init__(parent)
mainlayout = QVBoxLayout()
timecontrolLay = QHBoxLayout()
self.timespancmbox = QComboBox()
self.dayscmbox = QComboBox()
self.timecmbox = QComboBox()
self.ampm = QComboBox()
self.timezonecmbox = QComboBox()
self.timespancmbox.addItems(self.timespan)
self.dayscmbox.addItems(self.day)
self.timecmbox.addItems(self.timestamp)
self.ampm.addItems(self.ap)
self.dayscmbox.hide()
self.timezonecmbox.addItems(self.timez)
self.view = QTreeView()
timecontrolLay.addWidget(self.timespancmbox)
timecontrolLay.addWidget(self.dayscmbox)
timecontrolLay.addWidget(self.timecmbox)
timecontrolLay.addWidget(self.ampm)
mainlayout.addLayout(timecontrolLay)
mainlayout.addWidget(self.view)
self.setLayout(mainlayout)
self.timespancmbox.currentTextChanged.connect(self.showdays)
def showdays(self, text):
if text == "Weekly":
self.dayscmbox.show()
elif text == "Daily":
self.dayscmbox.hide()
def init_allVol(self, volumes_of_instances):
print(volumes_of_instances)
self.model = QStandardItemModel()
self.model.setHorizontalHeaderLabels(['instance and related voloumns'])
self.view.setModel(self.model)
self.view.setUniformRowHeights(True)
for key, value in volumes_of_instances.items():
parent1 = QStandardItem(key)
for v in value:
vol = QStandardItem(v)
vol.setCheckState(Qt.Unchecked)
vol.setCheckable(True)
vol.setEditable(False)
parent1.appendRow(vol)
self.model.appendRow(parent1)
self.view.show()
self.model.itemChanged.connect(self.check_vol)
def check_vol(self, item):
print(item.text())
class DirectoriesDialog(QMainWindow):
def __init__(self, app, **kwargs):
super().__init__(None, **kwargs)
self.app = app
self.specific_actions = set()
self.lastAddedFolder = platform.INITIAL_FOLDER_IN_DIALOGS
self.recentFolders = Recent(self.app, "recentFolders")
self._setupUi()
self._updateScanTypeList()
self.directoriesModel = DirectoriesModel(self.app.model.directory_tree,
view=self.treeView)
self.directoriesDelegate = DirectoriesDelegate()
self.treeView.setItemDelegate(self.directoriesDelegate)
self._setupColumns()
self.app.recentResults.addMenu(self.menuLoadRecent)
self.app.recentResults.addMenu(self.menuRecentResults)
self.recentFolders.addMenu(self.menuRecentFolders)
self._updateAddButton()
self._updateRemoveButton()
self._updateLoadResultsButton()
self._updateActionsState()
self._setupBindings()
def _setupBindings(self):
self.appModeRadioBox.itemSelected.connect(self.appModeButtonSelected)
self.showPreferencesButton.clicked.connect(
self.app.actionPreferences.trigger)
self.scanButton.clicked.connect(self.scanButtonClicked)
self.loadResultsButton.clicked.connect(self.actionLoadResults.trigger)
self.addFolderButton.clicked.connect(self.actionAddFolder.trigger)
self.removeFolderButton.clicked.connect(self.removeFolderButtonClicked)
self.treeView.selectionModel().selectionChanged.connect(
self.selectionChanged)
self.app.recentResults.itemsChanged.connect(
self._updateLoadResultsButton)
self.recentFolders.itemsChanged.connect(self._updateAddButton)
self.recentFolders.mustOpenItem.connect(self.app.model.add_directory)
self.directoriesModel.foldersAdded.connect(
self.directoriesModelAddedFolders)
self.app.willSavePrefs.connect(self.appWillSavePrefs)
def _setupActions(self):
# (name, shortcut, icon, desc, func)
ACTIONS = [
(
"actionLoadResults",
"Ctrl+L",
"",
tr("Load Results..."),
self.loadResultsTriggered,
),
(
"actionShowResultsWindow",
"",
"",
tr("Scan Results"),
self.app.showResultsWindow,
),
("actionAddFolder", "", "", tr("Add Folder..."),
self.addFolderTriggered),
("actionLoadDirectories", "", "", tr("Load Directories..."),
self.loadDirectoriesTriggered),
("actionSaveDirectories", "", "", tr("Save Directories..."),
self.saveDirectoriesTriggered),
]
createActions(ACTIONS, self)
if self.app.use_tabs:
# Keep track of actions which should only be accessible from this window
self.specific_actions.add(self.actionLoadDirectories)
self.specific_actions.add(self.actionSaveDirectories)
def _setupMenu(self):
if not self.app.use_tabs:
# we are our own QMainWindow, we need our own menu bar
self.menubar = QMenuBar(self)
self.menubar.setGeometry(QRect(0, 0, 42, 22))
self.menuFile = QMenu(self.menubar)
self.menuFile.setTitle(tr("File"))
self.menuView = QMenu(self.menubar)
self.menuView.setTitle(tr("View"))
self.menuHelp = QMenu(self.menubar)
self.menuHelp.setTitle(tr("Help"))
self.setMenuBar(self.menubar)
menubar = self.menubar
else:
# we are part of a tab widget, we populate its window's menubar instead
self.menuFile = self.app.main_window.menuFile
self.menuView = self.app.main_window.menuView
self.menuHelp = self.app.main_window.menuHelp
menubar = self.app.main_window.menubar
self.menuLoadRecent = QMenu(self.menuFile)
self.menuLoadRecent.setTitle(tr("Load Recent Results"))
self.menuFile.addAction(self.actionLoadResults)
self.menuFile.addAction(self.menuLoadRecent.menuAction())
self.menuFile.addSeparator()
self.menuFile.addAction(self.app.actionClearPictureCache)
self.menuFile.addSeparator()
self.menuFile.addAction(self.actionLoadDirectories)
self.menuFile.addAction(self.actionSaveDirectories)
self.menuFile.addSeparator()
self.menuFile.addAction(self.app.actionQuit)
self.menuView.addAction(self.app.actionDirectoriesWindow)
self.menuView.addAction(self.actionShowResultsWindow)
self.menuView.addAction(self.app.actionIgnoreList)
self.menuView.addAction(self.app.actionExcludeList)
self.menuView.addSeparator()
self.menuView.addAction(self.app.actionPreferences)
self.menuHelp.addAction(self.app.actionShowHelp)
self.menuHelp.addAction(self.app.actionOpenDebugLog)
self.menuHelp.addAction(self.app.actionAbout)
menubar.addAction(self.menuFile.menuAction())
menubar.addAction(self.menuView.menuAction())
menubar.addAction(self.menuHelp.menuAction())
# Recent folders menu
self.menuRecentFolders = QMenu()
self.menuRecentFolders.addAction(self.actionAddFolder)
self.menuRecentFolders.addSeparator()
# Recent results menu
self.menuRecentResults = QMenu()
self.menuRecentResults.addAction(self.actionLoadResults)
self.menuRecentResults.addSeparator()
def _setupUi(self):
self.setWindowTitle(self.app.NAME)
self.resize(420, 338)
self.centralwidget = QWidget(self)
self.verticalLayout = QVBoxLayout(self.centralwidget)
self.verticalLayout.setContentsMargins(4, 0, 4, 0)
self.verticalLayout.setSpacing(0)
hl = QHBoxLayout()
label = QLabel(tr("Application Mode:"), self)
label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
hl.addWidget(label)
self.appModeRadioBox = RadioBox(
self,
items=[tr("Standard"), tr("Music"),
tr("Picture")],
spread=False)
hl.addWidget(self.appModeRadioBox)
self.verticalLayout.addLayout(hl)
hl = QHBoxLayout()
hl.setAlignment(Qt.AlignLeft)
label = QLabel(tr("Scan Type:"), self)
label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
hl.addWidget(label)
self.scanTypeComboBox = QComboBox(self)
self.scanTypeComboBox.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed))
self.scanTypeComboBox.setMaximumWidth(400)
hl.addWidget(self.scanTypeComboBox)
self.showPreferencesButton = QPushButton(tr("More Options"),
self.centralwidget)
self.showPreferencesButton.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.Fixed)
hl.addWidget(self.showPreferencesButton)
self.verticalLayout.addLayout(hl)
self.promptLabel = QLabel(
tr('Select folders to scan and press "Scan".'), self.centralwidget)
self.verticalLayout.addWidget(self.promptLabel)
self.treeView = QTreeView(self.centralwidget)
self.treeView.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.treeView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.treeView.setAcceptDrops(True)
triggers = (QAbstractItemView.DoubleClicked
| QAbstractItemView.EditKeyPressed
| QAbstractItemView.SelectedClicked)
self.treeView.setEditTriggers(triggers)
self.treeView.setDragDropOverwriteMode(True)
self.treeView.setDragDropMode(QAbstractItemView.DropOnly)
self.treeView.setUniformRowHeights(True)
self.verticalLayout.addWidget(self.treeView)
self.horizontalLayout = QHBoxLayout()
self.removeFolderButton = QPushButton(self.centralwidget)
self.removeFolderButton.setIcon(QIcon(QPixmap(":/minus")))
self.removeFolderButton.setShortcut("Del")
self.horizontalLayout.addWidget(self.removeFolderButton)
self.addFolderButton = QPushButton(self.centralwidget)
self.addFolderButton.setIcon(QIcon(QPixmap(":/plus")))
self.horizontalLayout.addWidget(self.addFolderButton)
spacerItem1 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem1)
self.loadResultsButton = QPushButton(self.centralwidget)
self.loadResultsButton.setText(tr("Load Results"))
self.horizontalLayout.addWidget(self.loadResultsButton)
self.scanButton = QPushButton(self.centralwidget)
self.scanButton.setText(tr("Scan"))
self.scanButton.setDefault(True)
self.horizontalLayout.addWidget(self.scanButton)
self.verticalLayout.addLayout(self.horizontalLayout)
self.setCentralWidget(self.centralwidget)
self._setupActions()
self._setupMenu()
if self.app.prefs.directoriesWindowRect is not None:
self.setGeometry(self.app.prefs.directoriesWindowRect)
else:
moveToScreenCenter(self)
def _setupColumns(self):
header = self.treeView.header()
header.setStretchLastSection(False)
header.setSectionResizeMode(0, QHeaderView.Stretch)
header.setSectionResizeMode(1, QHeaderView.Fixed)
header.resizeSection(1, 100)
def _updateActionsState(self):
self.actionShowResultsWindow.setEnabled(
self.app.resultWindow is not None)
def _updateAddButton(self):
if self.recentFolders.isEmpty():
self.addFolderButton.setMenu(None)
else:
self.addFolderButton.setMenu(self.menuRecentFolders)
def _updateRemoveButton(self):
indexes = self.treeView.selectedIndexes()
if not indexes:
self.removeFolderButton.setEnabled(False)
return
self.removeFolderButton.setEnabled(True)
def _updateLoadResultsButton(self):
if self.app.recentResults.isEmpty():
self.loadResultsButton.setMenu(None)
else:
self.loadResultsButton.setMenu(self.menuRecentResults)
def _updateScanTypeList(self):
try:
self.scanTypeComboBox.currentIndexChanged[int].disconnect(
self.scanTypeChanged)
except TypeError:
# Not connected, ignore
pass
self.scanTypeComboBox.clear()
scan_options = self.app.model.SCANNER_CLASS.get_scan_options()
for scan_option in scan_options:
self.scanTypeComboBox.addItem(scan_option.label)
SCAN_TYPE_ORDER = [so.scan_type for so in scan_options]
selected_scan_type = self.app.prefs.get_scan_type(
self.app.model.app_mode)
scan_type_index = SCAN_TYPE_ORDER.index(selected_scan_type)
self.scanTypeComboBox.setCurrentIndex(scan_type_index)
self.scanTypeComboBox.currentIndexChanged[int].connect(
self.scanTypeChanged)
self.app._update_options()
# --- QWidget overrides
def closeEvent(self, event):
event.accept()
if self.app.model.results.is_modified:
title = tr("Unsaved results")
msg = tr("You have unsaved results, do you really want to quit?")
if not self.app.confirm(title, msg):
event.ignore()
if event.isAccepted():
self.app.shutdown()
# --- Events
def addFolderTriggered(self):
title = tr("Select a folder to add to the scanning list")
flags = QFileDialog.ShowDirsOnly
dirpath = str(
QFileDialog.getExistingDirectory(self, title, self.lastAddedFolder,
flags))
if not dirpath:
return
self.lastAddedFolder = dirpath
self.app.model.add_directory(dirpath)
self.recentFolders.insertItem(dirpath)
def appModeButtonSelected(self, index):
if index == 2:
mode = AppMode.Picture
elif index == 1:
mode = AppMode.Music
else:
mode = AppMode.Standard
self.app.model.app_mode = mode
self._updateScanTypeList()
def appWillSavePrefs(self):
self.app.prefs.directoriesWindowRect = self.geometry()
def directoriesModelAddedFolders(self, folders):
for folder in folders:
self.recentFolders.insertItem(folder)
def loadResultsTriggered(self):
title = tr("Select a results file to load")
files = ";;".join(
[tr("dupeGuru Results (*.dupeguru)"),
tr("All Files (*.*)")])
destination = QFileDialog.getOpenFileName(self, title, "", files)[0]
if destination:
self.app.model.load_from(destination)
self.app.recentResults.insertItem(destination)
def loadDirectoriesTriggered(self):
title = tr("Select a directories file to load")
files = ";;".join([
tr("dupeGuru Directories (*.dupegurudirs)"),
tr("All Files (*.*)")
])
destination = QFileDialog.getOpenFileName(self, title, "", files)[0]
if destination:
self.app.model.load_directories(destination)
def removeFolderButtonClicked(self):
self.directoriesModel.model.remove_selected()
def saveDirectoriesTriggered(self):
title = tr("Select a file to save your directories to")
files = tr("dupeGuru Directories (*.dupegurudirs)")
destination, chosen_filter = QFileDialog.getSaveFileName(
self, title, "", files)
if destination:
if not destination.endswith(".dupegurudirs"):
destination = "{}.dupegurudirs".format(destination)
self.app.model.save_directories_as(destination)
def scanButtonClicked(self):
if self.app.model.results.is_modified:
title = tr("Start a new scan")
msg = tr(
"You have unsaved results, do you really want to continue?")
if not self.app.confirm(title, msg):
return
self.app.model.start_scanning()
def scanTypeChanged(self, index):
scan_options = self.app.model.SCANNER_CLASS.get_scan_options()
self.app.prefs.set_scan_type(self.app.model.app_mode,
scan_options[index].scan_type)
self.app._update_options()
def selectionChanged(self, selected, deselected):
self._updateRemoveButton()
class VisualStates(QMainWindow):
def __init__(self, parent=None):
super(QMainWindow, self).__init__()
self.setWindowTitle("VisualStates")
self.configDialog = None
# root state
self.globalNamespace = Namespace('', '', [])
self.localNamespace = Namespace('', '', [])
self.rootState = State(0, "root", True, self.localNamespace)
self.activeState = self.rootState
self.activeNamespace = self.localNamespace
# create status bar
# remove border around the widget added to the status bar
self.setStyleSheet("QStatusBar::item { border: 0px solid black }; ")
statusBar = self.statusBar()
logo = QLabel()
logo.setAlignment(Qt.AlignHCenter)
logoPixmap = QPixmap(getPackagePath() + '/resources/jderobot.png')
logo.setPixmap(logoPixmap)
statusBar.addWidget(logo)
self.createMenu()
self.createTreeView()
self.createStateCanvas()
self.setGeometry(0, 0, 800, 600)
self.show()
self.fileManager = FileManager()
self.importManager = ImportManager()
self.automataPath = None
self.libraries = []
self.config = None
def createMenu(self):
# create actions
newAction = QAction('&New', self)
newAction.setShortcut('Ctrl+N')
newAction.setStatusTip('Create New Visual States')
newAction.triggered.connect(self.newAction)
openAction = QAction('&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open Visual States')
openAction.triggered.connect(self.openAction)
importAction = QAction('&Import', self)
openAction.setShortcut('Ctrl+I')
importAction.setStatusTip('Import A State')
importAction.triggered.connect(self.importAction)
saveAction = QAction('&Save', self)
saveAction.setShortcut('Ctrl+S')
saveAction.setStatusTip('Save Visual States')
saveAction.triggered.connect(self.saveAction)
saveAsAction = QAction('&Save As', self)
saveAsAction.setShortcut('Ctrl+S')
saveAsAction.setStatusTip('Save Visual States as New One')
saveAsAction.triggered.connect(self.saveAsAction)
libImportAction = QAction('&Library Import', self)
libImportAction.setStatusTip('Import from Online Library of Automatas')
libImportAction.triggered.connect(self.libImportAction)
libExportAction = QAction('&Library Export', self)
libExportAction.setStatusTip('Export to Online Library of Automata')
libExportAction.triggered.connect(self.libExportAction)
quitAction = QAction('&Quit', self)
quitAction.setShortcut('Ctrl+Q')
quitAction.setStatusTip('Quit Visual States')
quitAction.triggered.connect(self.quitAction)
# figures menu
stateAction = QAction('&State', self)
stateAction.setStatusTip('Create a state')
stateAction.triggered.connect(self.stateAction)
transitionAction = QAction('&Transition', self)
transitionAction.setStatusTip('Create a transition')
transitionAction.triggered.connect(self.transitionAction)
timerAction = QAction('&Timer', self)
timerAction.setShortcut('Ctrl+M')
timerAction.setStatusTip('Set timing of states')
timerAction.triggered.connect(self.timerAction)
globalNamespaceAction = QAction('&Global Namespace', self)
globalNamespaceAction.setShortcut('Ctrl+G')
globalNamespaceAction.setStatusTip('Open Global Namespace')
globalNamespaceAction.triggered.connect(self.globalNamespaceAction)
stateNamespaceAction = QAction('&State Namespace', self)
stateNamespaceAction.setShortcut('Ctrl+G')
stateNamespaceAction.setStatusTip('Open State Namespace')
stateNamespaceAction.triggered.connect(self.localNamespaceAction)
# actions menu
librariesAction = QAction('&Libraries', self)
librariesAction.setShortcut('Ctrl+L')
librariesAction.setStatusTip('Add additional libraries')
librariesAction.triggered.connect(self.librariesAction)
configFileAction = QAction('&ROS Config', self)
configFileAction.setShortcut('Ctrl+R')
configFileAction.setStatusTip('Edit ROS configuration')
configFileAction.triggered.connect(self.configFileAction)
generateCppAction = QAction('&Generate C++', self)
generateCppAction.setShortcut('Ctrl+G')
generateCppAction.setStatusTip('Generate C++ code')
generateCppAction.triggered.connect(self.generateCppAction)
generatePythonAction = QAction('&Generate Python', self)
generatePythonAction.setShortcut('Ctrl+Y')
generatePythonAction.setStatusTip('Generate Python code')
generatePythonAction.triggered.connect(self.generatePythonAction)
# help menu
aboutAction = QAction('&About', self)
aboutAction.setShortcut('F1')
aboutAction.setStatusTip('Information about VisualStates')
aboutAction.triggered.connect(self.aboutAction)
# create main menu
menubar = self.menuBar()
archieveMenu = menubar.addMenu('&File')
archieveMenu.addAction(newAction)
archieveMenu.addAction(openAction)
archieveMenu.addAction(importAction)
archieveMenu.addAction(libImportAction)
archieveMenu.addAction(saveAction)
archieveMenu.addAction(saveAsAction)
archieveMenu.addAction(libExportAction)
archieveMenu.addAction(quitAction)
figuresMenu = menubar.addMenu('&Figures')
figuresMenu.addAction(stateAction)
figuresMenu.addAction(transitionAction)
dataMenu = menubar.addMenu('&Data')
dataMenu.addAction(timerAction)
dataMenu.addAction(globalNamespaceAction)
dataMenu.addAction(stateNamespaceAction)
actionsMenu = menubar.addMenu('&Actions')
actionsMenu.addAction(librariesAction)
actionsMenu.addAction(configFileAction)
actionsMenu.addAction(generateCppAction)
# actionsMenu.addAction(compileCppAction)
actionsMenu.addAction(generatePythonAction)
helpMenu = menubar.addMenu('&Help')
helpMenu.addAction(aboutAction)
def newAction(self):
self.automataScene.clearScene()
self.treeModel.removeAll()
# create new root state
self.globalNamespace = Namespace('', '', [])
self.localNamespace = Namespace('', '', [])
self.rootState = State(0, 'root', True, self.localNamespace)
self.automataScene.setActiveState(self.rootState)
self.automataScene.resetIndexes()
self.libraries = []
self.config = None
def openAction(self):
fileDialog = QFileDialog(self)
fileDialog.setWindowTitle("Open VisualStates File")
fileDialog.setViewMode(QFileDialog.Detail)
fileDialog.setNameFilters(['VisualStates File (*.xml)'])
fileDialog.setDefaultSuffix('.xml')
fileDialog.setAcceptMode(QFileDialog.AcceptOpen)
if fileDialog.exec_():
self.openFile(fileDialog.selectedFiles()[0])
def openFile(self, fileName):
(self.rootState, self.config, self.libraries,
self.globalNamespace) = self.fileManager.open(fileName)
self.automataPath = self.fileManager.fullPath
self.treeModel.removeAll()
self.treeModel.loadFromRoot(self.rootState)
# set the active state as the loaded state
self.automataScene.setActiveState(self.rootState)
self.automataScene.setLastIndexes(self.rootState)
def saveAction(self):
if len(self.fileManager.getFileName()) == 0:
self.saveAsAction()
else:
self.fileManager.save(self.rootState, self.config, self.libraries,
self.globalNamespace)
def saveAsAction(self):
fileDialog = QFileDialog(self)
fileDialog.setWindowTitle("Save VisualStates Project")
fileDialog.setViewMode(QFileDialog.Detail)
fileDialog.setNameFilters(['VisualStates File (*.xml)'])
fileDialog.setAcceptMode(QFileDialog.AcceptSave)
if fileDialog.exec_():
self.fileManager.setFullPath(fileDialog.selectedFiles()[0])
self.fileManager.save(self.rootState, self.config, self.libraries,
self.globalNamespace)
def quitAction(self):
# print('Quit')
self.close()
def stateAction(self):
self.automataScene.setOperationType(OpType.ADDSTATE)
def transitionAction(self):
self.automataScene.setOperationType(OpType.ADDTRANSITION)
def importAction(self):
fileDialog = QFileDialog(self)
fileDialog.setWindowTitle("Import VisualStates File")
fileDialog.setViewMode(QFileDialog.Detail)
fileDialog.setNameFilters(['VisualStates File (*.xml)'])
fileDialog.setDefaultSuffix('.xml')
fileDialog.setAcceptMode(QFileDialog.AcceptOpen)
if fileDialog.exec_():
tempPath = self.fileManager.getFullPath()
file = self.fileManager.open(fileDialog.selectedFiles()[0])
self.fileManager.setFullPath(tempPath)
self.importFile(file)
def importFile(self, file):
# if the current active state already has an initial state make sure that
# there will not be any initial state in the imported state
if self.activeState.getInitialChild() is not None:
for childState in file[0].getChildren():
childState.setInitial(False)
displayParamDialog = ImportDialog("Imported States and Parameters",
file)
if displayParamDialog.exec_():
file = displayParamDialog.file
# Update importing Namespaces
importedState, self.config, self.libraries, self.globalNamespace = self.importManager.updateAuxiliaryData(
file, self)
self.treeModel.loadFromRoot(importedState, self.activeState)
self.automataScene.displayState(self.activeState)
self.automataScene.setLastIndexes(self.rootState)
def libImportAction(self):
fileImportDialog = FileImportDialog()
fileImportDialog.fileStr.connect(self.libImportFile)
fileImportDialog.exec_()
def libImportFile(self, fileStr):
file = self.fileManager.parse(fileStr)
self.importFile(file)
def libExportAction(self):
xmlFile = self.fileManager.generateXml(self.rootState, self.config,
self.libraries,
self.globalNamespace)
githubCredDialog = GithubCredentialsDialog()
if githubCredDialog.exec_():
username = githubCredDialog.username
password = githubCredDialog.password
fileExportDialog = LibraryExportDialog(username, password, xmlFile)
if fileExportDialog.exec_():
self.showInfo("Success", "Behaviour successfully exported.")
def timerAction(self):
if self.activeState is not None:
timerDialog = TimerDialog('Time Step Duration',
str(self.activeState.getTimeStep()))
timerDialog.timeChanged.connect(self.timeStepDurationChanged)
timerDialog.exec_()
def globalNamespaceAction(self):
self.globalNamespaceDialog = NamespaceDialog('Global Namespace',
self.globalNamespace,
True)
self.globalNamespaceDialog.namespaceChanged.connect(
self.globalNamespaceChanged)
self.globalNamespaceDialog.exec_()
def localNamespaceAction(self):
self.localNamespaceDialog = NamespaceDialog('Local Namespace',
self.activeNamespace)
self.localNamespaceDialog.namespaceChanged.connect(
self.localNamespaceChanged)
self.localNamespaceDialog.exec_()
def librariesAction(self):
librariesDialog = LibrariesDialog('Libraries', self.libraries)
librariesDialog.librariesChanged.connect(self.librariesChanged)
librariesDialog.exec_()
def configFileAction(self):
if self.config is None:
self.config = RosConfig()
self.configDialog = RosConfigDialog('Config', self.config)
self.configDialog.exec_()
def showWarning(self, title, msg):
QMessageBox.warning(self, title, msg)
def showInfo(self, title, msg):
QMessageBox.information(self, title, msg)
def generateCppAction(self):
stateList = []
if self.fileManager.hasFile():
self.getStateList(self.rootState, stateList)
if self.config is None:
self.config = RosConfig()
generator = CppRosGenerator(self.libraries, self.config, stateList,
self.globalNamespace)
generator.generate(self.fileManager.getPath(),
self.fileManager.getFileName())
self.showInfo('C++ Code Generation',
'C++ code generation is successful.')
else:
self.showWarning(
'C++ Generation',
'Please save the project before code generation.')
# def compileCppAction(self):
# # print('compile cpp action')
# pass
def generatePythonAction(self):
stateList = []
if self.fileManager.hasFile():
self.getStateList(self.rootState, stateList)
if self.config is None:
self.config = RosConfig()
generator = PythonRosGenerator(self.libraries, self.config,
stateList, self.globalNamespace)
generator.generate(self.fileManager.getPath(),
self.fileManager.getFileName())
self.showInfo('Python Code Generation',
'Python code generation is successful.')
else:
self.showWarning(
'Python Generation',
'Please save the project before code generation.')
def aboutAction(self):
aboutDialog = AboutDialog()
aboutDialog.exec_()
def createTreeView(self):
dockWidget = QDockWidget()
dockWidget.setAllowedAreas(Qt.LeftDockWidgetArea)
dockWidget.setFeatures(QDockWidget.NoDockWidgetFeatures)
dockWidget.setTitleBarWidget(QWidget())
self.treeView = QTreeView()
self.treeView.clicked.connect(self.treeItemClicked)
self.treeModel = TreeModel()
self.treeView.setModel(self.treeModel)
self.upButton = QPushButton()
self.upButton.setText('Up')
self.upButton.clicked.connect(self.upButtonClicked)
leftContainer = QWidget()
leftLayout = QVBoxLayout()
leftLayout.addWidget(self.treeView)
leftLayout.addWidget(self.upButton)
leftContainer.setLayout(leftLayout)
dockWidget.setWidget(leftContainer)
self.addDockWidget(Qt.LeftDockWidgetArea, dockWidget)
def createStateCanvas(self):
self.stateCanvas = QGraphicsView()
self.automataScene = AutomataScene()
self.automataScene.setSceneRect(0, 0, 2000, 2000)
self.automataScene.activeStateChanged.connect(self.activeStateChanged)
self.automataScene.activeNamespaceChanged.connect(
self.activeNamespaceChanged)
self.automataScene.stateInserted.connect(self.stateInserted)
self.automataScene.stateRemoved.connect(self.stateRemoved)
self.automataScene.stateImported.connect(self.stateImported)
self.automataScene.transitionInserted.connect(self.transitionInserted)
self.automataScene.stateNameChangedSignal.connect(
self.stateNameChanged)
self.automataScene.setActiveState(self.rootState)
self.setCentralWidget(self.stateCanvas)
self.stateCanvas.setScene(self.automataScene)
self.stateCanvas.setRenderHint(QPainter.Antialiasing)
self.stateCanvas.setAcceptDrops(True)
def stateInserted(self, state):
if self.activeState != self.rootState:
parent = self.treeModel.getByDataId(self.activeState.id)
self.treeModel.insertState(state, QColor(Qt.white), parent)
else:
self.treeModel.insertState(state, QColor(Qt.white))
def stateRemoved(self, state):
if self.activeState != self.rootState:
parent = self.treeModel.getByDataId(self.activeState.id)
self.treeModel.removeState(state.stateData, parent)
else:
self.treeModel.removeState(state.stateData)
def stateImported(self):
self.importAction()
def transitionInserted(self, tran):
# print('transition inserted:' + tran.transitionData.name)
pass
def stateNameChanged(self, state):
dataItem = self.treeModel.getByDataId(state.stateData.id)
if dataItem != None:
dataItem.name = state.stateData.name
self.treeModel.layoutChanged.emit()
def activeStateChanged(self):
if self.automataScene.activeState != self.activeState:
# print('visual states active state changed:' + self.automataScene.activeState.name)
self.activeState = self.automataScene.activeState
if self.activeState == self.rootState:
self.treeView.selectionModel().clearSelection()
else:
self.treeView.setCurrentIndex(
self.treeModel.indexOf(
self.treeModel.getByDataId(self.activeState.id)))
def activeNamespaceChanged(self):
if self.automataScene.activeNamespace != self.activeNamespace:
self.activeNamespace = self.automataScene.activeNamespace
def upButtonClicked(self):
if self.activeState != None:
if self.activeState.parent != None:
#print(self.activeState.parent.id)
self.automataScene.setActiveState(self.activeState.parent)
def getStateById(self, state, id):
if state.id == id:
return state
else:
result = None
for child in state.getChildren():
result = self.getStateById(child, id)
if result is not None:
return result
return result
def treeItemClicked(self, index):
# print('clicked item.id:' + str(index.internalPointer().id))
state = self.getStateById(self.rootState, index.internalPointer().id)
if state is not None:
# set the active state as the loaded state
self.automataScene.setActiveState(state)
def timeStepDurationChanged(self, duration):
if self.activeState is not None:
self.activeState.setTimeStep(duration)
def librariesChanged(self, libraries):
self.libraries = libraries
def globalNamespaceChanged(self):
if self.globalNamespaceDialog:
self.globalNamespace = self.globalNamespaceDialog.getNamespace()
def localNamespaceChanged(self):
if self.localNamespaceDialog:
self.activeNamespace = self.localNamespaceDialog.getNamespace()
def getStateList(self, state, stateList):
if len(state.getChildren()) > 0:
stateList.append(state)
for s in state.getChildren():
self.getStateList(s, stateList)
def __init__(self, *args):
# Invoke parent init
QTreeView.__init__(self, *args)
# Get a reference to the window object
self.win = get_app().window
# Get Model data
self.files_model = FilesModel()
# Keep track of mouse press start position to determine when to start drag
self.setAcceptDrops(True)
self.setDragEnabled(True)
self.setDropIndicatorShown(True)
self.selected = []
# Setup header columns
self.setModel(self.files_model.model)
self.setIconSize(QSize(75, 62))
self.setIndentation(0)
self.setSelectionBehavior(QTreeView.SelectRows)
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.setWordWrap(True)
self.setStyleSheet('QTreeView::item { padding-top: 2px; }')
# Refresh view
self.refresh_view()
# setup filter events
app = get_app()
app.window.filesFilter.textChanged.connect(self.filter_changed)
app.window.actionFilesClear.triggered.connect(self.clear_filter)
self.files_model.model.itemChanged.connect(self.value_updated)
def __init__(self,parent=None):
QWidget.__init__(self,parent)
self.setWindowTitle('View')
dirModel=QDirModel()
lay=QGridLayout(self)
lv=QListView()
lay.addWidget(lv,0,0)
lv.setModel(dirModel)
lvi=QListView()
lay.addWidget(lvi,0,1)
lvi.setViewMode(QListView.IconMode)
lvi.setModel(dirModel)
trv=QTreeView()
lay.addWidget(trv,1,0)
trv.setModel(dirModel)
tav=QTableView()
tav.setModel(dirModel)
lay.addWidget(tav,1,1)
cwdIndex=dirModel.index(QDir.currentPath())
lv.setRootIndex(cwdIndex)
lvi.setRootIndex(cwdIndex)
trv.setRootIndex(cwdIndex)
tav.setRootIndex(cwdIndex)
