class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'PyQt5 file system view - pythonspot.com'
self.left = 10
self.top = 10
self.width = 400
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.hideColumn(1)
self.tree.hideColumn(2)
self.tree.hideColumn(3)
self.tree.setAnimated(True)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(300, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.show()
class DirectoryDockWidget(QWidget):
def __init__(self, directory: Directory, filtered=False, parent=None):
super().__init__(parent)
layout = QVBoxLayout(self)
layout.setContentsMargins(4, 4, 4, 4)
self.setLayout(layout)
self.path_label = QLineEdit()
self.path_label.setReadOnly(True)
layout.addWidget(self.path_label)
self.tree_view = QTreeView()
layout.addWidget(self.tree_view)
self.directory = directory
self.filtered = filtered
self.tree_view.setModel(QFileSystemModel())
for i in range(1, 4):
self.tree_view.hideColumn(i)
self.tree_view.setHeaderHidden(True)
self.directory.changed.connect(self.handle_directory_path_changed)
def handle_directory_path_changed(self, path):
if not path:
return
self.path_label.setText(path)
model = self.tree_view.model()
model.setRootPath(path)
self.tree_view.setRootIndex(model.index(path))
if self.filtered:
model.setNameFilters(plugin.pattern
for plugin in FilePluginRegistry.plugins)
class FileBrowserWidget(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.model = QFileSystemModel()
self.model.setRootPath('')
self.tree = QTreeView()
self.tree.setModel(self.model)
idx = self.model.index(BASE_DIR)
self.tree.setRootIndex(idx)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.hideColumn(2)
self.tree.header().resizeSection(0,200)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
def __initFilesView(self, model: QFileSystemModel):
view = QTreeView()
view.setEditTriggers(QTreeView.NoEditTriggers)
view.hideColumn(1)
view.hideColumn(3)
view.setGeometry(0, 0, 10, 10)
view.setModel(model)
view.setRootIndex(model.index(str(model.rootDirectory())))
return view
def __initFileTreeView(self, model):
treeView = QTreeView()
treeView.setModel(model)
treeView.setRootIndex(model.index(r'C:'))
treeView.hideColumn(1)
treeView.hideColumn(3)
treeView.setAnimated(True)
treeView.setIndentation(20)
treeView.setSortingEnabled(True)
treeView.setMinimumWidth(100)
return treeView
class DirectoryTree(QWidget):
def __init__(self):
super().__init__()
self.title = 'PyQt5 file system view'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
self.model.setRootPath(QDir.rootPath())
self.model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.hideColumn(1)
self.tree.hideColumn(2)
self.tree.hideColumn(3)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
self.fileModel = QFileSystemModel()
self.fileModel.setRootPath(QDir.rootPath())
self.list = QTableView()
self.list.setModel(self.fileModel)
self.list.setShowGrid(False)
self.list.verticalHeader().setVisible(False)
self.list.setSelectionBehavior(QTableView().SelectRows)
self.tree.clicked.connect(self.onClicked)
windowLayout = QHBoxLayout()
windowLayout.addWidget(self.tree)
windowLayout.addWidget(self.list)
self.setLayout(windowLayout)
self.show()
def onClicked(self, index):
path = self.model.fileInfo(index).absoluteFilePath()
self.list.setRootIndex(self.fileModel.setRootPath(path))
def create_tree_view(self, start_path="/home", callback=None):
""" Display the tree view to choose a folder """
file_manager = QTreeView()
self.callback_func = callback
self.model = QFileSystemModel()
self.model.setRootPath(start_path)
# for ViewType in (QColumnView, QTreeView):
file_manager.setModel(self.model)
# hide all columns except the filename
for i in range(1, self.model.columnCount()):
file_manager.hideColumn(i)
file_manager.setRootIndex(self.model.index(start_path))
file_manager.setFixedWidth(self.width)
file_manager.setWordWrap(True)
file_manager.clicked.connect(self.item_clicked)
return {"file_manager": file_manager, "file_model": self.model}
class AddToProject(QDialog):
"""Dialog to let the user choose one of the folders from the opened proj"""
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 _project_changed(self, item, previous):
#FIXME, this is not being called, at least in osx
for each_project in self._projects:
if each_project.name == item.text():
self.load_tree(each_project)
def load_tree(self, project):
"""Load the tree view on the right based on the project selected."""
qfsm = QFileSystemModel()
qfsm.setRootPath(project.path)
load_index = qfsm.index(qfsm.rootPath())
qfsm.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
qfsm.setNameFilterDisables(False)
pext = ["*{0}".format(x) for x in project.extensions]
qfsm.setNameFilters(pext)
self._tree.setModel(qfsm)
self._tree.setRootIndex(load_index)
t_header = self._tree.header()
t_header.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
t_header.setSectionResizeMode(0, QHeaderView.Stretch)
t_header.setStretchLastSection(False)
t_header.setClickable(True)
self._tree.hideColumn(1) # Size
self._tree.hideColumn(2) # Type
self._tree.hideColumn(3) # Modification date
#FIXME: Changing the name column's title requires some magic
#Please look at the project tree
def _select_path(self):
"""Set pathSelected to the folder selected in the tree."""
path = self._tree.model().filePath(self._tree.currentIndex())
if path:
self.pathSelected = path
self.close()
class QLabelWindow(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.window = QWidget(self)
self.imview = QMainGraphicsView(self)
self.imscene = QMainGraphicsScene(self)
self.imview.setScene(self.imscene)
self.openButton = QPushButton("Open")
self.closeButton = QPushButton("Close")
self.treeView = QTreeView(self)
self.fsmodel = QFileSystemModel()
self.statusBar()
self.openButton.clicked.connect(self.openButtonClicked)
self.imscene.textChanged.connect(self.displayText)
hbox = QHBoxLayout()
hbox.addWidget(self.openButton)
hbox.addWidget(self.closeButton)
hbox.addStretch(1)
splitter = QSplitter()
splitter.addWidget(self.treeView)
splitter.addWidget(self.imview)
splitter.setStretchFactor(1, 1)
splitter.setSizes([125, 150])
vbox = QVBoxLayout()
vbox.addLayout(hbox)
vbox.addWidget(splitter)
self.fsmodel.setRootPath(QDir.currentPath())
self.fsmodel.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
self.treeView.setModel(self.fsmodel)
self.treeView.setRootIndex(self.fsmodel.index(QDir.currentPath()))
self.treeView.hideColumn(1)
self.treeView.hideColumn(2)
self.treeView.hideColumn(3)
self.window.setLayout(vbox)
self.setCentralWidget(self.window)
self.setGeometry(300, 300, 300, 220)
self.setWindowTitle('LabelBoost: Tool for ML-supported labelling')
self.setWindowIcon(QIcon('resources/icon.png'))
self.show()
def displayText(self, text):
self.statusBar().showMessage(text)
def openButtonClicked(self):
fname = QFileDialog.getOpenFileName(self, 'Open file',
str(Path.home()))[0]
try:
image = cv2.imread(fname)
cv2.cvtColor(image, cv2.COLOR_BGR2RGB, image)
height, width, channel = image.shape
bytesPerLine = 3 * width
qImg = QPixmap.fromImage(
QImage(image.data, width, height, bytesPerLine,
QImage.Format_RGB888))
self.imview.setSceneRect(QRectF(
qImg.rect())) # Set scene size to image size.
# self.updateViewer()
[self.imscene.removeItem(item) for item in self.imscene.items()]
self.imscene.addPixmap(qImg)
except:
self.statusBar().showMessage("Cannot open {fname}".format(fname))
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'Whenson\'s Custom INI Merger'
self.geo = (200, 200, 800, 600)
self.initGUI()
def initGUI(self):
# windows title and geometry
self.setGeometry(*(self.geo))
self.setWindowTitle(self.title)
self.show()
# master layout and widget definition
self.layout = QHBoxLayout()
self.file_box = QVBoxLayout()
self.list_box = QVBoxLayout()
self.btn_group = QVBoxLayout()
# deploy layout
self.setLayout(self.layout)
self.layout.addLayout(self.file_box)
self.layout.addLayout(self.list_box)
self.layout.addLayout(self.btn_group)
# file box
self.file_box.addWidget(QLabel('File Browser'))
self.folder_tree = QTreeView()
self.file_box.addWidget(self.folder_tree)
self.file_list = QTreeView()
self.file_box.addWidget(self.file_list)
# list box
self.normal_list = DropListWidget()
self.demo_list = DropListWidget()
self.list_box.addWidget(QLabel('Output File'))
self.list_box.addWidget(QLineEdit())
self.list_box.addWidget(QLabel('Module List'))
self.list_box.addWidget(self.normal_list)
temp = QHBoxLayout()
self.up_btn = QPushButton()
self.up_btn.setText('ᐱ')
self.down_btn = QPushButton()
self.down_btn.setText('ᐯ')
self.list_box.addLayout(temp)
temp.addWidget(self.up_btn)
temp.addWidget(self.down_btn)
self.list_box.addWidget(QLabel('With Demostration'))
self.list_box.addWidget(self.demo_list)
# button group
self.merge_btn = QPushButton('Merge')
self.btn_group.addWidget(self.merge_btn)
self.load_btn = QPushButton('Load')
self.btn_group.addWidget(self.load_btn)
self.init_file_tree()
self.init_drag()
def init_file_tree(self):
self.dir_model = QFileSystemModel()
self.dir_model.setRootPath('C:/')
self.dir_model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
self.folder_tree.setModel(self.dir_model)
self.folder_tree.hideColumn(1)
self.folder_tree.hideColumn(2)
self.folder_tree.hideColumn(3)
self.file_model = QFileSystemModel()
self.file_model.setFilter(QDir.NoDotAndDotDot | QDir.Files)
self.file_list.setModel(self.file_model)
self.file_list.setRootIndex(self.file_model.setRootPath('C:/'))
self.file_model.setNameFilters(['*.txt', '*.ini', '*.map'])
self.file_model.setNameFilterDisables(False)
self.folder_tree.clicked.connect(self.tree_on_clicked)
self.file_list.setSelectionMode(QAbstractItemView.ExtendedSelection)
def init_drag(self):
self.file_list.setDragEnabled(True)
self.file_list.setDropIndicatorShown(True)
# self.file_list.setDefaultDropAction(Qt.MoveAction)
def tree_on_clicked(self, index):
path = self.dir_model.fileInfo(index).absoluteFilePath()
self.file_list.setRootIndex(self.file_model.setRootPath(path))
class AddToProject(QDialog):
"""Dialog to let the user choose one of the folders from the opened proj"""
def __init__(self, projects, parent=None):
super(AddToProject, self).__init__(parent)
# projects must be a list
self._projects = projects
self.setWindowTitle(translations.TR_ADD_FILE_TO_PROJECT)
self.path_selected = ''
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.setHeaderHidden(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()
btn_add = QPushButton(translations.TR_ADD_HERE)
btn_cancel = QPushButton(translations.TR_CANCEL)
hbox2.addWidget(btn_cancel)
hbox2.addWidget(btn_add)
vbox.addLayout(hbox2)
btn_add.clicked.connect(self._select_path)
btn_cancel.clicked.connect(self.close)
self._list.currentItemChanged.connect(self._project_changed)
def _project_changed(self, item, previous):
# FIXME, this is not being called, at least in osx
for each_project in self._projects:
if each_project.name == item.text():
self.load_tree(each_project)
def load_tree(self, project):
"""Load the tree view on the right based on the project selected."""
qfsm = QFileSystemModel()
qfsm.setRootPath(project.path)
load_index = qfsm.index(qfsm.rootPath())
qfsm.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
qfsm.setNameFilterDisables(False)
pext = ["*{0}".format(x) for x in project.extensions]
qfsm.setNameFilters(pext)
self._tree.setModel(qfsm)
self._tree.setRootIndex(load_index)
t_header = self._tree.header()
t_header.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
t_header.setSectionResizeMode(0, QHeaderView.Stretch)
t_header.setStretchLastSection(False)
t_header.setSectionsClickable(True)
self._tree.hideColumn(1) # Size
self._tree.hideColumn(2) # Type
self._tree.hideColumn(3) # Modification date
# FIXME: Changing the name column's title requires some magic
# Please look at the project tree
def _select_path(self):
"""Set path_selected to the folder selected in the tree."""
path = self._tree.model().filePath(self._tree.currentIndex())
if path:
self.path_selected = path
self.close()
class PinStatusWidget(GalacteekTab):
COL_TS = 0
COL_QUEUE = 1
COL_PATH = 2
COL_STATUS = 3
COL_PROGRESS = 4
COL_CTRL = 5
def __init__(self, gWindow, **kw):
super(PinStatusWidget, self).__init__(gWindow, **kw)
self.tree = QTreeView()
self.tree.setObjectName('pinStatusWidget')
self.boxLayout = QVBoxLayout()
self.boxLayout.addWidget(self.tree)
self.ctrlLayout = QHBoxLayout()
self.btnPin = QPushButton(iPin())
self.pathLabel = QLabel(iCidOrPath())
self.pathEdit = QLineEdit()
self.ctrlLayout.addWidget(self.pathLabel)
self.ctrlLayout.addWidget(self.pathEdit)
self.ctrlLayout.addWidget(self.btnPin)
self.vLayout.addLayout(self.ctrlLayout)
self.vLayout.addLayout(self.boxLayout)
self.app.ipfsCtx.pinItemStatusChanged.connect(self.onPinStatusChanged)
self.app.ipfsCtx.pinFinished.connect(self.onPinFinished)
self.app.ipfsCtx.pinItemRemoved.connect(self.onItemRemoved)
self.pathEdit.returnPressed.connect(self.onPathEntered)
self.btnPin.clicked.connect(self.onPathEntered)
self.model = QStandardItemModel()
self.model.setHorizontalHeaderLabels(
['TS', iQueue(),
iPath(),
iStatus(),
iNodesProcessed(), ''])
self.tree.setSortingEnabled(True)
self.tree.setModel(self.model)
self.tree.sortByColumn(self.COL_TS, Qt.DescendingOrder)
for col in [self.COL_QUEUE, self.COL_PATH, self.COL_PROGRESS]:
self.tree.header().setSectionResizeMode(
col, QHeaderView.ResizeToContents)
self.tree.hideColumn(self.COL_TS)
def resort(self):
self.model.sort(self.COL_TS, Qt.DescendingOrder)
def onPathEntered(self):
text = self.pathEdit.text()
self.pathEdit.clear()
path = IPFSPath(text)
if path.valid:
ensure(self.app.ipfsCtx.pinner.queue(path.objPath, True, None))
else:
messageBox(iInvalidInput())
def removeItem(self, path):
modelSearch(self.model,
search=path,
columns=[self.COL_PATH],
delete=True)
def onItemRemoved(self, qname, path):
self.removeItem(path)
def getIndexFromPath(self, path):
idxList = self.model.match(self.model.index(0, self.COL_PATH),
PinObjectPathRole, path, 1,
Qt.MatchFixedString | Qt.MatchWrap)
if len(idxList) > 0:
return idxList.pop()
def findPinItems(self, path):
idx = self.getIndexFromPath(path)
if not idx:
return None
itemP = self.model.itemFromIndex(idx)
if not itemP:
return None
idxQueue = self.model.index(itemP.row(), self.COL_QUEUE,
itemP.index().parent())
idxProgress = self.model.index(itemP.row(), self.COL_PROGRESS,
itemP.index().parent())
idxStatus = self.model.index(itemP.row(), self.COL_STATUS,
itemP.index().parent())
idxC = self.model.index(itemP.row(), self.COL_CTRL,
itemP.index().parent())
cancelButton = self.tree.indexWidget(idxC)
return {
'itemPath': itemP,
'itemQname': self.model.itemFromIndex(idxQueue),
'itemProgress': self.model.itemFromIndex(idxProgress),
'itemStatus': self.model.itemFromIndex(idxStatus),
'cancelButton': cancelButton
}
def updatePinStatus(self, path, status, progress):
idx = self.getIndexFromPath(path)
if not idx:
return
try:
itemPath = self.model.itemFromIndex(idx)
if itemPath and time.time() - itemPath.lastProgressUpdate < 5:
return
itemProgress = self.model.itemFromIndex(
self.model.index(idx.row(), self.COL_PROGRESS, idx.parent()))
itemStatus = self.model.itemFromIndex(
self.model.index(idx.row(), self.COL_STATUS, idx.parent()))
itemStatus.setText(status)
itemProgress.setText(progress)
itemPath.lastProgressUpdate = time.time()
except:
pass
def onPinFinished(self, path):
items = self.findPinItems(path)
if items:
items['itemStatus'].setText(iPinned())
items['itemProgress'].setText('OK')
color1 = QBrush(QColor('#4a9ea1'))
color2 = QBrush(QColor('#66a56e'))
for item in [
items['itemQname'], items['itemPath'], items['itemStatus'],
items['itemProgress']
]:
item.setBackground(color1)
for item in [items['itemStatus'], items['itemProgress']]:
item.setBackground(color2)
if items['cancelButton']:
items['cancelButton'].setEnabled(False)
self.resort()
self.purgeFinishedItems()
def purgeFinishedItems(self):
maxFinished = 16
ret = modelSearch(self.model,
search=iPinned(),
columns=[self.COL_STATUS])
if len(ret) > maxFinished:
rows = []
for idx in ret:
item = self.model.itemFromIndex(idx)
if not item:
continue
rows.append(item.row())
try:
for row in list(sorted(rows))[int(maxFinished / 2):]:
self.model.removeRow(row)
except:
pass
async def onCancel(self, qname, path, *a):
self.removeItem(path)
await self.app.ipfsCtx.pinner.cancel(qname, path)
def onPinStatusChanged(self, qname, path, statusInfo):
nodesProcessed = statusInfo['status'].get('Progress', iUnknown())
idx = self.getIndexFromPath(path)
if not idx:
# Register it
btnCancel = QToolButton()
btnCancel.setIcon(getIcon('cancel.png'))
btnCancel.setText(iCancel())
btnCancel.clicked.connect(partialEnsure(self.onCancel, qname,
path))
btnCancel.setFixedWidth(140)
displayPath = path
if len(displayPath) > 64:
displayPath = displayPath[0:64] + ' ..'
itemTs = UneditableItem(str(statusInfo['ts_queued']))
itemQ = UneditableItem(qname)
itemP = UneditableItem(displayPath)
itemP.setData(path, PinObjectPathRole)
itemP.setToolTip(path)
itemP.lastProgressUpdate = time.time()
itemStatus = UneditableItem(iPinning())
itemProgress = UneditableItem(str(nodesProcessed))
itemC = UneditableItem('')
self.model.invisibleRootItem().appendRow(
[itemTs, itemQ, itemP, itemStatus, itemProgress, itemC])
idx = self.model.indexFromItem(itemC)
self.tree.setIndexWidget(idx, btnCancel)
self.resort()
else:
self.updatePinStatus(path, iPinning(), str(nodesProcessed))
class ViewerWindow(QWidget):
statusWindow: QLabel = None
bottomStatus: QLabel = None
fsDirModel: QFileSystemModel = None
fsFileModel: QFileSystemModel = None
fsTree: QTreeView = None
fsList: QListView = None
def makeTop(self):
topBox = QHBoxLayout()
self.statusWidget = QLabel('')
self.statusWidget.setMinimumHeight(1)
self.statusWidget.setMaximumHeight(1)
self.statusWidget.setStyleSheet(
"QLabel { background-color : lightgray; color : black; }")
topBox.addWidget(self.statusWidget)
return topBox
@pyqtSlot(QModelIndex)
def onDirChange(self, index):
mPath = self.fsDirModel.fileInfo(index).absoluteFilePath()
self.fsList.setRootIndex(self.fsFileModel.setRootPath(mPath))
print("Dir=%s", mPath)
def makeExplorer(self, under):
self.fsDirModel = QFileSystemModel()
self.fsDirModel.setFilter(QDir.Dirs | QDir.Drives | QDir.NoDotAndDotDot
| QDir.AllDirs)
self.fsDirModel.setRootPath("")
self.fsTree = QTreeView()
self.fsTree.setModel(self.fsDirModel)
self.fsTree.clicked.connect(self.onDirChange)
self.fsTree.hideColumn(1)
self.fsTree.hideColumn(2)
self.fsTree.hideColumn(3)
self.fsTree.hideColumn(4)
self.fsTree.setStyleSheet(
"QLabel { background-color : green; color : blue; }")
return self.fsTree
def makeFiles(self, under):
self.fsFileModel = QFileSystemModel()
self.fsFileModel.setFilter(QDir.NoDotAndDotDot | QDir.Files)
self.fsFileModel.setRootPath("")
self.fsList = QListView()
self.fsList.setModel(self.fsFileModel)
self.fsList.setStyleSheet(
"QLabel { background-color : lightblue; color : blue; }")
return self.fsList
def makeDisplay(selfself, under):
displayWidget = QLabel("Display")
displayWidget.setAlignment(QtCore.Qt.AlignCenter)
displayWidget.setStyleSheet(
"QLabel { background-color : pink; color : blue; }")
return displayWidget
def makeMiddle(self):
middleBox = QHBoxLayout()
explorerWidget = self.makeExplorer(middleBox)
explorerWidget.setMinimumHeight(300)
explorerWidget.setMinimumWidth(300)
explorerWidget.setMaximumWidth(400)
explorerWidget.setMaximumHeight(20000)
filesWidget = self.makeFiles(middleBox)
filesWidget.setMinimumHeight(300)
filesWidget.setMinimumWidth(300)
filesWidget.setMaximumWidth(400)
filesWidget.setMaximumHeight(20000)
displayWidget = self.makeDisplay(middleBox)
displayWidget.setMinimumHeight(300)
displayWidget.setMinimumWidth(300)
displayWidget.setMaximumHeight(20000)
middleBox.addWidget(explorerWidget)
middleBox.addWidget(filesWidget)
middleBox.addWidget(displayWidget)
return middleBox
@pyqtSlot()
def okOK(self):
print("Clicked")
def makeBottom(self):
bottomBox = QHBoxLayout()
self.bottomStatus = QLabel("Status")
self.bottomStatus.setMaximumHeight(20)
self.bottomStatus.setMinimumHeight(20)
self.bottomStatus.setStyleSheet(
"QLabel { background-color : lightgray; color : black; }")
bottomBox.addWidget(self.bottomStatus)
bottomOK = QPushButton("Quit", self)
bottomOK.setMaximumWidth(80)
bottomOK.setToolTip("Quit Application")
bottomOK.clicked.connect(self.okOK)
bottomBox.addWidget(bottomOK)
return bottomBox
def __init__(self):
super().__init__()
vbox = QVBoxLayout()
vbox.addLayout(self.makeTop())
vbox.addLayout(self.makeMiddle())
vbox.addLayout(self.makeBottom())
self.setLayout(vbox)
self.setWindowTitle("QtText")
self.setGeometry(200, 200, 800, 600)
class VGExplorer(QWidget):
def __init__(self, app, config):
super().__init__()
self.clipboard = app.clipboard()
self.config = config
self.setWindowTitle(config.server_name)
rootPath = self.get_cwd()
self.model = QFileSystemModel()
index = self.model.setRootPath(rootPath)
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setRootIndex(index)
self.tree.setAnimated(False)
self.tree.setIndentation(20)
self.tree.hideColumn(1)
self.tree.hideColumn(2)
self.tree.hideColumn(3)
self.tree.setHeaderHidden(True)
self.tree.doubleClicked.connect(self.on_double_click)
self.tree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.tree.customContextMenuRequested.connect(self.show_menu)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
# Shortcut for hide
self.shortcut = QShortcut(QKeySequence(config.toggle_key), self)
self.shortcut.activated.connect(self.hide)
if not config.hidden:
self.show()
def toggle_show(self):
if self.isHidden():
self.show()
else:
self.hide()
def open_file(self, index):
path = self.sender().model().filePath(index)
if os.path.isfile(path):
subprocess.call([
self.config.vim, "--servername", self.config.server_name,
"--remote", path
])
def get_cwd(self):
path = subprocess.check_output([
self.config.vim, "--servername", self.config.server_name,
"--remote-expr", "getcwd()"
])
return path.decode("utf-8").strip()
def on_double_click(self, index):
self.open_file(index)
def show_menu(self, clickPos):
index = self.tree.indexAt(clickPos)
selected_path = self.tree.model().filePath(index)
enclosing_dir = self.find_enclosing_dir(selected_path)
menu = QMenu(self)
openAction = menu.addAction("Open")
newFolderAction = menu.addAction("New Folder")
newFileAction = menu.addAction("New File")
copyAction = menu.addAction("Copy")
pasteAction = menu.addAction("Paste")
renameAction = menu.addAction("Rename")
fileInfo = menu.addAction("Properties")
menuPos = QPoint(clickPos.x() + 15, clickPos.y() + 15)
action = menu.exec_(self.mapToGlobal(menuPos))
if action == openAction:
self.open_file(index)
elif action == newFolderAction:
path = self.get_dialog_str("New Folder",
"Enter name for new folder:")
if path:
self.mkdir(os.path.join(enclosing_dir, path))
elif action == newFileAction:
path = self.get_dialog_str("New File", "Enter name for new file:")
if path:
self.touch(os.path.join(enclosing_dir, path))
elif action == renameAction:
path = self.get_dialog_str("Rename File", "Enter new name:")
# Naive validation
if "/" in path:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Filename cannot contain '/'")
msg.setWindowTitle("Error")
msg.exec_()
return
new_path = os.path.join(enclosing_dir, path)
self.move(selected_path, new_path)
elif action == copyAction:
mime_data = QMimeData()
# TODO: support multiple selections
mime_data.setUrls([QUrl(Path(selected_path).as_uri())])
self.clipboard.setMimeData(mime_data)
elif action == pasteAction:
mime_data = self.clipboard.mimeData()
if not mime_data:
return
if mime_data.hasUrls():
for src_url in mime_data.urls():
self.copy(src_url.path(), enclosing_dir)
def get_dialog_str(self, title, message):
text, confirm = QInputDialog.getText(self, title, message,
QLineEdit.Normal, "")
if confirm and text != '':
return text
return None
'''
Filesystem and OS Functions
'''
def copy(self, src_file, dest_dir):
src_basename = os.path.basename(src_file)
dest_file = os.path.join(dest_dir, src_basename)
# First confirm file doesn't already exist
if os.path.exists(dest_file):
print(f"Destination path '{dest_file}' already exists, skipping")
return
print(f"Pasting {src_file} -> {dest_file}")
shutil.copy2(src_file, dest_file)
def move(self, old_path, new_path):
os.rename(old_path, new_path)
def mkdir(self, path):
if not os.path.exists(path):
os.mkdir(path)
def touch(self, path):
subprocess.run(["touch", path])
def find_enclosing_dir(self, path):
'''
If path is file, return dir it is in
If path is dir, return itself
'''
if os.path.isdir(path):
return path
if os.path.isfile(path):
return str(Path(path).parent)
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
### Main window ###
MainWindow.setObjectName("MainWindow")
MainWindow.resize(700, 490)
MainWindow.setStyleSheet(style_background)
self.centralwidget = QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
### List widget ###
'''
# List for audio files
self.list_audio = QListWidget(self.centralwidget)
self.list_audio.setGeometry(QRect(30, 60, 300, 351))
self.list_audio.setFont(font_content)
self.list_audio.setStyleSheet(style_list)
self.list_audio.setObjectName("list_audio")
self.list_audio.verticalScrollBar().setStyleSheet(style_slidebar)
'''
# List for locations
self.list_location = QListWidget(self.centralwidget)
self.list_location.setGeometry(QRect(370, 60, 300, 120))
self.list_location.setStyleSheet(style_list)
self.list_location.setObjectName("list_location")
self.list_location.verticalScrollBar().setStyleSheet(style_slidebar)
# List for sound source
self.list_soundsource = QListWidget(self.centralwidget)
self.list_soundsource.setGeometry(QRect(370, 215, 300, 130))
self.list_soundsource.setStyleSheet(style_list)
self.list_soundsource.setObjectName("list_soundsource")
self.list_soundsource.verticalScrollBar().setStyleSheet(style_slidebar)
### Label ###
# Title for audio list
self.label_audio = QLabel(self.centralwidget)
self.label_audio.setGeometry(QRect(30, 20, 300, 40))
self.label_audio.setFont(font_title)
self.label_audio.setObjectName("label_audio")
# Title for location list
self.label_location = QLabel(self.centralwidget)
self.label_location.setGeometry(QRect(370, 20, 300, 40))
self.label_location.setFont(font_title)
self.label_location.setObjectName("label_location")
# Title for sound source list
self.label_soundsource = QLabel(self.centralwidget)
self.label_soundsource.setGeometry(QRect(370, 190, 300, 30))
self.label_soundsource.setFont(font_title)
self.label_soundsource.setObjectName("label_soundsource")
# Title for root path
self.label_root = QLabel(self.centralwidget)
self.label_root.setGeometry(QRect(30, 428, 80, 40))
self.label_root.setFont(font_title)
self.label_root.setObjectName("label_root")
# Title for description
self.label_description = QLabel(self.centralwidget)
self.label_description.setGeometry(QRect(370, 350, 300, 40))
self.label_description.setFont(font_title)
self.label_description.setObjectName("label_description")
# Title for timestamp
self.label_timestamp = QLabel(self.centralwidget)
self.label_timestamp.setGeometry(QRect(370, 380, 300, 40))
self.label_timestamp.setFont(font_title)
self.label_timestamp.setObjectName("label_timestamp")
### Button ###
# Button for saving labels
self.btn_save = QPushButton(self.centralwidget)
self.btn_save.setGeometry(QRect(600, 430, 70, 34))
self.btn_save.setStyleSheet(style_btn_pressed)
self.btn_save.setFont(font_content)
self.btn_save.setObjectName("btn_save")
# Button for loading files
self.btn_load = QPushButton(self.centralwidget)
self.btn_load.setGeometry(QRect(520, 430, 70, 34))
self.btn_load.setStyleSheet(style_btn_pressed)
self.btn_load.setFont(font_content)
self.btn_load.setObjectName("btn_load")
### ComboBox ###
self.combo_location = QComboBox(self.centralwidget)
self.combo_location.setGeometry(QRect(450, 29, 220, 24))
self.combo_location.setStyleSheet(style_combobox)
### TextBox ###
self.textbox_root = QLineEdit(self.centralwidget)
self.textbox_root.setGeometry(QRect(110, 432, 360, 30))
self.textbox_root.setStyleSheet(style_blank + style_round_box)
self.textbox_description = QLineEdit(self.centralwidget)
self.textbox_description.setGeometry(QRect(460, 358, 210, 24))
self.textbox_description.setStyleSheet(style_blank + style_round_box)
self.textbox_timestamp = QLineEdit(self.centralwidget)
self.textbox_timestamp.setGeometry(QRect(460, 388, 210, 24))
self.textbox_timestamp.setStyleSheet(style_blank + style_round_box)
### SpinBox ###
'''
self.spinBox = QSpinBox(self.centralwidget)
self.spinBox.setGeometry(QRect(470, 40, 43, 26))
self.spinBox.setObjectName("spinBox")
self.spinBox_2 = QSpinBox(self.centralwidget)
self.spinBox_2.setGeometry(QRect(530, 40, 43, 26))
self.spinBox_2.setObjectName("spinBox_2")
self.label_4 = QLabel(self.centralwidget)
self.label_4.setGeometry(QRect(518, 30, 30, 40))
self.label_4.setFont(font_title)
self.label_4.setObjectName("label_4")
self.spinBox_2.raise_()
self.spinBox.raise_()
'''
### List Dir/file with TreeView ###
self.model_dataset = QFileSystemModel()
#self.model.setRootPath(dir_path)
self.tree_dataset = QTreeView(self.centralwidget)
self.tree_dataset.setModel(self.model_dataset)
#self.tree.setRootIndex(self.model.index(dir_path))
self.tree_dataset.hideColumn(1)
self.tree_dataset.hideColumn(2)
self.tree_dataset.hideColumn(3)
self.tree_dataset.setGeometry(QRect(30, 60, 300, 351))
self.tree_dataset.setStyleSheet(style_list)
self.tree_dataset.verticalScrollBar().setStyleSheet(style_slidebar)
MainWindow.setCentralWidget(self.centralwidget)
self.retranslateUi(MainWindow)
QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QCoreApplication.translate
MainWindow.setWindowTitle(
_translate("MainWindow", "Data Labeling Tool"))
#__sortingEnabled = self.list_audio.isSortingEnabled()
#self.list_audio.setSortingEnabled(False)
#self.list_audio.setSortingEnabled(__sortingEnabled)
__sortingEnabled = self.list_location.isSortingEnabled()
self.list_location.setSortingEnabled(False)
self.list_location.setSortingEnabled(__sortingEnabled)
__sortingEnabled = self.list_soundsource.isSortingEnabled()
self.list_soundsource.setSortingEnabled(False)
self.list_soundsource.setSortingEnabled(__sortingEnabled)
self.label_audio.setText(_translate("MainWindow", "Audio Files"))
self.label_location.setText(_translate("MainWindow", "Location"))
self.label_soundsource.setText(_translate("MainWindow",
"Sound Source"))
self.label_root.setText(_translate("MainWindow", "Root Path"))
self.label_description.setText(_translate("MainWindow", "Description"))
self.label_timestamp.setText(_translate("MainWindow", "Timestamp"))
#self.label_4.setText(_translate("MainWindow", ":"))
self.btn_save.setText(_translate("MainWindow", "Save"))
self.btn_load.setText(_translate("MainWindow", "Load"))
class EditorTextosDlg(QWidget):
def __init__(self):
super().__init__()
self.fileName = ["Editor de texto", ".txt"]
self.initUI()
def initUI(self):
# Sección de seleccionar carpeta
folderSectionTitle = QLabel("Carpeta")
self.fileFolder = QLineEdit() # Línea donde está la carpeta
self.fileFolder.setReadOnly(
True
) # Hacemos que solo muestre el path y no podamos escribir en ella
self.selectButton = QPushButton("Seleccionar") # Botón de la sección
# Sección de listado de directorios y archivos
filesSectionTitle = QLabel("Archivos") # Título de la sección
self.fileTree = QTreeView() # Crea una vista en forma de árbol
self.fileSystemModel = QFileSystemModel(
self.fileTree) # Construye un modelo de los archivos del sistema
self.fileSystemModel.setReadOnly(
True) # Hacemos que solo sea de modo lectura
modelRoot = self.fileSystemModel.setRootPath(
"/home"
) # /home será el directorio que se mostrará por defecto cuando iniciemos la app
self.fileTree.setModel(
self.fileSystemModel
) # Seteamos el modelo que creamos como modelo de nuestra vista en forma de árbol
self.fileTree.setRootIndex(
modelRoot
) # Seteamos el directorio por defecto que establecimos anteriormente (/home)
self.fileTree.hideColumn(1) # Escondemos el tamaño
self.fileTree.hideColumn(2) # Escondemos el tipo de archivo
self.fileTree.hideColumn(
3) # Escondemos la fecha de modificación del archivo
self.fileTree.setHeaderHidden(
True) # Escondemos la cabecera de la sección
# Sección de texto
self.textEdit = QTextEdit(
) # Cuadro de texto donde podremos escribir para modificar y guardar archivos
# Sección de botones
self.saveButton = QPushButton("Guardar") # Botón de guardar
self.saveAsButton = QPushButton(
"Guardar como") # Botón de guardar como
# Creamos un diseño horizontal donde añadiremos los componentes de la sección de carpeta
hbox = QHBoxLayout()
hbox.addWidget(folderSectionTitle)
hbox.addWidget(self.fileFolder)
hbox.addWidget(self.selectButton)
# Creamos un diseño vertical donde añadimos el horizontal que hemos creado previamente
vbox = QVBoxLayout()
vbox.setSpacing(30)
vbox.addLayout(hbox)
# Creamos una cuadrícula donde añadiremos los componentes de la sección de archivo especificando sus coordenadas
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(filesSectionTitle, 0, 0)
grid.addWidget(self.fileTree, 1, 0, 1, 3)
grid.addWidget(self.textEdit, 1, 3, 1, 5)
# Añadimos el diseño de cuadricula de archivos al diseño vertical
vbox.addLayout(grid)
# Creamos un diseño horizontal donde añadiremos los componentes de la sección de botones
# Añadimos margen después de los botones para que estén pegados a la esquina inferior izquierda
self.buttomsLayout = QHBoxLayout()
self.buttomsLayout.addWidget(self.saveButton)
self.buttomsLayout.addWidget(self.saveAsButton)
self.buttomsLayout.addStretch()
# Añadimos el diseño de botones al diseño vertical
vbox.addLayout(self.buttomsLayout)
self.setLayout(
vbox) # Establecemos el diseño vertical como diseño principal
self.setWindowTitle("Editor de texto") # Título de la ventana
self.setGeometry(
300, 150, 1000,
700) # Establecemos el tamaño y posicionamiento de la ventana
self.show() # Mostramos la ventana
# Conectamos los botones a diferentes métodos
self.selectButton.clicked.connect(
self.openFolders) # Dispara el método de abrir carpeta
self.fileTree.doubleClicked.connect(
self.doubleClickedTreeView
) # Dispara el método de desplegar carpeta en la sección de archivos
self.saveButton.clicked.connect(
self.saveFiles) # Dispara el método de guardar archivo
self.saveAsButton.clicked.connect(
self.saveAsFiles) # Dispara el método de guardar como
def openFolders(self): # Método de abrir carpeta
directory = controller.openFolder(
self
) # Dispara el método de seleccionar carpeta, el cual abre una ventana emergente
modelRoot = self.fileSystemModel.setRootPath(
directory) # Establece la raiz el árbol en la carpeta seleccionada
self.fileTree.setRootIndex(
modelRoot) # Muestra esta carpeta en la sección de archivos
self.fileFolder.setText(
directory
) # Muestra el path de la carpeta en la sección de carpeta
def doubleClickedTreeView(self, index): # Método de desplegar carpeta
filedata = controller.doubleClickedTreeView(
self, index
) # Dispara el método de doble click en la sección de archivos
self.textEdit.setText(
filedata) # Muestra el contenido en el cuadro de texto
def saveFiles(self): # Método de guardar archivo
controller.saveFile(self) # Dispara el método de guardar archivo
def saveAsFiles(self): # Método de guardar como
controller.saveAsFile(self) # Dispara el método de guardar como
def closeEvent(
self,
event): # Método que se despliega cuando se intenta cerrar la app
reply = QMessageBox.question(self, "Confirmación",
"¿Deseas cerrar la app?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if reply == QMessageBox.Yes:
event.accept() # Cerramos la app
else:
event.ignore() # No cerramos la app (ignoramos la señal de cerrar)
class App(QWidget):
FROM, TO, DATE, SUBJECT, MESSAGE = range(5)
def __init__(self,
mails_lst=[],
my_mail="",
send=None,
receive=None,
labels=None):
super().__init__()
# self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.sendClass = send
self.receiveClass = receive
self.labelsClass = labels
self.mails_lst = mails_lst
self.mails = mails_lst[1]
self.my_mail = my_mail
self.labels = ["All", "Inbox", "Sent", "Trash"]
self.title = 'SMTP Email Client'
self.left = 0
self.top = 0
self.width = 1024
self.height = 600
self.total_cols = 5
self.ret_val = False
self.is_first_ret_val = True
self.is_reload_mails = False
self.messages_file = 'messages.data'
self.initUI()
def toolbarButtonClick(self, i):
def buttonClick():
if self.send_button.isChecked():
self.send_button.setChecked(False)
self.sendMenuToggleClick(False)
# for l in self.label_buttons:
# print(l.isChecked())
if self.label_buttons[i].isChecked():
# if self.is_reload_mails:
# self.reloadMails()
# print("mails reloaded")
# self.is_reload_mails = False
print(f"displaying label category '{self.labels[i]}'")
for index, label_button in enumerate(self.label_buttons):
if index != i:
label_button.setChecked(False)
self.mails = self.mails_lst[i]
self.reloadMails()
else:
self.label_buttons[i].setChecked(True)
return buttonClick
def parallelReloading(self):
temp_mails_lst = []
for label in self.labelsClass:
temp_mails_lst.append(
self.receiveClass.get_message(category=label))
index = [label.isChecked() for label in self.label_buttons].index(True)
self.mails_lst = temp_mails_lst
self.mails = temp_mails_lst[index]
write_to_file(self.messages_file, self.mails_lst)
self.is_reload_mails = True
def parallelSending(self, to_addr, subj, msg):
self.sendClass.send_message(to_addr, subj, msg)
def reloadButtonClick(self, s):
if self.receiveClass:
if self.is_first_ret_val:
print("reloading all mails")
self.ret_val = threading.Thread(target=self.parallelReloading,
args=())
self.ret_val.start()
self.is_first_ret_val = False
elif not self.ret_val.isAlive():
print("reloading all mails")
self.ret_val = threading.Thread(target=self.parallelReloading,
args=())
self.ret_val.start()
else:
print("reloading already taking place in background")
else:
print("unable to reload as 'receiveClass' missing")
self.reload_button.setChecked(False)
def sendMenuToggleClick(self, s):
if s:
self.toBox.setFixedWidth(self.contentView.width())
self.contentView.hide()
self.toBox.show()
self.subjectBox.show()
self.messageBox.show()
self.sendButtonBox.show()
else:
self.toBox.hide()
self.subjectBox.hide()
self.messageBox.hide()
self.sendButtonBox.hide()
self.contentView.show()
def logoutButtonClick(self, s):
print("loging out and closing app")
sys.exit()
def rowSelectionClick(self):
if self.send_button.isChecked():
self.send_button.setChecked(False)
self.sendMenuToggleClick(False)
self.dataView.showColumn(1)
self.dataView.showColumn(4)
item = self.dataView.selectedIndexes()
lst = []
for i in range(self.total_cols):
text = item[i].model().itemFromIndex(item[i]).text()
if i == 0 or i == 1:
text = text.split()
lst.append(text)
self.dataView.hideColumn(1)
self.dataView.hideColumn(4)
msg = self.htmlString(lst)
self.contentView.setPlainText("")
self.contentView.textCursor().insertHtml(msg)
def sendButtonClick(self):
if self.sendClass:
self.reloadButtonClick(True)
# to_addr = re.split(r'[, ]', self.toBox.text())
to_addr = re.findall(r'[\w\.-]+@[\w\.-]+', self.toBox.text())
subj = self.subjectBox.text()
msg = self.messageBox.toPlainText()
send_ret_val = threading.Thread(target=self.parallelSending,
args=(to_addr, subj, msg))
send_ret_val.start()
else:
print("unable to send as 'sendClass' missing")
self.toBox.setText("")
self.subjectBox.setText("")
self.messageBox.setPlainText("")
self.sendMenuToggleClick(False)
self.send_button.setChecked(False)
def initUI(self):
# windows title and geometry set
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.globalLayout = QVBoxLayout()
menuLayout = QHBoxLayout()
dataLayout = QHBoxLayout()
labelLayout = QToolBar("Labels")
self.label_buttons = [QAction(label, self) for label in self.labels]
# button_action.setStatusTip("This is your button")
for i, label_button in enumerate(self.label_buttons):
label_button.triggered.connect(self.toolbarButtonClick(i))
labelLayout.addAction(label_button)
label_button.setCheckable(True)
# labelLayout.addAction(label_button)
self.label_buttons[1].setChecked(True)
optionLayout = QToolBar("Options")
self.send_button = QAction(QIcon("images/icons8-email-60.png"),
"Send Mail", self)
self.reload_button = QAction(QIcon("images/icons8-reset-60.png"),
"Reload Page", self)
logout_button = QAction(QIcon("images/icons8-shutdown-60.png"),
"Logout", self)
self.send_button.triggered.connect(self.sendMenuToggleClick)
self.reload_button.triggered.connect(self.reloadButtonClick)
logout_button.triggered.connect(self.logoutButtonClick)
optionLayout.addAction(self.send_button)
optionLayout.addAction(self.reload_button)
optionLayout.addAction(logout_button)
self.send_button.setCheckable(True)
self.reload_button.setCheckable(True)
logout_button.setCheckable(True)
# w1.setContentsMargins(0, 0, 0, 0)
# w2.setContentsMargins(0, 0, 0, 0)
# menuLayout.setSpacing(0)
menuLayout.setContentsMargins(0, 0, 0, 0)
optionLayout.setFixedWidth(106)
menuLayout.addWidget(labelLayout, 10)
menuLayout.addWidget(QLabel(self.my_mail), 1)
menuLayout.addWidget(optionLayout)
# dataview with non editable columns (from, date, subject etc)
self.dataView = QTreeView()
self.dataView.setRootIsDecorated(False)
self.dataView.setAlternatingRowColors(True)
self.dataView.setEditTriggers(QAbstractItemView.NoEditTriggers)
# content view to display complete email message
self.contentView = QPlainTextEdit()
self.contentView.setReadOnly(True)
self.sendLayout = QVBoxLayout()
self.toBox = QLineEdit()
self.subjectBox = QLineEdit()
self.messageBox = QPlainTextEdit()
self.sendButtonBox = QPushButton("Send")
self.toBox.setPlaceholderText("To")
self.subjectBox.setPlaceholderText("Subject")
self.messageBox.setPlaceholderText("Message")
self.sendLayout.addWidget(self.toBox)
self.sendLayout.addWidget(self.subjectBox)
self.sendLayout.addWidget(self.messageBox)
self.sendLayout.addWidget(self.sendButtonBox)
self.sendLayout.setSpacing(0)
self.sendLayout.setContentsMargins(0, 0, 0, 0)
# set layout of columns and content box horizontally
dataLayout.addWidget(self.dataView, 3)
dataLayout.addWidget(self.contentView, 2)
dataLayout.addLayout(self.sendLayout)
self.contentView.show()
self.toBox.hide()
self.subjectBox.hide()
self.messageBox.hide()
self.sendButtonBox.hide()
self.sendButtonBox.clicked.connect(self.sendButtonClick)
# create mail model to add to data view
self.model = self.createMailModel(self)
self.dataView.setModel(self.model)
self.dataView.clicked.connect(self.rowSelectionClick)
self.globalLayout.addLayout(menuLayout, 1)
self.globalLayout.addLayout(dataLayout, 20)
self.setLayout(self.globalLayout)
self.addAllMails()
self.autoColumnWidths()
self.show()
self.reloadButtonClick(True)
def reloadMails(self):
# self.mails = mails
self.model.removeRows(0, self.model.rowCount())
self.addAllMails()
self.autoColumnWidths()
# set headers text for the created model
def createMailModel(self, parent):
model = QStandardItemModel(0, self.total_cols, parent)
model.setHeaderData(self.FROM, Qt.Horizontal, "From")
model.setHeaderData(self.TO, Qt.Horizontal, "To")
model.setHeaderData(self.DATE, Qt.Horizontal, "Date")
model.setHeaderData(self.SUBJECT, Qt.Horizontal, "Subject")
model.setHeaderData(self.MESSAGE, Qt.Horizontal, "Message")
return model
# add content of mail to data view
def addAllMails(self):
today = date.today()
today_date = today.strftime('%a, %d %b %Y')
for mail in self.mails:
if today_date == mail[2]:
date_temp = mail[3]
else:
date_temp = mail[2]
self.addMail(self.model, mail[0], mail[1], date_temp, mail[4],
mail[5])
if self.mails:
# msg = self.htmlString(
# [self.mails[-1][0], self.mails[-1][1], self.mails[-1][4], self.mails[-1][5]])
msg = self.htmlString(self.mails[-1])
self.contentView.setPlainText("")
self.contentView.textCursor().insertHtml(msg)
def addMail(self, model, mailFrom, mailTo, date, subject, message):
model.insertRow(0)
mailFrom = ' '.join(map(str, mailFrom))
mailTo = ' '.join(map(str, mailTo))
model.setData(model.index(0, self.FROM), mailFrom)
model.setData(model.index(0, self.TO), mailTo)
model.setData(model.index(0, self.DATE), date)
model.setData(model.index(0, self.SUBJECT), subject)
model.setData(model.index(0, self.MESSAGE), message)
def autoColumnWidths(self):
width_plus = 30
self.dataView.setColumnWidth(1, 0)
self.dataView.setColumnWidth(4, 0)
for i in range(self.total_cols):
self.dataView.resizeColumnToContents(i)
width = self.dataView.columnWidth(i)
self.dataView.setColumnWidth(i, width + width_plus)
self.dataView.hideColumn(1)
self.dataView.hideColumn(4)
def htmlString(self, lst):
fr_addr = "<b>From</b><br>"
for l in lst[0]:
fr_addr += f"{l}<br>"
fr_addr += "<br>"
to_addr = "<b>To</b><br>"
for l in lst[1]:
to_addr += f"{l}<br>"
to_addr += "<br>"
subject = f"<b>Subject</b><br>{lst[-2]}<br><br>"
message = lst[-1].replace("\n", "<br>")
message = f"<b>Message</b><br>{message}<br><br>"
return fr_addr + to_addr + subject + message
class mainform(QWidget):
"""
Главное окно, оно будет пока и главным классом приложения
"""
def __init__(self):
QWidget.__init__(self)
self.resize(600, 400)
self.connect()
#запущаем соединение
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() # закрываем соединение
class FileSelect(QMainWindow, QWidget):
def __init__(self):
super(FileSelect, self).__init__()
self.setWindowTitle("Printing Booth Systems")
global file, pagecount, total, enabler, copies, colormode, page
file = ""
pagecount = 0
total = 0.0
copies = "1"
colormode = ""
page = ""
widget = QWidget()
layout = QVBoxLayout()
self.index = QModelIndex()
self.model = QFileSystemModel()
self.tree = QTreeView()
self.model.setRootPath(QDir.currentPath()) #ignore
self.model.setNameFilters(["*.pdf"])
idx = self.model.index("/media/pi/")
self.tree.setModel(self.model)
self.tree.setRootIndex(idx)
self.tree.setColumnWidth(0, 250)
self.tree.setAlternatingRowColors(True)
layout.addWidget(self.tree)
widget.setLayout(layout)
self.setCentralWidget(widget)
widget.setFixedWidth(600)
self.tree.setFont(QFont('Arial', 30))
self.tree.hideColumn(1)
self.tree.hideColumn(2)
self.tree.hideColumn(3)
self.tree.clicked.connect(self.on_treeView_clicked)
self.btn1 = QPushButton('Select', self)
self.btn1.setGeometry(620, 120, 150, 90)
self.btn1.clicked.connect(self.slot_btn1_function)
self.btn2 = QPushButton('Cancel', self)
self.btn2.setGeometry(620, 300, 150, 90)
self.btn2.clicked.connect(self.slot_btn2_function)
def slot_btn1_function(self):
if file.lower().endswith('.pdf'):
self.p = Preview()
self.p.showFullScreen()
self.hide()
else:
pass
def slot_btn2_function(self):
self.mw = MainWindow()
self.mw.showFullScreen()
self.hide()
def on_treeView_clicked(self, index):
global file
indexItem = self.model.index(index.row(), 0, index.parent())
filePath = self.model.filePath(indexItem)
file = filePath
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Untitled")
icon = os.path.join(BASE_DIR, 'ide/Icon.ico')
self.setWindowIcon(QIcon(icon))
self.saveLoad = SaveLoad()
self.fileName = None
self.setupUI()
def setupUI(self):
centralWidget = QWidget(self)
layout = QHBoxLayout(centralWidget)
self.fileSysView = QTreeView(centralWidget)
self.setupFileSystemViewer()
self.editor = QsciScintilla(centralWidget)
self.setupEditor()
layout.addWidget(self.fileSysView, 1)
layout.addWidget(self.editor, 3)
self.setCentralWidget(centralWidget)
self.setMinimumSize(700, 500)
self.defaultMenuBar = QMenuBar(self)
self.setupMenus()
self.setMenuBar(self.defaultMenuBar)
self.show()
def setupEditor(self):
self.editor.setFont(QFont("Times New Roman", 12))
self.editor.setMargins(2)
self.editor.setMarginType(0, QsciScintilla.NumberMargin)
self.editor.setMarginType(1, QsciScintilla.SymbolMargin)
self.editor.setMarginWidth(0, "000")
self.editor.setMarginWidth(1, "00")
self.editor.markerDefine(QsciScintilla.RightTriangle, 1)
if system() == "Windows":
self.editor.setEolMode(QsciScintilla.EolWindows)
elif system() == "Linux":
self.editor.setEolMode(QsciScintilla.EolUnix)
elif system() == "Mac":
self.editor.setEolMode(QsciScintilla.EolMac)
else:
print("Using Windows EOL")
self.editor.setEolMode(QsciScintilla.EolWindows)
self.editor.setBraceMatching(QsciScintilla.SloppyBraceMatch)
self.editor.setIndentationsUseTabs(True)
self.editor.setTabWidth(4)
self.editor.setIndentationGuides(True)
self.editor.setTabIndents(True)
self.editor.setAutoIndent(True)
self.editor.setCaretForegroundColor(QColor("#ff11214b"))
self.editor.setCaretLineVisible(True)
self.editor.setCaretLineBackgroundColor(QColor("#1f0000ff"))
self.editor.setUtf8(True)
self.editor.setMarginSensitivity(1, True)
self.editor.marginClicked.connect(self.margin_clicked)
self.editor.marginRightClicked.connect(self.margin_right_clicked)
self.lexer = QsciLexerPython()
self.lexer.setFont(QFont("Times New Roman", 12))
self.editor.setLexer(self.lexer)
self.editor.textChanged.connect(self.fileChanged)
def setupFileSystemViewer(self):
model = QFileSystemModel()
model.setRootPath("/")
self.fileSysView.setModel(model)
self.fileSysView.hideColumn(1)
self.fileSysView.hideColumn(2)
self.fileSysView.hideColumn(3)
self.fileSysView.doubleClicked.connect(self.openFile)
def setupMenus(self):
fileMenu = QMenu(self.defaultMenuBar)
fileMenu.setTitle("File")
editMenu = QMenu(self.defaultMenuBar)
editMenu.setTitle("Edit")
viewMenu = QMenu(self.defaultMenuBar)
viewMenu.setTitle("View")
runMenu = QMenu(self.defaultMenuBar)
runMenu.setTitle("Run")
settingsMenu = QMenu(self.defaultMenuBar)
settingsMenu.setTitle("Settings")
self.actionNew = QAction(self)
self.actionNew.setText("New")
self.actionNew.setShortcut("Ctrl+N")
self.actionOpen = QAction(self)
self.actionOpen.setText("Open")
self.actionOpen.setShortcut("Ctrl+O")
self.actionSave = QAction(self)
self.actionSave.setText("Save")
self.actionSave.setShortcut("Ctrl+S")
self.actionSaveAs = QAction(self)
self.actionSaveAs.setText("Save As")
self.actionSaveAs.setShortcut("Ctrl+Shift+S")
self.actionExit = QAction(self)
self.actionExit.setText("Exit")
self.actionExit.setShortcut("Alt+X")
self.actionUndo = QAction(self)
self.actionUndo.setText("Undo")
self.actionUndo.setShortcut("Ctrl+Z")
self.actionRedo = QAction(self)
self.actionRedo.setText("Redo")
self.actionRedo.setShortcut("Ctrl+Shift+Z")
self.actionSelectAll = QAction(self)
self.actionSelectAll.setText("Select all")
self.actionSelectAll.setShortcut("Ctrl+A")
self.actionCut = QAction(self)
self.actionCut.setText("Cut")
self.actionCut.setShortcut("Ctrl+X")
self.actionCopy = QAction(self)
self.actionCopy.setText("Copy")
self.actionCopy.setShortcut("Ctrl+C")
self.actionPaste = QAction(self)
self.actionPaste.setText("Paste")
self.actionPaste.setShortcut("Ctrl+V")
self.actionFind = QAction(self)
self.actionFind.setText("Find")
self.actionFind.setShortcut("Ctrl+F")
self.actionReplace = QAction(self)
self.actionReplace.setText("Replace")
self.actionReplace.setShortcut("Ctrl+H")
self.actionRun = QAction(self)
self.actionRun.setText("Run")
self.actionRun.setShortcut("F5")
self.actionRunCustom = QAction(self)
self.actionRunCustom.setText("Run Customized")
self.actionRunCustom.setShortcut("Shift+F5")
self.actionShell = QAction(self)
self.actionShell.setText("Python shell")
self.actionShell.setShortcut("Alt+S")
self.actionFont = QAction(self)
self.actionFont.setText("Font")
self.actionEncoding = QAction(self)
self.actionEncoding.setText("Encoding")
fileMenu.addAction(self.actionNew)
fileMenu.addAction(self.actionOpen)
fileMenu.addAction(self.actionSave)
fileMenu.addAction(self.actionSaveAs)
fileMenu.addSeparator()
fileMenu.addAction(self.actionExit)
editMenu.addAction(self.actionUndo)
editMenu.addAction(self.actionRedo)
editMenu.addSeparator()
editMenu.addAction(self.actionSelectAll)
editMenu.addSeparator()
editMenu.addAction(self.actionCut)
editMenu.addAction(self.actionCopy)
editMenu.addAction(self.actionPaste)
viewMenu.addAction(self.actionFind)
viewMenu.addAction(self.actionReplace)
runMenu.addAction(self.actionRun)
runMenu.addAction(self.actionRunCustom)
runMenu.addAction(self.actionShell)
settingsMenu.addAction(self.actionFont)
settingsMenu.addAction(self.actionEncoding)
self.defaultMenuBar.addAction(fileMenu.menuAction())
self.defaultMenuBar.addAction(editMenu.menuAction())
self.defaultMenuBar.addAction(viewMenu.menuAction())
self.defaultMenuBar.addAction(runMenu.menuAction())
self.defaultMenuBar.addAction(settingsMenu.menuAction())
self.actionNew.triggered.connect(self.new)
self.actionOpen.triggered.connect(self.open)
self.actionSave.triggered.connect(self.save)
self.actionSaveAs.triggered.connect(self.saveAs)
self.actionExit.triggered.connect(self.close)
self.actionUndo.triggered.connect(self.editor.undo)
self.actionRedo.triggered.connect(self.editor.redo)
self.actionSelectAll.triggered.connect(
lambda: self.editor.selectAll(True))
self.actionCut.triggered.connect(self.editor.cut)
self.actionCopy.triggered.connect(self.editor.copy)
self.actionPaste.triggered.connect(self.editor.paste)
self.actionFind.triggered.connect(self.find)
self.actionReplace.triggered.connect(self.replace)
self.actionRun.triggered.connect(self.run)
self.actionRunCustom.triggered.connect(self.runCustom)
self.actionShell.triggered.connect(self.shell)
self.actionFont.triggered.connect(self.Font)
def margin_clicked(self, margin_nr, line_nr, state):
self.editor.markerAdd(line_nr, margin_nr)
def margin_right_clicked(self, margin_nr, line_nr, state):
self.editor.markerDelete(line_nr, margin_nr)
def new(self):
if self.windowTitle().endswith("*"):
if (Dialogs().Question(
self, "Do you want to save your file?") == "accept"):
if self.filename is None:
self.saveAs()
else:
self.save()
self.editor.setText("")
self.setWindowTitle("Untitled")
def open(self):
if self.windowTitle().endswith("*"):
if (Dialogs().Question(
self, "Do you want to save your file?") == "accept"):
if self.filename is None:
self.saveAs()
else:
self.save()
filename = self.saveLoad.OpenDialog()
data = Open(filename)
if data is not None:
self.editor.setText(data)
self.setWindowTitle(filename)
self.filename = filename
def save(self):
if self.filename is None:
self.saveAs()
else:
returnval = Save(self.editor.text(), self.filename)
if (returnval):
Dialogs().Message(self, "File saved successfully")
self.setWindowTitle(self.filename)
else:
Dialogs().Error(self, "File could not be saved")
def saveAs(self):
self.filename = self.saveLoad.SaveDialog()
returnval = Save(self.editor.text(), self.filename)
if (returnval):
Dialogs().Message(self, "File saved successfully")
self.setWindowTitle(self.filename)
else:
Dialogs().Error(self, "File could not be saved")
def run(self):
if self.filename is None:
self.saveAs()
Runfile(self.filename)
def runCustom(self):
if self.filename is None:
self.saveAs()
if self.filename != "":
print(len(self.filename))
option, ok = QInputDialog().getText(
self, "Customized run", "Enter parameters for sys.argv",
QLineEdit.Normal, " ")
if ok:
Runfile(self.filename, option)
def shell(self):
Shell()
def Font(self):
font, ok = QFontDialog.getFont()
if ok:
self.editor.setFont(font)
self.lexer.setFont(font)
self.editor.setLexer(self.lexer)
def openFile(self, signal):
fileName = self.fileSysView.model().filePath(signal)
if fileName.endswith("py") or fileName.endswith("pyw"):
if self.windowTitle().endswith("*"):
if Dialogs().Question(
self, "Do you want to save your file?") == "accept":
if self.filename is None:
self.saveAs()
else:
self.save()
data = Open(fileName)
if data is not None:
self.editor.setText(data)
self.setWindowTitle(fileName)
self.filename = fileName
def fileChanged(self):
title = self.windowTitle()
if not (title.endswith("*")):
self.setWindowTitle(title + " *")
def replace(self):
replaceObj = replaceDialog(self, self.editor)
def find(self):
findObj = findDialog(self, self.editor)
class MyMainWindow(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.config_window()
self.create_widgets()
self.config_widgets()
self.create_menubar()
self.bind_widgets()
self.show_widgets()
def config_window(self):
self.setWindowTitle('DirectoPy')
self.setMinimumHeight(600)
self.setMinimumWidth(1000)
def create_widgets(self):
self.central_widget = QWidget()
self.main_layout = QGridLayout()
self.moveup_button = QPushButton('Collapse all', self)
self.goto_lineedit = QLineEdit('', self)
self.goto_button = QPushButton('Go', self)
self.folder_view = QTreeView(self)
self.file_view = QTreeView(self)
self.folder_model = QFileSystemModel(self)
self.file_model = QFileSystemModel(self)
def config_widgets(self):
self.main_layout.addWidget(self.moveup_button, 0, 0)
self.main_layout.addWidget(self.goto_lineedit, 0, 1, 1, 2)
self.main_layout.addWidget(self.goto_button, 0, 3)
self.main_layout.addWidget(self.folder_view, 1, 0, 1, 2)
self.main_layout.addWidget(self.file_view, 1, 2, 1, 2)
self.central_widget.setLayout(self.main_layout)
# Кнопка "вверх"
self.moveup_button.setMaximumWidth(100)
# Кнопка "перейти"
self.goto_button.setMaximumWidth(70)
self.setCentralWidget(self.central_widget)
# панели
self.folder_model.setRootPath(None)
self.folder_model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
self.folder_view.setModel(self.folder_model)
self.folder_view.setRootIndex(self.folder_model.index(None))
self.folder_view.clicked[QModelIndex].connect(self.clicked_onfolder)
self.folder_view.hideColumn(1)
self.folder_view.hideColumn(2)
self.folder_view.hideColumn(3)
self.file_model.setFilter(QDir.Files)
self.file_view.setModel(self.file_model)
self.file_model.setReadOnly(False)
self.file_view.setColumnWidth(0, 200)
self.file_view.setSelectionMode(QAbstractItemView.ExtendedSelection)
# открытие папки при нажати на неё в окне папок
def clicked_onfolder(self, index):
selection_model = self.folder_view.selectionModel()
index = selection_model.currentIndex()
dir_path = self.folder_model.filePath(index)
self.file_model.setRootPath(dir_path)
self.file_view.setRootIndex(self.file_model.index(dir_path))
# ф-я открытия нового файла
def open_file(self):
index = self.file_view.selectedIndexes()
if not index:
return
else:
index = index[0]
file_path = self.file_model.filePath(index).replace('/', '\\')
print(file_path)
self.file_view.update()
# ф-я создания нового файла
def new_file(self):
global file_name
index = self.folder_view.selectedIndexes()
if len(index) > 0:
path = self.folder_model.filePath(index[0])
for i in range(1, 9999999999999999):
if not os.path.isfile(os.path.join(path, "newfile{}.txt".format(i))):
file_name = os.path.join(path, "newfile{}.txt".format(i))
break
file_name = os.path.abspath(file_name)
open(file_name, 'w').close()
else:
print("Please, select folder")
# ф-я удаления файла
def delete_file(self):
indexes = self.file_view.selectedIndexes()
for i in indexes:
self.file_model.remove(i)
# ф-я переименования файла
def rename_file(self):
index = self.file_view.selectedIndexes()
if not index:
return
else:
index = index[0]
self.file_view.edit(index)
# ф-я копирования файла
def copy_file(self):
print("COPY")
ask = QFileDialog.getExistingDirectory(self, "Open Directory", "C:\\",
QFileDialog.ShowDirsOnly |
QFileDialog.DontResolveSymlinks)
new_path = ask.replace('\\', '/')
indexes = self.file_view.selectedIndexes()[::4]
for i in indexes:
new_filename = new_path + '/' + self.file_model.fileName(i)
copy2(self.file_model.filePath(i), new_filename)
# ф-я возвращения к корню пути
def colapse(self):
self.folder_view.collapseAll()
# ф-я перемещения в заданную директорию
def go_to(self):
dir_path = self.goto_lineedit.text().replace('\\', '/')
print(dir_path)
self.file_model.setRootPath(dir_path)
self.file_view.setRootIndex(self.file_model.index(dir_path))
#self.file_model.setRootPath()
# ф-я перемещения файла
def move_file(self):
print("MOVE")
ask = QFileDialog.getExistingDirectory(self, "Open Directory", "C:\\",
QFileDialog.ShowDirsOnly |
QFileDialog.DontResolveSymlinks)
if ask == '':
return
new_path = ask.replace('\\', '/')
indexes = self.file_view.selectedIndexes()[::4]
for i in indexes:
new_filename = new_path + '/' + self.file_model.fileName(i)
move(self.file_model.filePath(i), new_filename)
# ф-я создания новой папки
def new_folder(self):
global file_name
index = self.folder_view.selectedIndexes()
if len(index) > 0:
path = self.folder_model.filePath(index[0])
for i in range(1, 9999999999999999):
if not os.path.isdir(os.path.join(path, "newfolder{}".format(i))):
file_name = os.path.join(path, "newfolder{}".format(i))
break
file_name = os.path.abspath(file_name)
os.mkdir(file_name)
else:
print("Please, select folder")
# ф-я удаления папки
def delete_folder(self):
indexes = self.folder_view.selectedIndexes()
for i in indexes:
self.folder_model.remove(i)
# ф-я переименования папки
def rename_folder(self):
index = self.folder_view.selectedIndexes()
if not index:
return
else:
index = index[0]
self.folder_view.edit(index)
# ф-я закрытия окна файлового менеджера
def exit_application(self):
print("EXIT")
self.close()
# задавание функции каждой кнопке
def bind_widgets(self):
self.open_file_action.triggered.connect(self.open_file)
self.new_file_action.triggered.connect(self.new_file)
self.delete_file_action.triggered.connect(self.delete_file)
self.rename_file_action.triggered.connect(self.rename_file)
self.copy_file_action.triggered.connect(self.copy_file)
self.move_file_action.triggered.connect(self.move_file)
self.exit_action.triggered.connect(self.exit_application)
self.new_folder_action.triggered.connect(self.new_folder)
self.delete_folder_action.triggered.connect(self.delete_folder)
self.rename_folder_action.triggered.connect(self.rename_folder)
self.goto_button.clicked.connect(partial(self.go_to))
self.moveup_button.clicked.connect(partial(self.colapse))
# создание меню
def create_menubar(self):
self.exit_action = QAction('Exit', self)
self.exit_action.setShortcut('Ctrl+Q')
self.new_file_action = QAction('New file', self)
self.new_file_action.setShortcut('F4')
self.open_file_action = QAction('Open file', self)
self.open_file_action.setShortcut('F3')
self.rename_file_action = QAction('Rename file', self)
self.rename_file_action.setShortcut('F2')
self.delete_file_action = QAction('Remove file', self)
self.delete_file_action.setShortcut(QKeySequence.Delete)
self.copy_file_action = QAction('Copy folder...', self)
self.copy_file_action.setShortcut(QKeySequence.Copy)
self.move_file_action = QAction('Move folder...', self)
self.move_file_action.setShortcut(QKeySequence.Cut)
self.new_folder_action = QAction('New folder', self)
self.new_folder_action.setShortcut('Ctrl+Shift+N')
self.delete_folder_action = QAction('Delete folder', self)
self.delete_folder_action.setShortcut('Ctrl+Shift+Del')
self.rename_folder_action = QAction('Rename folder', self)
self.rename_folder_action.setShortcut('Ctrl+Shift+R')
self.menubar = self.menuBar()
self.file_menu = self.menubar.addMenu('File')
self.file_menu.addAction(self.new_file_action)
self.file_menu.addAction(self.open_file_action)
self.file_menu.addAction(self.rename_file_action)
self.file_menu.addAction(self.delete_file_action)
self.file_menu.addAction(self.copy_file_action)
self.file_menu.addAction(self.move_file_action)
self.file_menu.addSeparator()
self.file_menu.addAction(self.exit_action)
self.folder_menu = self.menubar.addMenu('Folder')
self.folder_menu.addAction(self.new_folder_action)
self.folder_menu.addAction(self.delete_folder_action)
self.folder_menu.addAction(self.rename_folder_action)
def show_widgets(self):
self.setLayout(self.main_layout)
class TreeSelectionScreen(SelectionScreen):
""" Shows all plans and tasks in a tree view """
def __init__(self, model):
super(TreeSelectionScreen, self).__init__(model)
self.tree_view = QTreeView()
self.tree_view.setModel(self.data_context.data_model)
self.tree_view.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.tree_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tree_view.selectionModel().selectionChanged.connect(
self.selection_changed)
self.tree_view.hideColumn(TreeModelCols.DESCRIPTION)
self.tree_view.hideColumn(TreeModelCols.RESULT)
self.tree_view.hideColumn(TreeModelCols.ANCESTOR)
self.tree_view.hideColumn(TreeModelCols.LINK)
self.button_add_plan = QPushButton()
self.button_add_plan.setText("Add Plan")
self.button_add_plan.setIcon(QIcon(":/icons/plan.ico"))
self.button_add_plan.setDisabled(True)
self.button_add_plan.pressed.connect(self.add_plan)
self.button_add_task = QPushButton()
self.button_add_task.setText("Add Task")
self.button_add_task.setIcon(QIcon(":/icons/task.ico"))
self.button_add_task.setDisabled(True)
self.button_add_task.pressed.connect(self.add_task)
self.button_delete_selection = QPushButton()
self.button_delete_selection.setText("Delete")
self.button_delete_selection.setIcon(QIcon(":/icons/delete.ico"))
self.button_delete_selection.setDisabled(True)
self.button_delete_selection.pressed.connect(self.delete_selection)
self.button_print_selection = QPushButton()
self.button_print_selection.setText("Print")
self.button_print_selection.setIcon(QIcon(":/icons/print.ico"))
self.button_print_selection.setDisabled(True)
self.button_print_selection.pressed.connect(self.print_selection)
button_box = QHBoxLayout()
button_box.addWidget(self.button_add_plan)
button_box.addWidget(self.button_add_task)
button_box.addWidget(self.button_delete_selection)
button_box.addWidget(self.button_print_selection)
layout = QVBoxLayout()
layout.addWidget(self.tree_view)
layout.addLayout(button_box)
self.setLayout(layout)
def reload_screen(self):
""" Called when project changes """
self.button_add_plan.setDisabled(self.project is None)
def selection_changed(self, selected, _):
""" Handle changed selection """
if len(selected.indexes()) < 1:
return
index = selected.indexes()[0]
self.item_selected.emit(index)
node = index.internalPointer()
self.button_add_task.setEnabled(node.type == "plan")
self.button_print_selection.setEnabled(node.type == "plan")
self.button_delete_selection.setEnabled(node.type == "plan"
or node.type == "task")
def delete_selection(self):
""" Deletes the selected row if valid """
if len(self.tree_view.selectedIndexes()) == 0:
return
self.data_context.data_model.delete_node(
self.tree_view.selectedIndexes()[0])
def print_selection(self):
""" Print the selected plan """
plan = self.tree_view.selectedIndexes()[0].internalPointer().data
printer = PlanPrinter()
printer.print_plan(plan)
def add_plan(self):
""" Create a new plan in the project """
self.data_context.data_model.add_node(
self.data_context.data_model.plans_index)
def add_task(self):
""" Create a new task in the project """
if len(self.tree_view.selectedIndexes()) == 0:
return
self.data_context.data_model.add_node(
self.tree_view.selectedIndexes()[0])
def clear_selection(self):
""" Called when screen is being switched to """
self.tree_view.selectionModel().clearSelection()
class Main(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.filename = ""
self.changed = False
self.initUI()
style = open("style.qss", 'r')
self.setStyleSheet(style.read())
def initAction(self):
self.newAction = QAction(QtGui.QIcon("icons/new.png"), "New", self)
self.newAction.setStatusTip("Create a new document")
self.newAction.setShortcut("Ctrl+N")
self.newAction.triggered.connect(self.new)
self.openAction = QAction(QtGui.QIcon("icons/open.png"), "Open file",
self)
self.openAction.setStatusTip("Open existing document")
self.openAction.setShortcut("Ctrl+O")
self.openAction.triggered.connect(self.open)
self.saveAction = QAction(QtGui.QIcon("icons/save.png"), "Save", self)
self.saveAction.setStatusTip("Save document")
self.saveAction.setShortcut("Ctrl+S")
self.saveAction.triggered.connect(self.save)
self.saveAsAction = QAction("Save As", self)
self.saveAsAction.setStatusTip("Save document as")
self.saveAsAction.setShortcut("Ctrl+Shift+S")
self.saveAsAction.triggered.connect(self.saveAs)
self.exitAction = QAction("Exit", self)
self.exitAction.setStatusTip("Exit word processor")
self.exitAction.setShortcut("Ctrl+W")
self.exitAction.triggered.connect(self.close)
self.hideDirAction = QAction("Toggle Dir Visibility", self)
self.hideDirAction.setStatusTip("Show/Hide the Directory View")
self.hideDirAction.setShortcut("Ctrl+\\")
self.hideDirAction.triggered.connect(self.toggleDirVisibility)
# def initFormatbar(self):
# self.formatbar = self.addToolBar("Format")
def initMenubar(self):
menubar = self.menuBar()
file = menubar.addMenu("File")
edit = menubar.addMenu("Edit")
view = menubar.addMenu("View")
file.addAction(self.newAction)
file.addAction(self.openAction)
file.addAction(self.saveAction)
file.addAction(self.saveAsAction)
file.addAction(self.exitAction)
view.addAction(self.hideDirAction)
def initFont(self):
self.font = QtGui.QFont("Futura", pointSize=16)
self.document.setDefaultFont(self.font)
def initFileTree(self):
#TODO: fix the scope of these variables
self.dockWidget = QDockWidget(self, flags=Qt.FramelessWindowHint)
# titleWidget = QtWidget(self)
# self.dockWidget.setTitleBarWidget(titleWidget)
self.view = QTreeView(self)
self.model = QFileSystemModel()
self.model.setRootPath("/Users/kevinhouyang/Development/")
self.view.setModel(self.model)
self.view.setRootIndex(
self.model.index("/Users/kevinhouyang/Development/typy"))
self.view.hideColumn(1)
self.view.hideColumn(2)
self.view.hideColumn(3)
self.view.hideColumn(4)
self.view.setHeaderHidden(True)
self.dockWidget.setWidget(self.view)
self.addDockWidget(Qt.LeftDockWidgetArea, self.dockWidget)
self.dockWidget.setFeatures(QDockWidget.NoDockWidgetFeatures)
self.dockWidget.setVisible(False)
self.dockWidget.setTitleBarWidget(None)
def initUI(self):
self.editor = QPlainTextEdit(self)
self.editor.setCenterOnScroll(True)
self.editor.textChanged.connect(self.toggleChanged)
self.document = self.editor.document()
self.document.setDocumentMargin(100)
self.initFont()
self.setWindowIcon(QtGui.QIcon("icons/icon.png"))
self.initAction()
self.initMenubar()
self.setCentralWidget(self.editor)
self.initFileTree()
self.setGeometry(100, 100, 1030, 800)
self.setWindowTitle("QtWriter")
#TODO fix this..? how do i get formatting to show
def updateFocus(self):
for i in range(self.document.lineCount()):
currBlock = self.document.findBlockByLineNumber(i)
# print(currBlock.text())
# print(currBlock.text())
# for c in currBlock.text():
# currBlock.text().charFormat().setForeground(QtGui.QBrush(QtGui.QColor(10,10,10)))
# currBlock.blockFormat().setForeground(QtGui.QBrush(QtGui.QColor(10,10,10)))
# print(currBlock.blockFormat().fontUnderline())
#
self.editor.update()
# for each line in the textdocument
# adjust its lightness in accordance to distance from cursor line
def new(self):
spawn = Main(self)
spawn.show()
def open(self):
self.filename = QFileDialog.getOpenFileName(self, 'Open File', ".",
"(*.txt)")[0]
if self.filename:
with open(self.filename, "r") as file:
self.document.setPlainText(file.read())
self.setWindowTitle("QtWriter - " + os.path.basename(self.filename))
self.updateFocus()
def save(self):
if not self.filename:
# if event is not None:
self.filename = QFileDialog.getSaveFileName(self, 'Save File')[0]
if self.filename:
if not self.filename.endswith(".txt"):
self.filename += ".txt"
with open(self.filename, "w") as file:
file.write(self.editor.toPlainText())
def saveAs(self):
self.filename = QFileDialog.getSaveFileName(self, 'Save File')[0]
self.save()
def exit(self):
print("just tried to exit!")
def toggleDirVisibility(self):
self.dockWidget.setVisible(not self.dockWidget.isVisible())
def toggleChanged(self):
self.changed = True
def closeEvent(self, event):
if self.changed:
popup = QMessageBox(self)
popup.setIcon(QMessageBox.Warning)
popup.setText("The document has been modified")
popup.setInformativeText("Do you want to save your changes?")
popup.setStandardButtons(QMessageBox.Save | QMessageBox.Cancel
| QMessageBox.Discard)
popup.setDefaultButton(QMessageBox.Save)
answer = popup.exec_()
if answer == QMessageBox.Save:
self.save()
elif answer == QMessageBox.Discard:
event.accept()
else:
event.ignore()
else:
event.accept()
class mainform(QWidget):
"""
Главное окно, оно будет пока и главным классом приложения
"""
def __init__(self):
QWidget.__init__(self)
self.resize(600, 400)
self.connect()
#запущаем соединение
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() # закрываем соединение
class Ui_MainWindow(object):
def setupUi(self, MainWindow, model):
# self.initDirectory(DEFAULT_DIR_PATH)
MainWindow.setObjectName("MainWindow")
MainWindow.setWindowTitle("Exploit")
self.centralWidget = QtWidgets.QWidget(MainWindow)
self.centralWidget.setObjectName("centralWidget")
self.hLayout = QtWidgets.QHBoxLayout(self.centralWidget)
self.hLayout.setContentsMargins(11, 11, 11, 11)
# self.hLayout.setSpacing(6)
self.hLayout.setObjectName("hLayout")
self.comboBox_Devices = QtWidgets.QComboBox()
self.comboBox_Devices.setStyleSheet(
"max-width:250;\n"
"selection-color: rgb(11, 181, 255);\n"
"selection-background-color: rgb(255, 255, 255);")
self.comboBox_Devices.setObjectName("comboBox_Devices")
devices = next(os.walk(DEFAULT_DIR_PATH))[1]
self.comboBox_Devices.addItem("Devices")
for device in devices:
self.comboBox_Devices.addItem(device)
self.comboBox_Devices.activated[str].connect(self.setTreeviewItem)
self.listLabel = QtWidgets.QLabel("DEVICES")
self.dialog = QDialog()
self.layout = QVBoxLayout(self.dialog)
self.treeView = QTreeView(self.dialog)
# QTreeView use QStandardItemModel as data source
self.treeView.setModel(model)
# model.setRootPath(DEFAULT_DIR_PATH)
# self.treeView.setRootIndex(model.index(DEFAULT_DIR_PATH))
self.treeView.setHeaderHidden(True)
self.treeView.hideColumn(1)
self.treeView.hideColumn(2)
self.treeView.hideColumn(3)
self.treeView.doubleClicked.connect(self.printUrl)
self.layout.addWidget(self.treeView)
self.listLabel1 = QtWidgets.QLabel("DATA")
self.listLabel1.setStyleSheet("font: 14pt \"Sans Serif\";")
self.listLabel1.setAlignment(QtCore.Qt.AlignCenter)
self.details_dialog = QDialog()
self.layout_details = QVBoxLayout(self.details_dialog)
self.treeView_Details = QTreeView(self.details_dialog)
# QTreeView use QStandardItemModel as data source
# self.details_model = QFileSystemModel()
# self.details_model.setRootPath(DEFAULT_DIR_PATH)
# self.treeView_Details.setModel( self.details_model)
# self.treeView_Details.setRootIndex(self.details_model.index(DEFAULT_DIR_PATH))
self.layout_details.addWidget(self.treeView_Details)
# self.tableView = QTableView()
# self.tableView.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
# self.tableView.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Stretch)
# self.tableView.verticalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Fixed)
# self.tableView.verticalHeader().setDefaultSectionSize(80)
# self.tableView.horizontalHeader().setDefaultAlignment(Qt.AlignLeft)
splitter_label = QtWidgets.QSplitter(Qt.Horizontal)
splitter_label.addWidget(self.comboBox_Devices)
splitter_label.addWidget(self.listLabel1)
splitter_label.setSizes([30, 157])
splitter_data = QtWidgets.QSplitter(Qt.Horizontal)
splitter_data.addWidget(self.treeView)
splitter_data.addWidget(self.treeView_Details)
splitter_data.setSizes([30, 157])
splitter_all = QtWidgets.QSplitter(Qt.Vertical)
splitter_all.addWidget(splitter_label)
splitter_all.addWidget(splitter_data)
splitter_all.setSizes([1, 500])
self.hLayout.addWidget(splitter_all)
MainWindow.setCentralWidget(self.centralWidget)
def initDirectory(self, path):
new_item = self.newItem(path)
self.readDirectory(path, new_item)
model.appendRow(new_item)
def readDirectory(self, path, parent_item):
directory = os.listdir(path)
for file_name in directory:
self.file_path = path + '/' + file_name
new_item = self.newItem(self.file_path)
parent_item.appendRow(new_item)
if os.path.isdir(self.file_path):
self.readDirectory(self.file_path, new_item)
def newItem(self, path):
title = os.path.basename(path)
item = QStandardItem()
if os.path.isdir(path):
icon_path = DIR_ICON_PATH
else:
if path.endswith('PNG') or path.endswith('png') or path.endswith(
'JPG') or path.endswith('jpg') or path.endswith(
'JPEG') or path.endswith('jpeg') or path.endswith(
'GIF') or path.endswith('gif'):
icon_path = IMAGE_ICON_PATH
elif path.endswith('.mp4'):
icon_path = VIDEO_ICON_PATH
else:
icon_path = FILE_ICON_PATH
icon = QIcon(icon_path)
item.setText(title)
item.setIcon(icon)
return item
def setTreeviewItem(self, device):
if device != "Devices":
model.setRootPath(DEFAULT_DIR_PATH)
self.treeView.setRootIndex(
model.index(DEFAULT_DIR_PATH + "/" + device))
else:
self.treeView.setRootIndex(model.index(DEFAULT_DIR_PATH))
def printUrl(self, signal):
file_path = model.filePath(signal)
if "Toshiba Laptop" in file_path:
print(file_path.replace("/home/.exploits/Toshiba Laptop", ""))
else:
print(file_path.replace("/home/.exploits/Hp Desktop", ""))
class EditorTextosDlg(QWidget):
def __init__(self):
super().__init__()
self.fileName = ["Editor de texto", ".txt"]
self.initUI()
def initUI(self):
folderSectionTitle = QLabel("Carpeta")
self.fileFolder = QLineEdit()
self.fileFolder.setReadOnly(True)
self.selectButton = QPushButton("Seleccionar")
filesSectionTitle = QLabel("Archivos")
self.fileTree = QTreeView()
self.fileSystemModel = QFileSystemModel(self.fileTree)
self.fileSystemModel.setReadOnly(True)
modelRoot = self.fileSystemModel.setRootPath("/home")
self.fileTree.setModel(self.fileSystemModel)
self.fileTree.setRootIndex(modelRoot)
self.fileTree.hideColumn(1)
self.fileTree.hideColumn(2)
self.fileTree.hideColumn(3)
self.fileTree.setHeaderHidden(True)
self.textEdit = QTextEdit()
self.saveButton = QPushButton("Guardar")
self.saveAsButton = QPushButton("Guardar como")
hbox = QHBoxLayout()
hbox.addWidget(folderSectionTitle)
hbox.addWidget(self.fileFolder)
hbox.addWidget(self.selectButton)
vbox = QVBoxLayout()
vbox.setSpacing(30)
vbox.addLayout(hbox)
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(filesSectionTitle, 0, 0)
grid.addWidget(self.fileTree, 1, 0, 1, 3)
grid.addWidget(self.textEdit, 1, 3, 1, 5)
vbox.addLayout(grid)
self.buttomsLayout = QHBoxLayout()
self.buttomsLayout.addWidget(self.saveButton)
self.buttomsLayout.addWidget(self.saveAsButton)
self.buttomsLayout.addStretch()
vbox.addLayout(self.buttomsLayout)
self.setLayout(vbox)
self.setWindowTitle("Editor de texto")
self.setGeometry(300, 150, 1000, 700)
self.show()
self.selectButton.clicked.connect(self.openFolders)
self.fileTree.doubleClicked.connect(self.doubleClickedTreeView)
self.saveButton.clicked.connect(self.saveFiles)
self.saveAsButton.clicked.connect(self.saveAsFiles)
def openFolders(self):
directory = controller.openFolder(self)
modelRoot = self.fileSystemModel.setRootPath(directory)
self.fileTree.setRootIndex(modelRoot)
self.fileFolder.setText(directory)
def doubleClickedTreeView(self, index):
filedata = controller.doubleClickedTreeView(self, index)
self.textEdit.setText(filedata)
def saveFiles(self):
controller.saveFile(self)
def saveAsFiles(self):
controller.saveAsFile(self)
def closeEvent(self, event):
reply = QMessageBox.question(self, "Confirmación",
"¿Deseas cerrar la app?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if reply == QMessageBox.Yes:
event.accept()
else:
event.ignore()
class mainForm(QMainWindow):
get_template_filename = pyqtSignal(str)
exit_program = pyqtSignal()
camera_changed = pyqtSignal(int)
def __init__(self):
super().__init__()
self.stream = None
self.image_difference_thread = None
self.template_set = False
self._countour_max_tresh = 10
self._countour_min_tresh = 1
self._transparency_max = 10
self._transparency_min = 0
self._countour_gamma_max = 10
self._countour_gamma_min = 1
self._color_max = 255
self._color_min = 0
self.screen_resolution = None
self.grid_layout = None
self.output_picture = None
self.initUI()
self.init_image_difference()
if self.webcam_switcher.count() > 0:
self.stream = streamCapture(self.webcam_switcher.itemData(self.webcam_switcher.currentIndex()))
self.stream.getframe.connect(self.mat2qimage)
self.webcam_switcher.currentIndexChanged.connect(self.camera_switcher_index_changed)
self.camera_changed.connect(self.stream.reopenStream)
self.stream.start()
self.exit_program.connect(self.stream.exit)
### отрисовка интерфейса
def initUI(self):
self.screen_resolution = QApplication.desktop().screenGeometry()
# self.resize(self.screen_resolution.size())
# self.move(self.screen_resolution.left(), self.screen_resolution.top())
self.grid_layout = QGridLayout()
self.central_widget = QWidget()
self.central_widget.setLayout(self.grid_layout)
self.central_widget.setMaximumSize(self.screen_resolution.width() // 4 * 3,
self.screen_resolution.height() // 4 * 3)
self.setCentralWidget(self.central_widget)
self.camera_label = QLabel("Camera:")
self.grid_layout.addWidget(self.camera_label, 0, 0, 1, 1, Qt.AlignmentFlag.AlignHCenter)
self.webcam_switcher = QComboBox()
self.detect_webcam_devices(self.webcam_switcher)
self.grid_layout.addWidget(self.webcam_switcher, 0, 1, 1, 3)
self.output_picture = QLabel()
self.grid_layout.addWidget(self.output_picture, 1, 0, 1, 4)
### creating right dock
self.right_dock_layout = QVBoxLayout()
self.right_dock_widget = QDockWidget()
self.right_dock_widget.setFeatures(QDockWidget.DockWidgetFeature.DockWidgetMovable | QDockWidget.DockWidgetFeature.DockWidgetFloatable)
self.right_dock_widget.setMinimumSize(self.screen_resolution.width() // 4, self.screen_resolution.height())
right_dock = QWidget(self.right_dock_widget)
right_dock.setMinimumSize(self.screen_resolution.width() // 4, self.screen_resolution.height())
right_dock.setLayout(self.right_dock_layout)
template_label = QLabel("Templates")
template_label.setMinimumSize(50, 25)
self.right_dock_layout.addWidget(template_label)
self.filter_template_edit = QLineEdit()
self.filter_template_edit.setPlaceholderText("Filter (Ctr + Alt + f)")
template_label.setMinimumSize(90, 25)
self.filter_template_edit.setStyleSheet(
"background-image: url(../image_difference/icons/searchIcon.png); background-repeat: no-repeat; background-position: right;")
self.right_dock_layout.addWidget(self.filter_template_edit)
self.file_system_model = QFileSystemModel()
self.file_system_model.setFilter(QDir.Filter.AllDirs | QDir.Filter.NoDotAndDotDot | QDir.Filter.AllEntries)
self.file_system_model.setRootPath(QDir.currentPath())
self.directory_tree_view = QTreeView()
self.directory_tree_view.setModel(self.file_system_model)
self.directory_tree_view.setMinimumSize(200, 100)
self.directory_tree_view.hideColumn(1)
self.directory_tree_view.hideColumn(2)
self.directory_tree_view.hideColumn(3)
# self.directory_tree_view.sortByColumn(0)
self.directory_tree_view.setSortingEnabled(True)
self.directory_tree_view.doubleClicked.connect(self.load_template)
self.directory_tree_view.setRootIndex(self.file_system_model.index("../image_difference/"))
self.right_dock_layout.addWidget(self.directory_tree_view)
self.load_template_button = QPushButton("Select Template")
self.load_template_button.setMaximumSize(self.screen_resolution.width() // 4 - 30, 30)
self.load_template_button.clicked.connect(self.load_template)
self.right_dock_layout.addWidget(self.load_template_button)
self.create_template_button = QPushButton("Create Template")
self.create_template_button.setMaximumSize(self.screen_resolution.width() // 4 - 30, 30)
self.create_template_button.clicked.connect(self.create_template)
self.right_dock_layout.addWidget(self.create_template_button)
self.template_image_widget = QWidget()
self.template_image_widget.setMinimumSize(self.screen_resolution.width() // 4 - 20,
self.screen_resolution.width() // 4 - 10)
self.template_image_back = QLabel(self.template_image_widget)
self.template_image_back.resize(self.screen_resolution.width() // 4 - 20,
self.screen_resolution.width() // 4 - 10)
pix = QPixmap(self.template_image_back.size())
pix.fill(Qt.lightGray)
rect = QRectF(0.0, 0.0, self.template_image_back.size().width(), self.template_image_back.size().height())
painter = QPainter()
painter.begin(pix)
painter.setRenderHints(QPainter.Antialiasing, True)
path = QPainterPath()
path.addRoundedRect(rect, 5.0, 5.0)
painter.drawPath(path)
painter.end()
self.template_image_back.setPixmap(pix)
self.template_image = QLabel(self.template_image_widget)
self.template_image.move(5, 5)
self.template_image.resize(self.screen_resolution.width() // 4 - 30, self.screen_resolution.width() // 4 - 30)
self.template_image_text = QLabel(self.template_image_widget, text="Current Template")
self.template_image_text.setStyleSheet("font-weight: bold")
self.template_image_text.move(self.screen_resolution.width() // 8 - 65, 20)
self.right_dock_layout.addWidget(self.template_image_widget)
self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.right_dock_widget)
### creating bottom dock
self.bottom_dock_layout = QGridLayout()
self.bottom_dock_layout.setSpacing(10)
self.bottom_dock_widget = QDockWidget()
self.bottom_dock_widget.setMinimumSize(self.screen_resolution.width() // 4 * 3 - 10,
self.screen_resolution.height() // 4 - 10)
bottom_dock = QWidget(self.bottom_dock_widget)
bottom_dock.setMinimumSize(self.screen_resolution.width() // 4 * 3 - 20,
self.screen_resolution.height() // 4 - 20)
bottom_dock.move(10, 10)
bottom_dock.setLayout(self.bottom_dock_layout)
settings_label = QLabel("Settings:")
self.bottom_dock_layout.addWidget(settings_label, 0, 0, 1, 2,
Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop)
countour_tresh_label = QLabel("Countour Tresh:")
self.bottom_dock_layout.addWidget(countour_tresh_label, 1, 0, 1, 1, Qt.AlignmentFlag.AlignTop)
self.countour_tresh_slider = QSlider(Qt.Orientation.Horizontal)
self.countour_tresh_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
self.countour_tresh_slider.setRange(self._countour_min_tresh, self._countour_max_tresh)
self.countour_tresh_slider.setValue(2)
self.bottom_dock_layout.addWidget(self.countour_tresh_slider, 1, 1, 1, 1, Qt.AlignmentFlag.AlignTop)
transparency_weight_label = QLabel("Transparency:")
self.bottom_dock_layout.addWidget(transparency_weight_label, 2, 0, 1, 1, Qt.AlignmentFlag.AlignTop)
self.transparency_weight_slider = QSlider(Qt.Orientation.Horizontal)
self.transparency_weight_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
self.transparency_weight_slider.setValue(6)
self.transparency_weight_slider.setRange(self._transparency_min, self._transparency_max)
self.bottom_dock_layout.addWidget(self.transparency_weight_slider, 2, 1, 1, 1, Qt.AlignmentFlag.AlignTop)
countour_gamma_label = QLabel("Countour Gamma:")
self.bottom_dock_layout.addWidget(countour_gamma_label, 3, 0, 1, 1, Qt.AlignmentFlag.AlignTop)
self.countour_gamma_slider = QSlider(Qt.Orientation.Horizontal)
self.countour_gamma_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
self.countour_gamma_slider.setValue(8)
self.countour_gamma_slider.setRange(self._countour_gamma_min, self._countour_gamma_max)
self.bottom_dock_layout.addWidget(self.countour_gamma_slider, 3, 1, 1, 1, Qt.AlignmentFlag.AlignTop)
### right side of settings
countour_color_label = QLabel("Countour Color:")
self.bottom_dock_layout.addWidget(countour_color_label, 0, 2, 1, 2,
Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop)
r_color_label = QLabel("R:")
self.bottom_dock_layout.addWidget(r_color_label, 1, 2, 1, 1, Qt.AlignmentFlag.AlignTop)
self.r_color_slider = QSlider(Qt.Orientation.Horizontal)
self.r_color_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
self.r_color_slider.setRange(self._color_min, self._color_max)
self.r_color_slider.setValue(255)
self.bottom_dock_layout.addWidget(self.r_color_slider, 1, 3, 1, 1, Qt.AlignmentFlag.AlignTop)
g_color_label = QLabel("G:")
self.bottom_dock_layout.addWidget(g_color_label, 2, 2, 1, 1, Qt.AlignmentFlag.AlignTop)
self.g_color_slider = QSlider(Qt.Orientation.Horizontal)
self.g_color_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
self.g_color_slider.setRange(self._color_min, self._color_max)
self.bottom_dock_layout.addWidget(self.g_color_slider, 2, 3, 1, 1, Qt.AlignmentFlag.AlignTop)
b_color_label = QLabel("B:")
self.bottom_dock_layout.addWidget(b_color_label, 3, 2, 1, 1, Qt.AlignmentFlag.AlignTop)
self.b_color_slider = QSlider(Qt.Orientation.Horizontal)
self.b_color_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
self.b_color_slider.setRange(self._color_min, self._color_max)
self.bottom_dock_layout.addWidget(self.b_color_slider, 3, 3, 1, 1, Qt.AlignmentFlag.AlignTop)
self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, self.bottom_dock_widget)
self.setCorner(Qt.Corner.BottomRightCorner, Qt.DockWidgetArea.RightDockWidgetArea)
def init_image_difference(self):
self.image_difference_thread = imageDifference()
self.get_template_filename.connect(self.image_difference_thread.set_template_image)
self.countour_tresh_slider.valueChanged.connect(self.image_difference_thread.set_countour_tresh_value)
self.transparency_weight_slider.valueChanged.connect(self.image_difference_thread.set_transparency_weight_value)
self.countour_gamma_slider.valueChanged.connect(self.image_difference_thread.set_countour_gamma_value)
self.r_color_slider.valueChanged.connect(self.image_difference_thread.set_countour_color_r)
self.g_color_slider.valueChanged.connect(self.image_difference_thread.set_countour_color_g)
self.b_color_slider.valueChanged.connect(self.image_difference_thread.set_countour_color_b)
self.image_difference_thread.output_image_defference.connect(self.mat2qimage)
self.image_difference_thread.set_template_picture.connect(self.set_template_picture)
self.image_difference_thread.start()
def detect_webcam_devices(self, combo_box):
_video_capture = cv2.VideoCapture()
_dev_id = 0
while (_dev_id < 3):
if _video_capture.open(_dev_id):
combo_box.addItem("Device #" + str(_dev_id + 1), _dev_id)
_dev_id += 1
else:
_dev_id += 1
_video_capture.release()
def load_template(self):
index = self.directory_tree_view.selectedIndexes()[0]
if not QFileInfo(self.file_system_model.filePath(index)).isDir():
# print("load template, path:", self.file_system_model.filePath(index))
self.get_template_filename.emit(self.file_system_model.filePath(index))
def create_template(self):
if self.stream is not None:
template_to_save = self.stream.get_current_frame()
cv2.imwrite("../image_difference/examples/template.jpg", template_to_save)
print("create template")
pyqtSlot(np.ndarray)
def mat2qimage(self, image):
rgbImage = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
rgbImage = cv2.resize(rgbImage, (self.output_picture.size().width(),
self.output_picture.size().height()))
# rgbImage = imutils.resize(rgbImage, height=self.output_picture.height())
h, w, ch = rgbImage.shape
bytesPerLine = ch * w
result_image = QImage(rgbImage.data, w, h, bytesPerLine, QImage.Format_RGB888)
self.output_picture.setPixmap(QPixmap.fromImage(result_image))
pyqtSlot(np.ndarray)
def set_template_picture(self, image):
rgbImage = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# rgbImage = cv2.resize(rgbImage, (self.template_image.size().width(),
# self.template_image.size().height()))
rgbImage = imutils.resize(rgbImage, self.template_image.size().width())
h, w, ch = rgbImage.shape
bytesPerLine = ch * w
result_image = QImage(rgbImage.data, w, h, bytesPerLine, QImage.Format_RGB888)
self.template_image.setPixmap(QPixmap.fromImage(result_image))
if not self.template_set:
self.template_set = True
self.stream.getframe.disconnect(self.mat2qimage)
self.stream.getframe.connect(self.image_difference_thread.get_image)
self.image_difference_thread.output_image_defference.connect(self.mat2qimage)
def camera_switcher_index_changed(self, index):
self.camera_changed.emit(self.webcam_switcher.itemData(index))
print("current index:", index)
print("item data:", self.webcam_switcher.itemData(index))
def closeEvent(self, event):
self.exit_program.emit()
event.accept()
def __init__(self, _format, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.toolBox.setStyleSheet(S.toolBoxSS())
self.mw = mainWindow()
self._format = _format
self.settings = {}
#################################################################
# Content
self.grpContentFilters.button.setChecked(False)
h = self.tblContent.horizontalHeader()
h.setSectionResizeMode(h.ResizeToContents)
h.setSectionResizeMode(0, h.Stretch)
self.contentUpdateTable()
self.chkContentMore.toggled.connect(self.contentTableToggle)
self.contentTableToggle(False)
# Labels
self.lstContentLabels.clear()
h = QFontMetrics(self.font()).height()
for i in range(0, self.mw.mdlLabels.rowCount()):
item = self.mw.mdlLabels.item(i, 0)
if item:
item = QListWidgetItem(item.icon(), item.text())
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked)
item.setSizeHint(QSize(100, h))
self.lstContentLabels.addItem(item)
self.chkContentLabels.toggled.connect(self.lstContentLabels.setVisible)
self.chkContentLabels.toggled.connect(lambda: self.listWidgetAdjustToContent(self.lstContentLabels))
self.lstContentLabels.setVisible(False)
# Status
self.lstContentStatus.clear()
h = QFontMetrics(self.font()).height()
for i in range(0, self.mw.mdlStatus.rowCount()):
item = self.mw.mdlStatus.item(i, 0)
if item:
item = QListWidgetItem(item.icon(), item.text())
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked)
item.setSizeHint(QSize(100, h))
self.lstContentStatus.addItem(item)
self.chkContentStatus.toggled.connect(self.lstContentStatus.setVisible)
self.chkContentStatus.toggled.connect(lambda: self.listWidgetAdjustToContent(self.lstContentStatus))
self.lstContentStatus.setVisible(False)
# Root item
self.cmbContentParent.setModel(self.mw.mdlOutline)
v = QTreeView()
self.cmbContentParent.setView(v)
v.setHeaderHidden(True)
for i in range(1, self.mw.mdlOutline.columnCount()):
v.hideColumn(i)
self.chkContentParent.toggled.connect(self.cmbContentParent.setVisible)
self.cmbContentParent.hide()
#################################################################
# Separations
for cmb in [self.cmbSepFF, self.cmbSepTT, self.cmbSepFT, self.cmbSepTF]:
cmb.clear()
cmb.addItem(self.tr("Empty line"), "empty")
cmb.addItem(self.tr("Custom"), "custom")
cmb.currentIndexChanged.connect(self.sepCmbChanged)
#################################################################
# Transformations
h = self.tblReplacements.horizontalHeader()
h.setSectionResizeMode(h.ResizeToContents)
h.setSectionResizeMode(1, h.Stretch)
h.setSectionResizeMode(2, h.Stretch)
# Cf. https://en.wikipedia.org/wiki/Quotation_mark
self.cmbTransDoubleQuotes.clear()
self.cmbTransDoubleQuotes.addItems(["”___“", "“___”", "«___»"])
self.cmbTransSingleQuote.clear()
self.cmbTransSingleQuote.addItems(["‘___’", "‹___›"])
for cmb in [self.cmbTransDoubleQuotes, self.cmbTransSingleQuote]:
cmb.addItem(self.tr("Custom"), "custom")
cmb.currentIndexChanged.connect(self.transCmbChanged)
cmb.currentIndexChanged.emit(0)
self.btnTransAdd.clicked.connect(lambda: self.transAddTableRow(checked=True))
self.btnTransRemove.clicked.connect(self.transRemoveTableRow)
self.tableWidgetAdjustToContent(self.tblReplacements)
#################################################################
# Preview
self.cmbPreviewFont.setCurrentFont(self.font())
self.spnPreviewSize.setValue(self.font().pointSize())
#################################################################
# Final stuff
self.toolBox.setCurrentIndex(0)
