class RightPanel(FuturaFrame):
side = "right"
def __init__(self, *args):
super(RightPanel, self).__init__(*args)
self.connect_signals()
self.label.setText('Recipe')
self.tree_view = QTreeView()
self.model = RecipeModel()
self.tree_view.setModel(self.model)
self.tree_view.setWordWrap(True)
self.tree_view.setColumnWidth(0, 50)
self.widget_layout.addWidget(self.tree_view)
signals.update_recipe.emit()
def connect_signals(self):
signals.update_recipe.connect(self.update_recipe)
def update_recipe(self):
self.model.parse_recipe(findMainWindow().loader.recipe)
if self.model.rowCount() == 0:
self.tree_view.header().hide()
else:
self.tree_view.header().show()
class FileSystemView(QWidget):
def __init__(self, dir_path):
super().__init__()
# appWidth = 800
# appHeight = 300
self.setWindowTitle('File System Viewer')
# self.setGeometry(300, 300, appWidth, appHeight)
self.model = QFileSystemModel()
self.model.setRootPath(dir_path)
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setRootIndex(self.model.index(dir_path))
self.tree.setColumnWidth(0, 250)
self.tree.setAlternatingRowColors(True)
layout = QVBoxLayout()
layout.addWidget(self.tree)
self.setLayout(layout)
class TriageFilePicker(QWidget):
def __init__(self, context):
super(TriageFilePicker, self).__init__()
self.context = context
self.actionHandler = UIActionHandler()
self.actionHandler.setupActionHandler(self)
self.contextMenu = Menu()
self.contextMenuManager = ContextMenuManager(self)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.model = QFileSystemModel()
self.model.setRootPath("")
self.model.setFilter(QDir.AllEntries | QDir.Hidden | QDir.System)
self.tree = QTreeView(self)
self.tree.setModel(self.model)
self.tree.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.tree.setColumnWidth(0, 500)
layout.addWidget(self.tree, 1)
self.setLayout(layout)
self.tree.doubleClicked.connect(self.onDoubleClick)
recentFile = QSettings().value("triage/recentFile", os.path.expanduser("~"))
while len(recentFile) > 0:
f = self.model.index(recentFile)
if f.isValid():
self.tree.scrollTo(f)
self.tree.setExpanded(f, True)
break
parentDir = os.path.dirname(recentFile)
if parentDir == recentFile:
break
recentFile = parentDir
self.actionHandler.bindAction("Open Selected Files", UIAction(
lambda context: self.openSelectedFiles(),
lambda context: self.areFilesSelected()))
self.contextMenu.addAction("Open Selected Files", "Open")
def contextMenuEvent(self, event):
self.contextMenuManager.show(self.contextMenu, self.actionHandler)
def onDoubleClick(self, index):
self.openSelectedFiles()
def openSelectedFiles(self):
failedToOpen = []
files = set()
for index in self.tree.selectionModel().selectedIndexes():
if self.model.fileInfo(index).isFile():
files.add(self.model.fileInfo(index).absoluteFilePath())
for filename in files:
QSettings().setValue("triage/recentFile", filename)
f = FileContext.openFilename(filename)
if not f:
failedToOpen.append(filename)
continue
f.createBinaryViews()
for data in f.getAllDataViews():
Settings().set_string("analysis.mode", Settings().get_string("triage.analysisMode"), data)
Settings().set_bool("triage.preferSummaryView", True, data)
if data.view_type != "Raw":
linearSweepMode = Settings().get_string("triage.linearSweep")
if linearSweepMode == "none":
Settings().set_bool("analysis.linearSweep.autorun", False, data)
elif linearSweepMode == "partial":
Settings().set_bool("analysis.linearSweep.autorun", True, data)
Settings().set_bool("analysis.linearSweep.controlFlowGraph", False, data)
elif linearSweepMode == "full":
Settings().set_bool("analysis.linearSweep.autorun", True, data)
Settings().set_bool("analysis.linearSweep.controlFlowGraph", True, data)
self.context.openFileContext(f)
if len(failedToOpen) > 0:
QMessageBox.critical(self, "Error", "Unable to open:\n" + "\n".join(failedToOpen))
def areFilesSelected(self):
return self.tree.selectionModel().hasSelection()
class MyWidget(QtWidgets.QWidget):
@Slot()
def run_report(self):
dialog = ReportNameDialog()
if dialog.exec_():
metadata_fields = {}
item_model = self.list.model()
for i in range(item_model.rowCount()):
qmodel_index = item_model.index(i, 0)
index_name = item_model.item(i, 0).text()
if item_model.itemData(qmodel_index).get(10) == 2:
metadata_fields[index_name] = ""
if hasattr(item_model.item(i, 1), "text"):
index_value = item_model.item(i, 1).text()
if index_name == DOCUMENT_TYPE:
if index_value == TYPE_ASSET:
index_value = "IO"
if index_value == TYPE_FOLDER:
index_value = "SO"
if index_value == TYPE_ANY:
index_value = ""
metadata_fields[index_name] = index_value
self.progress = QProgressDialog(
"Creating Report\n\nPlease Wait...", None, 0, 100)
self.progress.setModal(True)
self.progress.setWindowTitle("Report")
self.progress.setAutoClose(True)
self.progress.setAutoReset(True)
self.callback = CallBack()
worker = Worker(self.client, self.search_value.text(),
dialog.report(), metadata_fields, self.callback,
dialog.auto_report())
self.callback.change_value.connect(self.progress.setValue)
self.callback.max_value.connect(self.progress.setMaximum)
self.callback.reset_dialog.connect(self.progress.reset)
self.threadpool.start(worker)
self.progress.show()
def __init__(self):
super().__init__()
self.threadpool = QThreadPool()
self.threadpool.setMaxThreadCount(1)
self.setWindowTitle("Preservica Solr Reporting")
self.windowModality()
self.progress = None
self.callback = None
self.search_label = QtWidgets.QLabel(
"Main Search Term (% returns everything)")
self.search_value = QtWidgets.QLineEdit("%")
self.help_label = QtWidgets.QLabel(
"Select from the list of indexed fields below to "
"add columns to the output spreadsheet\n\n"
"Indexes can have an optional filter term. Filters "
"are only applied to selected fields")
self.list = QTreeView()
self.list.setSelectionBehavior(QAbstractItemView.SelectRows)
model = QStandardItemModel()
model.setHorizontalHeaderLabels(['Index Name', 'Index Filter Term'])
self.list.setModel(model)
self.list.setUniformRowHeights(True)
self.list.setAlternatingRowColors(True)
self.list.setColumnWidth(0, 350)
self.list.setColumnWidth(1, 250)
self.list.setItemDelegateForColumn(
1, ComboDelegate(self.list, DOCUMENT_TYPE, model))
if not os.path.isfile("credentials.properties"):
dialog = PasswordDialog()
if dialog.exec_():
self.client = ContentAPI(dialog.username(), dialog.password(),
dialog.tenant(), dialog.server())
else:
raise SystemExit
else:
self.client = ContentAPI()
for index_name in self.client.indexed_fields():
if index_name == "xip.full_text":
continue
index = QStandardItem(index_name)
index.setCheckable(True)
index.setEditable(False)
model.appendRow([index])
self.run_report_button = QtWidgets.QPushButton("Run Report")
self.run_report_button.released.connect(self.run_report)
self.list.setModel(model)
self.layout = QtWidgets.QVBoxLayout()
self.layout.addWidget(self.search_label)
self.layout.addWidget(self.search_value)
self.layout.addWidget(self.help_label)
self.layout.addWidget(self.list)
self.layout.addWidget(self.run_report_button)
self.setLayout(self.layout)
def create_ui(self):
"""Setup main UI elements, dock widgets, UI-related elements, etc.
"""
log.debug('Loading UI')
# Undo Stack
self.undo_stack = QUndoStack(self)
self.undo_stack.setUndoLimit(100)
# Object navigation history
self.obj_history = deque([], config.MAX_OBJ_HISTORY)
app = QApplication.instance()
base_font = QFont()
base_font.fromString(self.prefs['base_font'])
app.setFont(base_font)
# Object class table widget
# classTable = QTableView(self)
classTable = classtable.TableView(self)
classTable.setObjectName("classTable")
classTable.setAlternatingRowColors(True)
classTable.setFrameShape(QFrame.StyledPanel)
classTable_font = QFont()
classTable_font.fromString(self.prefs['class_table_font'])
classTable.setFont(classTable_font)
fm = classTable.fontMetrics()
classTable.setWordWrap(True)
classTable.setEditTriggers(QAbstractItemView.EditKeyPressed |
QAbstractItemView.DoubleClicked |
QAbstractItemView.AnyKeyPressed |
QAbstractItemView.SelectedClicked)
# classTable.horizontalHeader().setMovable(True)
# classTable.verticalHeader().setMovable(False)
classTable.horizontalHeader().setSectionResizeMode(QHeaderView.Interactive)
classTable.verticalHeader().setSectionResizeMode(QHeaderView.Interactive)
classTable.horizontalHeader().setDefaultSectionSize(self.prefs['default_column_width'])
classTable.verticalHeader().setDefaultSectionSize(fm.height() + 0)
classTable.setSelectionMode(QAbstractItemView.ExtendedSelection)
classTable.setContextMenuPolicy(Qt.CustomContextMenu)
classTable.customContextMenuRequested.connect(self.custom_table_context_menu)
# Create table model and proxy layers for transposing and filtering
self.classTableModel = classtable.IDFObjectTableModel(classTable)
self.transposeableModel = classtable.TransposeProxyModel(self.classTableModel)
self.transposeableModel.setSourceModel(self.classTableModel)
self.sortableModel = classtable.SortFilterProxyModel(self.transposeableModel)
self.sortableModel.setSourceModel(self.transposeableModel)
# Assign model to table (enable sorting FIRST)
# table.setSortingEnabled(True) # Disable for now, CRUD actions won't work!
classTable.setModel(self.sortableModel)
# Connect some signals
selection_model = classTable.selectionModel()
selection_model.selectionChanged.connect(self.table_selection_changed)
scroll_bar = classTable.verticalScrollBar()
scroll_bar.valueChanged.connect(self.scroll_changed)
# These are currently broken
# classTable.horizontalHeader().sectionMoved.connect(self.moveObject)
# classTable.verticalHeader().sectionMoved.connect(self.moveObject)
# Object class tree widget
classTreeDockWidget = QDockWidget("Object Classes and Counts", self)
classTreeDockWidget.setObjectName("classTreeDockWidget")
classTreeDockWidget.setAllowedAreas(Qt.AllDockWidgetAreas)
classTree = QTreeView(classTreeDockWidget)
classTree.setUniformRowHeights(True)
classTree.setAllColumnsShowFocus(True)
classTree.setRootIsDecorated(False)
classTree.setExpandsOnDoubleClick(True)
classTree.setIndentation(15)
classTree.setAnimated(True)
classTree_font = QFont()
classTree_font.fromString(self.prefs['class_tree_font'])
classTree.setFont(classTree_font)
classTree.setAlternatingRowColors(True)
classTree.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
palette = classTree.palette()
palette.setColor(QPalette.Highlight, Qt.darkCyan)
classTree.setPalette(palette)
class_tree_window = QWidget(classTreeDockWidget)
class_tree_dock_layout_v = QVBoxLayout()
class_tree_dock_layout_h = QHBoxLayout()
class_tree_dock_layout_v.setContentsMargins(0, 8, 0, 0)
class_tree_dock_layout_h.setContentsMargins(0, 0, 0, 0)
class_tree_filter_edit = QLineEdit(classTreeDockWidget)
class_tree_filter_edit.setPlaceholderText("Filter Classes")
class_tree_filter_edit.textChanged.connect(self.treeFilterRegExpChanged)
class_tree_filter_cancel = QPushButton("Clear", classTreeDockWidget)
class_tree_filter_cancel.setMaximumWidth(45)
class_tree_filter_cancel.clicked.connect(self.clearTreeFilterClicked)
class_tree_dock_layout_h.addWidget(class_tree_filter_edit)
class_tree_dock_layout_h.addWidget(class_tree_filter_cancel)
class_tree_dock_layout_v.addLayout(class_tree_dock_layout_h)
class_tree_dock_layout_v.addWidget(classTree)
class_tree_window.setLayout(class_tree_dock_layout_v)
classTreeDockWidget.setWidget(class_tree_window)
classTreeDockWidget.setContentsMargins(0,0,0,0)
# Comments widget
commentDockWidget = QDockWidget("Comments", self)
commentDockWidget.setObjectName("commentDockWidget")
commentDockWidget.setAllowedAreas(Qt.AllDockWidgetAreas)
commentView = UndoRedoTextEdit(commentDockWidget, self)
commentView.setLineWrapMode(QTextEdit.FixedColumnWidth)
commentView.setLineWrapColumnOrWidth(499)
commentView.setFrameShape(QFrame.StyledPanel)
commentView_font = QFont()
commentView_font.fromString(self.prefs['comments_font'])
commentView.setFont(commentView_font)
commentDockWidget.setWidget(commentView)
# Info and help widget
infoDockWidget = QDockWidget("Info", self)
infoDockWidget.setObjectName("infoDockWidget")
infoDockWidget.setAllowedAreas(Qt.AllDockWidgetAreas)
infoView = QTextEdit(infoDockWidget)
infoView.setFrameShape(QFrame.StyledPanel)
infoView.setReadOnly(True)
infoDockWidget.setWidget(infoView)
# Node list and jump menu widget
refDockWidget = QDockWidget("Field References", self)
refDockWidget.setObjectName("refDockWidget")
refDockWidget.setAllowedAreas(Qt.AllDockWidgetAreas)
ref_model = reftree.ReferenceTreeModel(None, refDockWidget)
refView = QTreeView(refDockWidget)
refView.setModel(ref_model)
refView.setUniformRowHeights(True)
refView.setRootIsDecorated(False)
refView.setIndentation(15)
refView.setColumnWidth(0, 160)
refView.setFrameShape(QFrame.StyledPanel)
refDockWidget.setWidget(refView)
refView.doubleClicked.connect(self.ref_tree_double_clicked)
# Logging and debugging widget
logDockWidget = QDockWidget("Log Viewer", self)
logDockWidget.setObjectName("logDockWidget")
logDockWidget.setAllowedAreas(Qt.AllDockWidgetAreas)
logView = QPlainTextEdit(logDockWidget)
logView.setLineWrapMode(QPlainTextEdit.NoWrap)
logView.setReadOnly(True)
logView_font = QFont()
logView_font.fromString(self.prefs['base_font'])
logView.setFont(logView_font)
logView.ensureCursorVisible()
logDockWidget.setWidget(logView)
# Undo view widget
undoDockWidget = QDockWidget("Undo History", self)
undoDockWidget.setObjectName("undoDockWidget")
undoDockWidget.setAllowedAreas(Qt.AllDockWidgetAreas)
undoView = QUndoView(self.undo_stack)
undoDockWidget.setWidget(undoView)
# Define corner docking behaviour
self.setDockNestingEnabled(True)
self.setCorner(Qt.TopLeftCorner,
Qt.LeftDockWidgetArea)
self.setCorner(Qt.TopRightCorner,
Qt.RightDockWidgetArea)
self.setCorner(Qt.BottomLeftCorner,
Qt.LeftDockWidgetArea)
self.setCorner(Qt.BottomRightCorner,
Qt.RightDockWidgetArea)
# Assign main widget and dock widgets to QMainWindow
self.setCentralWidget(classTable)
self.addDockWidget(Qt.LeftDockWidgetArea, classTreeDockWidget)
self.addDockWidget(Qt.RightDockWidgetArea, commentDockWidget)
self.addDockWidget(Qt.RightDockWidgetArea, infoDockWidget)
self.addDockWidget(Qt.RightDockWidgetArea, refDockWidget)
self.addDockWidget(Qt.RightDockWidgetArea, logDockWidget)
self.addDockWidget(Qt.RightDockWidgetArea, undoDockWidget)
# Store widgets for access by other objects
self.classTable = classTable
self.commentView = commentView
self.infoView = infoView
self.classTree = classTree
self.logView = logView
self.undoView = undoView
self.refView = refView
self.filterTreeBox = class_tree_filter_edit
# Store docks for access by other objects
self.commentDockWidget = commentDockWidget
self.infoDockWidget = infoDockWidget
self.classTreeDockWidget = classTreeDockWidget
self.logDockWidget = logDockWidget
self.undoDockWidget = undoDockWidget
self.refDockWidget = refDockWidget
# Perform other UI-related initialization tasks
self.center()
self.setUnifiedTitleAndToolBarOnMac(True)
self.setWindowIcon(QIcon(':/images/logo.png'))
# Status bar setup
self.statusBar().showMessage('Status: Ready')
self.unitsLabel = QLabel()
self.unitsLabel.setAlignment(Qt.AlignCenter)
self.unitsLabel.setMinimumSize(self.unitsLabel.sizeHint())
self.unitsLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.statusBar().addPermanentWidget(self.unitsLabel)
self.pathLabel = QLabel()
self.pathLabel.setAlignment(Qt.AlignCenter)
self.pathLabel.setMinimumSize(self.pathLabel.sizeHint())
self.pathLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.statusBar().addPermanentWidget(self.pathLabel)
self.versionLabel = QLabel()
self.versionLabel.setAlignment(Qt.AlignCenter)
self.versionLabel.setMinimumSize(self.versionLabel.sizeHint())
self.versionLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.statusBar().addPermanentWidget(self.versionLabel)
self.progressBarIDF = QProgressBar()
self.progressBarIDF.setAlignment(Qt.AlignCenter)
self.progressBarIDF.setMaximumWidth(200)
self.statusBar().addPermanentWidget(self.progressBarIDF)
self.clipboard = QApplication.instance().clipboard()
self.obj_clipboard = []
self.setStyleSheet("""
QToolTip {
background-color: gray;
color: white;
border: black solid 1px
}
# QMenu {
# background-color: rgbf(0.949020, 0.945098, 0.941176);
# color: rgb(255,255,255);
# }
# QMenu::item::selected {
# background-color: rgbf(0.949020, 0.945098, 0.941176);
# }
""")
class MP3TagManipulator(QWidget):
last_directory = '.'
song = None
def __init__(self):
super().__init__()
self.title = 'MP3TagManipulator v1.0'
self.top = 100
self.left = 100
self.height = 400
self.width = 640
self.init_ui()
def init_ui(self):
self.setWindowTitle(self.title)
self.setGeometry(self.top, self.left, self.width, self.height)
# layout root of application
main_layout = QVBoxLayout(self)
self.setLayout(main_layout)
# to set the model of tree
model = QFileSystemModel()
model.setRootPath("/home/denison/Downloads/music")
model.setNameFilters(['*.mp3', '*.m4a', '*.flac'])
model.setNameFilterDisables(False)
self.tree = QTreeView()
self.tree.setModel(model)
self.tree.setAnimated(True)
self.tree.setColumnWidth(0, 500)
file_layout = QHBoxLayout()
label_file = QLabel('file/directory')
text_file = QLineEdit()
btn_load = QPushButton('load')
file_layout.addWidget(label_file)
file_layout.addWidget(text_file)
file_layout.addWidget(btn_load)
grid_info_layout = QGridLayout()
# strings to labels
self.labels = [
'ARTIST', 'ALBUMARTIST', 'ALBUM', 'TITLE', 'GENRE', 'DATE'
]
# line edits to tags
self.text_artist = QLineEdit('ARTIST')
self.text_album = QLineEdit('ALBUM')
self.text_album_artist = QLineEdit('ALBUMARTIST')
self.text_title = QLineEdit('TITLE')
self.text_genre = QLineEdit('GENRE')
self.text_date = QLineEdit('DATE')
self.text_tags = [
self.text_artist, self.text_album_artist, self.text_album,
self.text_title, self.text_genre, self.text_date
]
for text in self.text_tags:
text.setEnabled(False)
#text.textChanged.connect(self.enable_save)
# labels
for label, i in zip(self.labels, range(6)):
grid_info_layout.addWidget(QLabel(label), i, 0)
# cb_artist = QCheckBox()
# cb_album_artist = QCheckBox()
# cb_album = QCheckBox()
# cb_title = QCheckBox()
# cb_genre = QCheckBox()
# cb_date = QCheckBox()
# self.checkboxes = [
# cb_artist, cb_album_artist, cb_album,
# cb_title, cb_genre, cb_date
# ]
# for cb in self.checkboxes:
# cb.setText('editar')
# cb_artist.stateChanged.connect(lambda: self.enable_tag_edit(self.text_artist))
# cb_album_artist.stateChanged.connect(lambda: self.enable_tag_edit(self.text_album_artist))
# cb_album.stateChanged.connect(lambda: self.enable_tag_edit(self.text_album))
# cb_title.stateChanged.connect(lambda: self.enable_tag_edit(self.text_title))
# cb_genre.stateChanged.connect(lambda: self.enable_tag_edit(self.text_genre))
# cb_date.stateChanged.connect(lambda: self.enable_tag_edit(self.text_date))
for i, text in zip(range(6), self.text_tags):
grid_info_layout.addWidget(text, i, 1)
# for cb, i in zip(self.checkboxes, range(6)) :
# grid_info_layout.addWidget(cb, i, 2)
action_layout = QHBoxLayout()
btn_exit = QPushButton('Exit')
self.btn_save = QPushButton('save changes')
self.btn_save.setDisabled(True)
action_layout.addWidget(btn_exit)
action_layout.addWidget(self.btn_save)
#main_layout.addLayout(file_layout)
main_layout.addWidget(self.tree)
main_layout.addLayout(grid_info_layout)
main_layout.addLayout(action_layout)
btn_load.clicked.connect(self.open_file)
btn_exit.clicked.connect(self.close_application)
self.btn_save.clicked.connect(self.edit_tags)
self.tree.doubleClicked.connect(self.get_selected_file)
self.show()
def enable_edit_text(self):
if self.song:
for t in self.text_tags:
t.setEnabled(True)
self.enable_save()
else:
for t in self.text_tags:
t.setEnabled(False)
def enable_save(self):
self.btn_save.setEnabled(True)
def close_application(self):
if self.song:
self.song.close()
print('vazando...;-)')
self.close()
def enable_tag_edit(self, txt_edit):
txt_edit.setEnabled(not txt_edit.isEnabled())
for edit in self.text_tags:
edit.textChanged.connect(self.enable_save)
print('executou self.enable_tag_edit()')
print('não sei o q tá acontecendo :(')
def get_selected_file(self):
print('executou self.get_selected_file()')
selected = self.tree.selectedIndexes()[0]
print(selected.model().filePath(selected))
self.song = taglib.File(selected.model().filePath(selected))
self.enable_edit_text()
self.load_song_info(self.song)
return self.song
def edit_tags(self):
print("não tá funcionando 8'-(")
self.song.tags['ARTIST'] = self.text_artist.text()
self.song.tags['ALBUMARTIST'] = self.text_album_artist.text()
self.song.tags['ALBUM'] = self.text_album.text()
self.song.tags['TITLE'] = self.text_title.text()
self.song.tags['GENRE'] = self.text_genre.text()
self.song.tags['DATE'] = self.text_date.text()
self.song.save()
print(self.song.tags)
self.btn_save.setDisabled(True)
self.song.close()
def open_file(self):
print('*** quase lá *** ')
dialog = QFileDialog(self)
dialog.setViewMode(QFileDialog.Detail)
file = dialog.getOpenFileName(self, 'load...', self.last_directory,
'songs (*.mp3 *.m4a *.flac *.wma)')
song = taglib.File(file[0])
# print(song.tags)
self.show_song_info(song)
song.close()
def load_song_info(self, song):
print('executou self.load_song_info()')
for t, tag in zip(self.text_tags, self.labels):
try:
t.setText(song.tags[tag][0])
except KeyError:
t.setText('none')
class MyWindow(QWidget):
def __init__(self, *args):
super().__init__()
self.setFixedSize(930, 631)
self.setLocale(QLocale(QLocale.English, QLocale.UnitedStates))
self.setWindowTitle(
QCoreApplication.translate("MainWindow", "PyInspect"))
self.central_widget = QWidget(self)
self.comboBox = QComboBox(self.central_widget)
self.comboBox.setGeometry(QRect(10, 10, 451, 22))
self.comboBox.setMouseTracking(False)
self.comboBox.setMaxVisibleItems(5)
self.comboBox.setObjectName("comboBox")
for _backend in backend.registry.backends.keys():
self.comboBox.addItem(_backend)
self.tree_view = QTreeView(self.central_widget)
self.tree_view.setGeometry(QRect(10, 40, 451, 581))
self.tree_view.setColumnWidth(0, 150)
self.comboBox.setCurrentText('uia')
self.__show_tree()
self.table_view = QTableView(self.central_widget)
self.table_view.setGeometry(QRect(470, 40, 451, 581))
self.comboBox.activated[str].connect(self.__show_tree)
self.tree_view.clicked.connect(self.__show_property)
def __show_tree(self, _backend='uia'):
self.__initialize_calc(_backend)
def __initialize_calc(self, _backend):
self.element_info = backend.registry.backends[
_backend].element_info_class()
self.tree_model = MyTreeModel(self.element_info, _backend)
self.tree_model.setHeaderData(0, Qt.Horizontal, 'Controls')
self.tree_view.setModel(self.tree_model)
def __show_property(self, index=None):
data = index.data()
self.table_model = MyTableModel(self.tree_model.props_dict.get(data),
self)
self.table_view.wordWrap()
self.table_view.setModel(self.table_model)
self.table_view.setColumnWidth(1, 320)
element = self.tree_model.element_dict.get(data, None)
if element is not None:
with contextlib.suppress(Exception):
element.set_focus()
locate_element = center_locate_element(element)
if locate_element is not None:
pyperclip.copy('{0}, {1}'.format(*locate_element))
else:
pyperclip.copy('Retângulo não identificado.')
try:
im: Image = element.capture_as_image()
im.show()
except:
alert(
title='Atenção',
text=
'O elemento selecionado não é uma imagem ou não contém o atributo show.'
)
element.draw_outline(colour='green', thickness=4)
class ApplicationPage(QWidget):
host: "Host"
def __init__(self, host: "Host", **kwargs):
super().__init__(**kwargs)
self.host = host
self.model = AppStoreModel(self, self.host.app_store)
self._layout()
def _layout(self):
layout = QHBoxLayout(self)
self.setLayout(layout)
self.tree = QTreeView(self)
self.tree.setModel(self.model)
self.tree.setUniformRowHeights(True)
self.tree.setColumnWidth(0, 200)
self.tree.setDragEnabled(True)
self.tree.setDragDropMode(QAbstractItemView.InternalMove)
self.tree.viewport().setAcceptDrops(True)
layout.addWidget(self.tree, 1)
buttons = QVBoxLayout()
buttons.setAlignment(Qt.AlignTop)
add_button = QPushButton(QIcon.fromTheme("list-add"), "", self)
add_button.setToolTip("Add application")
add_button.clicked.connect(self.on_add)
buttons.addWidget(add_button)
mkdir_button = QPushButton(QIcon.fromTheme("folder-new"), "", self)
mkdir_button.setToolTip("Make directory")
mkdir_button.clicked.connect(self.on_mkdir)
buttons.addWidget(mkdir_button)
delete_button = QPushButton(QIcon.fromTheme("list-remove"), "", self)
delete_button.setToolTip("Remove selected item")
delete_button.clicked.connect(self.on_delete)
buttons.addWidget(delete_button)
layout.addLayout(buttons)
def on_add(self):
dialog = QInputDialog(self)
dialog.setLabelText("Enter appconfig.json URL")
if dialog.exec_() == QInputDialog.Rejected:
return
app_url = dialog.textValue().strip()
self.host.app_store.add_app_ui([app_url])
def on_mkdir(self):
dialog = QInputDialog(self)
dialog.setLabelText("Directory name")
if dialog.exec_() == QInputDialog.Rejected:
return
dirname = dialog.textValue().strip()
if not dirname or "/" in dirname:
QMessageBox.critical(self, "Invalid input",
"This directory name cannot be used")
return
self.host.app_store.mkdir(dirname)
def on_delete(self):
data = self.model.mimeData(self.tree.selectedIndexes())
if not data:
return
data = json.loads(
data.data("application/x-qabstractitemmodeldatalist").data())
if data["type"] == "dir":
confirm = QMessageBox.question(
self,
"Remove folder",
f"Remove {data['id']}?\n\nAll applications will be moved to the top level",
)
if confirm == QMessageBox.StandardButton.No:
return
self.host.app_store.rmdir(data["id"])
else:
app = self.host.app_store[data["id"]]
confirm = QMessageBox.question(
self,
"Remove application",
f"Remove {app['appName']}?",
)
if confirm == QMessageBox.StandardButton.No:
return
self.host.app_store.remove_app(data["id"])
class ClassTreeWidget(QDialog):
"""
TreeView widget to show pyleecan classes structured by their inheritance together
with the selected class description.
"""
def __init__(self, keys=None, expand=True):
super(ClassTreeWidget, self).__init__()
self.setupUi()
self.expandAll = expand
self.setMinimumHeight(600)
# === default variables ===
self.classDict = ClassInfo().get_dict()
self.keys = keys or ClassInfo().get_base_classes() # TODO all classes
self.selectionModel = self.treeView.selectionModel()
# === Signals ===
self.selectionModel.selectionChanged.connect(self.onSelectionChanged)
self.treeView.doubleClicked.connect(self.onClassSelected)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
# === Generate content ===
self.generate()
def onClassSelected(self, index):
"""Method to accept the selection if a class was double clicked."""
if index.isValid():
self.accept()
def onSelectionChanged(self, itSelection):
""" """
index = itSelection.indexes()[0]
desc = index.model().itemFromIndex(index).data()
self.text.setText(desc)
def getSelectedClass(self):
"""Get the currently selected class by its name."""
index = self.selectionModel.selectedIndexes()[0]
return index.model().itemFromIndex(index).text()
def setupUi(self):
"""Init. the UI."""
self.setWindowIcon(QIcon(ICON))
# === Widgets ===
# TreeView
model = QtGui.QStandardItemModel(0, 1)
model.setHorizontalHeaderLabels(["Class"])
self.treeView = QTreeView()
self.treeView.rootNode = model.invisibleRootItem()
self.treeView.setModel(model)
self.treeView.setAlternatingRowColors(False)
# size options
# setting min. width in self.generate to fit content
self.treeView.setContextMenuPolicy(Qt.CustomContextMenu)
# Hide Debug Columns
# self.treeView.hideColumn(1)
# text output
self.text = QLabel()
self.text.setAlignment(Qt.AlignTop)
self.text.setWordWrap(True)
self.text.setMinimumWidth(300)
# Splitters
self.splitter = QSplitter(self)
self.splitter.setStretchFactor(0, 0)
self.splitter.setStretchFactor(1, 1)
self.splitter.addWidget(self.treeView)
self.splitter.addWidget(self.text)
# dialog buttons
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel
) # window to create confirmation and cancellation buttons
# === Layout ===
# Horizontal Div.
layout = QVBoxLayout()
# layout.setContentsMargins(0, 0, 0, 0)
# layout.setSpacing(0)
layout.addWidget(self.splitter)
layout.addWidget(self.buttons)
self.setLayout(layout)
def generate(self):
"""Method to (recursively) build the tree (view) of the data object."""
self.treeDict = dict()
for key in self.keys:
self.genTreeDict(key, self.treeDict)
self.genTreeView(self.treeDict)
# set first row active & expand all branches
index = self.treeView.model().index(0, 0)
self.treeView.setCurrentIndex(index)
self.treeView.expandAll()
wHint = self.treeView.sizeHintForColumn(0)
self.treeView.setMinimumWidth(wHint)
self.treeView.setColumnWidth(0, wHint)
if not self.expandAll:
self.treeView.collapseAll()
def genTreeDict(self, key, parent):
"""Generate a dict structure of the classes recursively on the parent dict."""
parent[key] = dict()
for typ in self.classDict[key]["daughters"]:
if key == self.classDict[typ]["mother"]:
self.genTreeDict(typ, parent[key])
def genTreeView(self, tree, parent=None):
"""Generate the view item structure on the parent item."""
# init if root
if parent is None:
parent = self.treeView.rootNode
self.treeView.rootNode.removeRows(
0, self.treeView.rootNode.rowCount())
for key, item in tree.items():
desc = (
f"Class: {key} \nPackage: {self.classDict[key]['package']}" +
f"\nDescription: {self.classDict[key]['desc']}")
row = self.addRow(parent, key, desc)
if item:
self.genTreeView(item, parent=row)
def addRow(self, parent, name="", desc=""):
"""Add a new row to the parent item."""
item = QtGui.QStandardItem(name)
item.setEditable(False)
item.setData(desc)
parent.appendRow([item])
return item