def set_button_states(
component_tree_view: QTreeView,
delete_action: QAction,
duplicate_action: QAction,
new_rotation_action: QAction,
new_translation_action: QAction,
create_link_action: QAction,
zoom_action: QAction,
edit_component_action: QAction,
):
"""
Changes the button states based on user interaction with the component tree view.
:param component_tree_view: The component tree view.
:param delete_action: The action for deleting an item.
:param duplicate_action: The action for duplicating an item.
:param new_rotation_action: The action for creating a new rotation.
:param new_translation_action: The action for creating a new translation.
:param create_link_action: The action for creating a link.
:param zoom_action: The action for zooming on a component.
:param edit_component_action: The action for editing a component.
"""
selection_indices = component_tree_view.selectedIndexes()
if len(selection_indices) != 1:
handle_number_of_items_selected_is_not_one(
create_link_action,
delete_action,
duplicate_action,
new_rotation_action,
new_translation_action,
zoom_action,
)
else:
selected_object = selection_indices[0].internalPointer()
selected_object_is_component = isinstance(selected_object, Component)
zoom_action.setEnabled(selected_object_is_component)
selected_object_is_component_or_transform = isinstance(
selected_object, (Component, Transformation))
duplicate_action.setEnabled(selected_object_is_component_or_transform)
edit_component_action.setEnabled(selected_object_is_component)
selected_object_is_not_link_transform = not isinstance(
selected_object, LinkTransformation)
new_rotation_action.setEnabled(selected_object_is_not_link_transform)
new_translation_action.setEnabled(
selected_object_is_not_link_transform)
delete_action.setEnabled(selected_object_is_component_or_transform
or not selected_object_is_not_link_transform)
if isinstance(selected_object, Component):
if not hasattr(selected_object, "stored_transforms"):
selected_object.stored_transforms = selected_object.transforms
create_link_action.setEnabled(
not selected_object.stored_transforms.has_link)
elif isinstance(selected_object, TransformationsList):
create_link_action.setEnabled(not selected_object.has_link)
elif isinstance(selected_object, Transformation):
create_link_action.setEnabled(not selected_object.parent.has_link)
else:
create_link_action.setEnabled(False)
class VfsDirWidget(QWidget):
def __init__(self, vfs_view, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
self.vnode_2click_selected = None
# Getting the Model
self.source_model = VfsDirModel()
# Creating a QTableView
self.view = QTreeView()
self.view.doubleClicked.connect(self.double_clicked)
self.view.clicked.connect(self.clicked)
self.view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.view.setSelectionMode(QAbstractItemView.ExtendedSelection)
font = self.view.font()
font.setPointSize(8)
self.view.setFont(font)
self.view.setModel(self.source_model)
# # QTableView Headers
self.header = self.view.header()
self.header.setSectionResizeMode(QHeaderView.ResizeToContents)
self.header.setStretchLastSection(True)
size = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
size.setHorizontalStretch(1)
self.view.setSizePolicy(size)
self.main_layout = QHBoxLayout()
self.main_layout.addWidget(self.view)
self.setLayout(self.main_layout)
self.source_model.vfs_view_set(vfs_view)
def vfs_view_get(self):
return self.source_model.vfs_view_get()
def clicked(self, index):
if index.isValid():
if self.source_model.vfs_view is not None:
items = self.view.selectedIndexes()
items = list(set([idx.internalPointer() for idx in items]))
items = [
idx.v_path() for idx in items
if isinstance(idx, VfsDirLeaf)
or isinstance(idx, VfsDirBranch)
]
self.source_model.vfs_view.paths_set(items)
def double_clicked(self, index):
if index.isValid():
tnode = index.internalPointer()
if isinstance(
tnode,
VfsDirLeaf) and self.vnode_2click_selected is not None:
self.vnode_2click_selected(tnode.uids_hard)
def add_transformation(
transformation_type: TransformationType,
component_tree_view: QTreeView,
component_model: ComponentTreeModel,
):
selected = component_tree_view.selectedIndexes()
if len(selected) > 0:
current_index = selected[0]
if transformation_type == TransformationType.TRANSLATION:
component_model.add_translation(current_index)
elif transformation_type == TransformationType.ROTATION:
component_model.add_rotation(current_index)
else:
raise ValueError(f"Unknown transformation type: {transformation_type}")
expand_transformation_list(current_index, component_tree_view, component_model)
class Snippets(QDialog):
def __init__(self, parent=None):
super(Snippets, self).__init__(parent)
# Create widgets
self.setWindowModality(Qt.NonModal)
self.title = QLabel(self.tr("Snippet Editor"))
self.saveButton = QPushButton(self.tr("Save"))
self.revertButton = QPushButton(self.tr("Revert"))
self.clearHotkeyButton = QPushButton(self.tr("Clear Hotkey"))
self.setWindowTitle(self.title.text())
self.newFolderButton = QPushButton("New Folder")
self.deleteSnippetButton = QPushButton("Delete")
self.newSnippetButton = QPushButton("New Snippet")
self.edit = QPlainTextEdit()
self.resetting = False
self.columns = 3
self.keySequenceEdit = QKeySequenceEdit(self)
self.currentHotkey = QKeySequence()
self.currentHotkeyLabel = QLabel("")
self.currentFileLabel = QLabel()
self.currentFile = ""
self.snippetDescription = QLineEdit()
self.snippetEditsPending = False
self.clearSelection()
#Set Editbox Size
font = getMonospaceFont(self)
self.edit.setFont(font)
font = QFontMetrics(font)
self.edit.setTabStopWidth(4 * font.width(' ')); #TODO, replace with settings API
#Files
self.files = QFileSystemModel()
self.files.setRootPath(snippetPath)
self.files.setNameFilters(["*.py"])
#Tree
self.tree = QTreeView()
self.tree.setModel(self.files)
self.tree.setSortingEnabled(True)
self.tree.hideColumn(2)
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.tree.setRootIndex(self.files.index(snippetPath))
for x in range(self.columns):
#self.tree.resizeColumnToContents(x)
self.tree.header().setSectionResizeMode(x, QHeaderView.ResizeToContents)
treeLayout = QVBoxLayout()
treeLayout.addWidget(self.tree)
treeButtons = QHBoxLayout()
treeButtons.addWidget(self.newFolderButton)
treeButtons.addWidget(self.newSnippetButton)
treeButtons.addWidget(self.deleteSnippetButton)
treeLayout.addLayout(treeButtons)
treeWidget = QWidget()
treeWidget.setLayout(treeLayout)
# Create layout and add widgets
buttons = QHBoxLayout()
buttons.addWidget(self.clearHotkeyButton)
buttons.addWidget(self.keySequenceEdit)
buttons.addWidget(self.currentHotkeyLabel)
buttons.addWidget(self.revertButton)
buttons.addWidget(self.saveButton)
description = QHBoxLayout()
description.addWidget(QLabel(self.tr("Description: ")))
description.addWidget(self.snippetDescription)
vlayoutWidget = QWidget()
vlayout = QVBoxLayout()
vlayout.addWidget(self.currentFileLabel)
vlayout.addWidget(self.edit)
vlayout.addLayout(description)
vlayout.addLayout(buttons)
vlayoutWidget.setLayout(vlayout)
hsplitter = QSplitter()
hsplitter.addWidget(treeWidget)
hsplitter.addWidget(vlayoutWidget)
hlayout = QHBoxLayout()
hlayout.addWidget(hsplitter)
self.showNormal() #Fixes bug that maximized windows are "stuck"
self.settings = QSettings("Vector 35", "Snippet Editor")
if self.settings.contains("ui/snippeteditor/geometry"):
self.restoreGeometry(self.settings.value("ui/snippeteditor/geometry"))
else:
self.edit.setMinimumWidth(80 * font.averageCharWidth())
self.edit.setMinimumHeight(30 * font.lineSpacing())
# Set dialog layout
self.setLayout(hlayout)
# Add signals
self.saveButton.clicked.connect(self.save)
self.revertButton.clicked.connect(self.loadSnippet)
self.clearHotkeyButton.clicked.connect(self.clearHotkey)
self.tree.selectionModel().selectionChanged.connect(self.selectFile)
self.newSnippetButton.clicked.connect(self.newFileDialog)
self.deleteSnippetButton.clicked.connect(self.deleteSnippet)
self.newFolderButton.clicked.connect(self.newFolder)
def registerAllSnippets(self):
for action in list(filter(lambda x: x.startswith("Snippet\\"), UIAction.getAllRegisteredActions())):
UIActionHandler.globalActions().unbindAction(action)
UIAction.unregisterAction(action)
for snippet in includeWalk(snippetPath, ".py"):
(snippetDescription, snippetKey, snippetCode) = loadSnippetFromFile(snippet)
if not snippetDescription:
actionText = "Snippet\\" + snippet
else:
actionText = "Snippet\\" + snippetDescription
UIAction.registerAction(actionText, snippetKey)
UIActionHandler.globalActions().bindAction(actionText, UIAction(makeSnippetFunction(snippetCode)))
def clearSelection(self):
self.keySequenceEdit.clear()
self.currentHotkey = QKeySequence()
self.currentHotkeyLabel.setText("")
self.currentFileLabel.setText("")
self.snippetDescription.setText("")
self.edit.setPlainText("")
def reject(self):
self.settings.setValue("ui/snippeteditor/geometry", self.saveGeometry())
if self.snippetChanged():
question = QMessageBox.question(self, self.tr("Discard"), self.tr("You have unsaved changes, quit anyway?"))
if question != QMessageBox.StandardButton.Yes:
return
self.accept()
def newFolder(self):
(folderName, ok) = QInputDialog.getText(self, self.tr("Folder Name"), self.tr("Folder Name: "))
if ok and folderName:
index = self.tree.selectionModel().currentIndex()
selection = self.files.filePath(index)
if QFileInfo(selection).isDir():
QDir(selection).mkdir(folderName)
else:
QDir(snippetPath).mkdir(folderName)
def selectFile(self, new, old):
if (self.resetting):
self.resetting = False
return
newSelection = self.files.filePath(new.indexes()[0])
if QFileInfo(newSelection).isDir():
self.clearSelection()
return
if old.length() > 0:
oldSelection = self.files.filePath(old.indexes()[0])
if not QFileInfo(oldSelection).isDir() and self.snippetChanged():
question = QMessageBox.question(self, self.tr("Discard"), self.tr("Snippet changed. Discard changes?"))
if question != QMessageBox.StandardButton.Yes:
self.resetting = True
self.tree.selectionModel().select(old, QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
return False
self.currentFile = newSelection
self.loadSnippet()
def loadSnippet(self):
self.currentFileLabel.setText(QFileInfo(self.currentFile).baseName())
log_debug("Loading %s as a snippet." % self.currentFile)
(snippetDescription, snippetKey, snippetCode) = loadSnippetFromFile(self.currentFile)
self.snippetDescription.setText(snippetDescription) if snippetDescription else self.snippetDescription.setText("")
self.keySequenceEdit.setKeySequence(snippetKey[0]) if len(snippetKey) != 0 else self.keySequenceEdit.setKeySequence(QKeySequence(""))
self.edit.setPlainText(snippetCode) if snippetCode else self.edit.setPlainText("")
def newFileDialog(self):
(snippetName, ok) = QInputDialog.getText(self, self.tr("Snippet Name"), self.tr("Snippet Name: "))
if ok and snippetName:
if not snippetName.endswith(".py"):
snippetName += ".py"
index = self.tree.selectionModel().currentIndex()
selection = self.files.filePath(index)
if QFileInfo(selection).isDir():
open(os.path.join(selection, snippetName), "w").close()
else:
open(os.path.join(snippetPath, snippetName), "w").close()
log_debug("Snippet %s created." % snippetName)
def deleteSnippet(self):
selection = self.tree.selectedIndexes()[::self.columns][0] #treeview returns each selected element in the row
snippetName = self.files.fileName(selection)
question = QMessageBox.question(self, self.tr("Confirm"), self.tr("Confirm deletion: ") + snippetName)
if (question == QMessageBox.StandardButton.Yes):
log_debug("Deleting snippet %s." % snippetName)
self.clearSelection()
self.files.remove(selection)
def snippetChanged(self):
if (self.currentFile == "" or QFileInfo(self.currentFile).isDir()):
return False
(snippetDescription, snippetKey, snippetCode) = loadSnippetFromFile(self.currentFile)
if (not snippetCode):
return False
if len(snippetKey) == 0 and not self.keySequenceEdit.keySequence().isEmpty():
return True
if len(snippetKey) != 0 and snippetKey[0] != self.keySequenceEdit.keySequence():
return True
return self.edit.toPlainText() != snippetCode or \
self.snippetDescription.text() != snippetDescription
def save(self):
log_debug("Saving snippet %s" % self.currentFile)
outputSnippet = open(self.currentFile, "w")
outputSnippet.write("#" + self.snippetDescription.text() + "\n")
outputSnippet.write("#" + self.keySequenceEdit.keySequence().toString() + "\n")
outputSnippet.write(self.edit.toPlainText())
outputSnippet.close()
self.registerAllSnippets()
def clearHotkey(self):
self.keySequenceEdit.clear()
class MainWindow(QMainWindow):
def __init__(self, app):
super(MainWindow, self).__init__()
self._app = app
self._selectedIndex = None
# model
nodeFactory = NodeFactory()
rootNode = nodeFactory.create(NodeType.General, 'Root')
# for i in range(10000): # for testing
childNode0 = nodeFactory.create(NodeType.General, 'RightPirateLeg',
rootNode)
childNode1 = nodeFactory.create(NodeType.General, 'RightPirateLeg_END',
childNode0)
childNode2 = nodeFactory.create(NodeType.General, 'LeftFemur',
rootNode)
childNode3 = nodeFactory.create(NodeType.Sphere, 'LeftTibia',
childNode2)
childNode4 = nodeFactory.create(NodeType.Sphere, 'LeftFoot',
childNode3)
transform = childNode4.component(ComponentType.Transform)
qTransform = transform.component()
translation = qTransform.translation()
translation.setX(5)
qTransform.setTranslation(translation)
# childNode5 = nodeFactory.create(NodeType.Box, 'LeftFoot_END', childNode4)
self._model = SceneGraphModel(rootNode)
self._sceneView = SceneView(rootNode.entity())
self._container = self.createWindowContainer(self._sceneView)
# scene graph view
self._treeView = QTreeView()
self._treeView.setModel(self._model)
self._treeView.setHeaderHidden(True)
self._treeView.setAlternatingRowColors(True)
dockWidget = QDockWidget()
dockWidget.setWidget(self._treeView)
dockWidget.setWindowTitle('Scene Graph')
dockWidget.setObjectName('sceneGraph')
sceneGraphToggleAction = dockWidget.toggleViewAction()
self.addDockWidget(Qt.LeftDockWidgetArea, dockWidget)
# property editor
propertyEditor = PropertyEditor(self._model, nodeFactory,
FieldFactory())
dockWidget = QDockWidget()
dockWidget.setWidget(propertyEditor)
dockWidget.setWindowTitle('Property Editor')
dockWidget.setObjectName('propertyEditor')
propertyEditorToggleAction = dockWidget.toggleViewAction()
self.addDockWidget(Qt.RightDockWidgetArea, dockWidget)
# menu
menuBar = self.menuBar()
menu = menuBar.addMenu('&File')
exitAction = menu.addAction('E&xit')
exitAction.triggered.connect(self.close)
menu.addAction(exitAction)
menu = menuBar.addMenu('&Windows')
menu.addAction(sceneGraphToggleAction)
menu.addAction(propertyEditorToggleAction)
menuBar.addMenu(menu)
# central widget
#button = QPushButton()
self.setCentralWidget(self._container)
# selection change event
selectionModel = self._treeView.selectionModel()
selectionModel.currentChanged.connect(propertyEditor.changeSelection)
# click event
#button.clicked.connect(self.buttonClicked)
def selectedNode(self):
indices = self._treeView.selectedIndexes()
result = None
if len(indices) == 1:
self._selectedIndex = indices[0]
result = self._selectedIndex.internalPointer()
return result
def commitChange(self):
self._model.dataChanged.emit(self._selectedIndex, self._selectedIndex)
def closeEvent(self, event):
self._app.exit()
# data change example
def buttonClicked(self):
node = self.selectedNode()
if not node:
return
general = node.component(ComponentType.General)
general.setName('CLICKED')
self.commitChange()
def set_button_states(
component_tree_view: QTreeView,
new_component_action: QAction,
delete_action: QAction,
new_rotation_action: QAction,
new_translation_action: QAction,
create_link_action: QAction,
zoom_action: QAction,
edit_component_action: QAction,
):
"""
Changes the button states based on user interaction with the component tree view.
:param component_tree_view: The component tree view.
:param delete_action: The action for deleting an item.
:param new_rotation_action: The action for creating a new rotation.
:param new_translation_action: The action for creating a new translation.
:param create_link_action: The action for creating a link.
:param zoom_action: The action for zooming on a component.
:param edit_component_action: The action for editing a component.
"""
selection_indices = component_tree_view.selectedIndexes()
if len(selection_indices) != 1:
handle_number_of_items_selected_is_not_one(
new_component_action,
create_link_action,
delete_action,
new_rotation_action,
new_translation_action,
zoom_action,
edit_component_action,
)
else:
selected_object = selection_indices[0].internalPointer()
selected_object_is_component = isinstance(selected_object, Component)
selected_object_is_group = isinstance(selected_object, Group)
allowed_transformation_action = is_transformation_action_allowed(
selected_object)
set_enabled_and_raise(zoom_action, selected_object_is_component)
is_transform_group = False
if selected_object_is_group:
is_transform_group = selected_object.nx_class == NX_TRANSFORMATIONS
set_enabled_and_raise(
new_component_action, selected_object_is_group
and not is_transform_group)
set_enabled_and_raise(
edit_component_action, selected_object_is_group
and not is_transform_group)
selected_object_is_not_link_transform = not isinstance(
selected_object, LinkTransformation)
set_enabled_and_raise(
new_rotation_action,
selected_object_is_not_link_transform
and allowed_transformation_action,
)
set_enabled_and_raise(
new_translation_action,
selected_object_is_not_link_transform
and allowed_transformation_action,
)
not_tree_root = True
if hasattr(selected_object,
"parent_node") and not selected_object.parent_node:
not_tree_root = False
set_enabled_and_raise(delete_action, not_tree_root)
if isinstance(selected_object, Component):
if selected_object.stored_transforms is None:
selected_object.stored_transforms = selected_object.transforms
add_link_enabled = (len(selected_object.stored_transforms) and
not selected_object.stored_transforms.has_link)
set_enabled_and_raise(create_link_action, add_link_enabled)
elif (isinstance(selected_object, Group)
and selected_object.nx_class == "NXtransformations"):
set_enabled_and_raise(
create_link_action,
not selected_object.parent_node.transforms.has_link)
elif isinstance(selected_object, Transformation):
set_enabled_and_raise(
create_link_action,
not selected_object.parent_component.transforms.has_link,
)
else:
set_enabled_and_raise(create_link_action, False)
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 ComponentTreeViewTab(QWidget):
def __init__(self, parent=None):
super().__init__()
self.setLayout(QVBoxLayout())
self.setParent(parent)
self.componentsTabLayout = QVBoxLayout()
self.component_tree_view = QTreeView()
self.componentsTabLayout.addWidget(self.component_tree_view)
self.layout().addLayout(self.componentsTabLayout)
self.component_tree_view.setDragEnabled(True)
self.component_tree_view.setAcceptDrops(True)
self.component_tree_view.setDropIndicatorShown(True)
self.component_tree_view.header().hide()
self.component_tree_view.updateEditorGeometries()
self.component_tree_view.updateGeometries()
self.component_tree_view.updateGeometry()
self.component_tree_view.clicked.connect(self._set_button_state)
self.component_tree_view.setSelectionMode(QAbstractItemView.SingleSelection)
self.component_tool_bar = QToolBar("Actions", self)
self.new_component_action = create_and_add_toolbar_action(
"new_component.png",
"New Component",
self.parent().show_add_component_window,
self.component_tool_bar,
self,
True,
)
self.new_translation_action = create_and_add_toolbar_action(
"new_translation.png",
"New Translation",
lambda: self._add_transformation(TransformationType.TRANSLATION),
self.component_tool_bar,
self,
)
self.new_rotation_action = create_and_add_toolbar_action(
"new_rotation.png",
"New Rotation",
lambda: self._add_transformation(TransformationType.ROTATION),
self.component_tool_bar,
self,
)
self.create_link_action = create_and_add_toolbar_action(
"create_link.png",
"Create Link",
self.on_create_link,
self.component_tool_bar,
self,
)
self.duplicate_action = create_and_add_toolbar_action(
"duplicate.png",
"Duplicate",
self.on_duplicate_node,
self.component_tool_bar,
self,
)
self.edit_component_action = create_and_add_toolbar_action(
"edit_component.png",
"Edit Component",
self.parent().show_edit_component_dialog,
self.component_tool_bar,
self,
)
self.delete_action = create_and_add_toolbar_action(
"delete.png", "Delete", self.on_delete_item, self.component_tool_bar, self
)
self.zoom_action = create_and_add_toolbar_action(
"zoom.svg",
"Zoom To Component",
self.on_zoom_item,
self.component_tool_bar,
self,
)
self.component_tool_bar.insertSeparator(self.zoom_action)
self.componentsTabLayout.insertWidget(0, self.component_tool_bar)
def set_up_model(self, instrument):
self.component_model = ComponentTreeModel(instrument)
self.component_delegate = ComponentEditorDelegate(
self.component_tree_view, instrument
)
self.component_tree_view.setItemDelegate(self.component_delegate)
self.component_tree_view.setModel(self.component_model)
def _set_button_state(self):
set_button_states(
self.component_tree_view,
self.delete_action,
self.duplicate_action,
self.new_rotation_action,
self.new_translation_action,
self.create_link_action,
self.zoom_action,
self.edit_component_action,
)
def on_create_link(self):
selected = self.component_tree_view.selectedIndexes()
if len(selected) > 0:
self.component_model.add_link(selected[0])
self._expand_transformation_list(selected[0])
self._set_button_state()
def on_duplicate_node(self):
selected = self.component_tree_view.selectedIndexes()
if len(selected) > 0:
self.component_model.duplicate_node(selected[0])
self._expand_transformation_list(selected[0])
def _expand_transformation_list(self, node: QModelIndex):
expand_transformation_list(node, self.component_tree_view, self.component_model)
def _add_transformation(self, transformation_type: TransformationType):
add_transformation(
transformation_type, self.component_tree_view, self.component_model
)
def on_delete_item(self):
selected = self.component_tree_view.selectedIndexes()
for item in selected:
self.component_model.remove_node(item)
self._set_button_state()
def on_zoom_item(self):
selected = self.component_tree_view.selectedIndexes()[0]
component = selected.internalPointer()
self.sceneWidget.zoom_to_component(
self.sceneWidget.get_entity(component.name), self.sceneWidget.view.camera()
)
class CatsTreeWindow(PBDialog):
"""Extension of `PBDialog` that shows the categories tree"""
def __init__(
self,
parent=None,
askCats=False,
askForBib=None,
askForExp=None,
expButton=True,
previous=[],
single=False,
multipleRecords=False,
):
"""Initialize instance parameters and call the function that
creates the layout.
Parameters:
parent (default None): the parent widget
askCats (default False): if True, enable checkboxes for
selection of categories
askForBib (default None): the optional key which identifies
in the database the bibtex entry for which categories
are being selected
askForExp (default None): the optional ID which identifies
in the database the experiment for which categories
are being selected
expButton (default True): if True, add a button to accept
the widget content and later ask for experiments
previous (default []): the list of categories that
must be selected at the beginning
single (default False): if True, only allow the selection
of a single category (the parent category, typically).
Multiple checkboxes can be selected,
but only the first one will be considered
multipleRecords: used when dealing with categories
corresponding to multiple records. Activate a tristate
checkbox for the initial list of categories, which are
typically not the same for all the elements in the list
"""
PBDialog.__init__(self, parent)
self.setWindowTitle(cwstr.cats)
self.currLayout = QVBoxLayout(self)
self.setLayout(self.currLayout)
self.askCats = askCats
self.askForBib = askForBib
self.askForExp = askForExp
self.expButton = expButton
self.previous = previous
self.single = single
self.multipleRecords = multipleRecords
self.result = False
self.marked = []
self.root_model = None
self.proxyModel = None
self.tree = None
self.menu = None
self.timer = None
self.expsButton = None
self.filterInput = None
self.newCatButton = None
self.acceptButton = None
self.cancelButton = None
self.setMinimumWidth(400)
self.setMinimumHeight(600)
self.createForm()
def populateAskCat(self):
"""If selection of categories is allowed, add some information
on the bibtex/experiment for which the categories are requested
and a simple message, then create few required empty lists
"""
if self.askCats:
if self.askForBib is not None:
try:
bibitem = pBDB.bibs.getByBibkey(self.askForBib,
saveQuery=False)[0]
except IndexError:
pBGUILogger.warning(
cwstr.entryNotInDb % self.askForBib,
exc_info=True,
)
return
try:
if bibitem["inspire"] != "" and bibitem[
"inspire"] is not None:
link = "<a href='%s'>%s</a>" % (
pBView.getLink(self.askForBib, "inspire"),
self.askForBib,
)
elif bibitem["arxiv"] != "" and bibitem[
"arxiv"] is not None:
link = "<a href='%s'>%s</a>" % (
pBView.getLink(self.askForBib, "arxiv"),
self.askForBib,
)
elif bibitem["doi"] != "" and bibitem["doi"] is not None:
link = "<a href='%s'>%s</a>" % (
pBView.getLink(self.askForBib, "doi"),
self.askForBib,
)
else:
link = self.askForBib
bibtext = PBLabel(
cwstr.markCatBibKAT %
(link, bibitem["author"], bibitem["title"]))
except KeyError:
bibtext = PBLabel(cwstr.markCatBibK % (self.askForBib))
self.currLayout.addWidget(bibtext)
elif self.askForExp is not None:
try:
expitem = pBDB.exps.getByID(self.askForExp)[0]
except IndexError:
pBGUILogger.warning(
cwstr.expNotInDb % self.askForExp,
exc_info=True,
)
return
try:
exptext = PBLabel(
cwstr.markCatExpINC %
(self.askForExp, expitem["name"], expitem["comments"]))
except KeyError:
exptext = PBLabel(cwstr.markCatExpI % (self.askForExp))
self.currLayout.addWidget(exptext)
else:
if self.single:
comment = PBLabel(cwstr.selectCat)
else:
comment = PBLabel(cwstr.selectCats)
self.currLayout.addWidget(comment)
self.marked = []
self.parent().selectedCats = []
return True
def onCancel(self):
"""Reject the dialog content and close the window"""
self.result = False
self.close()
def onOk(self, exps=False):
"""Accept the dialog content
(update the list of selected categories)
and close the window.
May set `self.result` to "Exps"
for later opening of a new dialog to ask for experiments.
Parameter:
exps (default False): if True, set the result to "Exps",
otherwise to "Ok"
"""
self.parent().selectedCats = [
idC for idC in self.root_model.selectedCats.keys()
if self.root_model.selectedCats[idC] == True
]
self.parent().previousUnchanged = [
idC for idC in self.root_model.previousSaved.keys()
if self.root_model.previousSaved[idC] == True
]
if (self.single and len(self.parent().selectedCats) > 1
and self.parent().selectedCats[0] == 0):
self.parent().selectedCats.pop(0)
self.parent().selectedCats = [self.parent().selectedCats[0]]
self.result = "Exps" if exps else "Ok"
self.close()
def changeFilter(self, string):
"""When the filter `QLineEdit` is changed,
update the `LeafFilterProxyModel` regexp filter
Parameter:
string: the new filter string
"""
self.proxyModel.setFilterRegExp(str(string))
self.tree.expandAll()
def onAskExps(self):
"""Action to perform when the selection of categories
will be folloed by the selection of experiments.
Call `self.onOk` with `exps = True`.
"""
self.onOk(exps=True)
def onNewCat(self):
"""Action to perform when the creation
of a new category is requested
"""
editCategory(self, self.parent())
def keyPressEvent(self, e):
"""Manage the key press events.
Do nothing unless `Esc` is pressed:
in this case close the dialog
"""
if e.key() == Qt.Key_Escape:
self.close()
def createForm(self):
"""Create the dialog content, connect the model to the view
and eventually add the buttons at the end
"""
self.populateAskCat()
catsTree = pBDB.cats.getHier()
self.filterInput = QLineEdit("", self)
self.filterInput.setPlaceholderText(cwstr.filterCat)
self.filterInput.textChanged.connect(self.changeFilter)
self.currLayout.addWidget(self.filterInput)
self.filterInput.setFocus()
self.tree = QTreeView(self)
self.currLayout.addWidget(self.tree)
self.tree.setMouseTracking(True)
self.tree.entered.connect(self.handleItemEntered)
self.tree.doubleClicked.connect(self.cellDoubleClick)
self.tree.setExpandsOnDoubleClick(False)
catsNamedTree = self._populateTree(catsTree[0], 0)
self.root_model = CatsModel(
pBDB.cats.getAll(),
[catsNamedTree],
self,
self.previous,
multipleRecords=self.multipleRecords,
)
self.proxyModel = LeafFilterProxyModel(self)
self.proxyModel.setSourceModel(self.root_model)
self.proxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.proxyModel.setSortCaseSensitivity(Qt.CaseInsensitive)
self.proxyModel.setFilterKeyColumn(-1)
self.tree.setModel(self.proxyModel)
self.tree.expandAll()
self.tree.setHeaderHidden(True)
# self.tree.doubleClicked.connect(self.askAndPerformAction)
self.newCatButton = QPushButton(cwstr.addNew, self)
self.newCatButton.clicked.connect(self.onNewCat)
self.currLayout.addWidget(self.newCatButton)
if self.askCats:
self.acceptButton = QPushButton(cwstr.ok, self)
self.acceptButton.clicked.connect(self.onOk)
self.currLayout.addWidget(self.acceptButton)
if self.expButton:
self.expsButton = QPushButton(cwstr.askExp, self)
self.expsButton.clicked.connect(self.onAskExps)
self.currLayout.addWidget(self.expsButton)
# cancel button
self.cancelButton = QPushButton(cwstr.cancel, self)
self.cancelButton.clicked.connect(self.onCancel)
self.cancelButton.setAutoDefault(True)
self.currLayout.addWidget(self.cancelButton)
def _populateTree(self, children, idCat):
"""Read the list of categories recursively and
populate the categories tree
Parameters:
children: the list of children categories
of the currently considered one
idCat: the id of the current category
"""
name = pBDB.cats.getByID(idCat)[0]["name"]
children_list = []
for child in cats_alphabetical(children, pBDB):
child_item = self._populateTree(children[child], child)
children_list.append(child_item)
return NamedElement(idCat, name, children_list)
def handleItemEntered(self, index):
"""Process event when mouse enters an item and
create a `QTooltip` which describes the category, with a timer
Parameter:
index: a `QModelIndex` instance
"""
if index.isValid():
row = index.row()
else:
return
try:
idString = self.proxyModel.sibling(row, 0, index).data()
except AttributeError:
pBLogger.debug("", exc_info=True)
return
try:
idCat, catName = idString.split(": ")
except AttributeError:
pBLogger.debug("", exc_info=True)
return
idCat = idCat.strip()
try:
self.timer.stop()
QToolTip.showText(QCursor.pos(), "", self.tree.viewport())
except AttributeError:
pass
try:
catData = pBDB.cats.getByID(idCat)[0]
except IndexError:
pBGUILogger.exception(cwstr.failedFind)
return
self.timer = QTimer(self)
self.timer.setSingleShot(True)
self.timer.timeout.connect(lambda: QToolTip.showText(
QCursor.pos(),
cwstr.catId.format(idC=idCat, cat=catData["name"]) + cwstr.
entriesCorrespondent.format(en=pBDB.catBib.countByCat(idCat)) +
cwstr.expsAssociated.format(ex=pBDB.catExp.countByCat(idCat)),
self.tree.viewport(),
self.tree.visualRect(index),
3000,
))
self.timer.start(500)
def contextMenuEvent(self, event):
"""Create a right click menu with few actions
on the selected category
Parameter:
event: a `QEvent`
"""
indexes = self.tree.selectedIndexes()
try:
index = indexes[0]
except IndexError:
pBLogger.debug(cwstr.clickMissingIndex)
return
if index.isValid():
row = index.row()
else:
return
try:
idString = self.proxyModel.sibling(row, 0, index).data()
except AttributeError:
pBLogger.debug("", exc_info=True)
return
try:
idCat, catName = idString.split(": ")
except AttributeError:
pBLogger.debug("", exc_info=True)
return
idCat = idCat.strip()
menu = PBMenu()
self.menu = menu
titAction = QAction(cwstr.catDescr % catName)
titAction.setDisabled(True)
bibAction = QAction(cwstr.openEntryList)
modAction = QAction(cwstr.modify)
delAction = QAction(cwstr.delete)
subAction = QAction(cwstr.addSub)
menu.possibleActions = [
titAction,
None,
bibAction,
None,
modAction,
delAction,
None,
subAction,
]
menu.fillMenu()
action = menu.exec_(event.globalPos())
if action == bibAction:
self.parent().reloadMainContent(pBDB.bibs.getByCat(idCat))
elif action == modAction:
editCategory(self, self.parent(), idCat)
elif action == delAction:
deleteCategory(self, self.parent(), idCat, catName)
elif action == subAction:
editCategory(self, self.parent(), useParentCat=idCat)
return
def cellDoubleClick(self, index):
"""Process event when mouse double clicks an item.
Opens a link if some columns
Parameter:
index: a `QModelIndex` instance
"""
if index.isValid():
row = index.row()
col = index.column()
else:
return
try:
idString = self.proxyModel.sibling(row, 0, index).data()
except AttributeError:
pBLogger.debug("", exc_info=True)
return
try:
idCat, catName = idString.split(": ")
except AttributeError:
pBLogger.debug("", exc_info=True)
return
idCat = idCat.strip()
self.parent().reloadMainContent(pBDB.bibs.getByCat(idCat))
return
def recreateTable(self):
"""Delete the previous widgets and recreate them with new data"""
self.cleanLayout()
self.createForm()
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 Snippets(QDialog):
def __init__(self, context, parent=None):
super(Snippets, self).__init__(parent)
# Create widgets
self.setWindowModality(Qt.ApplicationModal)
self.title = QLabel(self.tr("Snippet Editor"))
self.saveButton = QPushButton(self.tr("&Save"))
self.saveButton.setShortcut(QKeySequence(self.tr("Ctrl+S")))
self.runButton = QPushButton(self.tr("&Run"))
self.runButton.setShortcut(QKeySequence(self.tr("Ctrl+R")))
self.closeButton = QPushButton(self.tr("Close"))
self.clearHotkeyButton = QPushButton(self.tr("Clear Hotkey"))
self.setWindowTitle(self.title.text())
#self.newFolderButton = QPushButton("New Folder")
self.browseButton = QPushButton("Browse Snippets")
self.browseButton.setIcon(QIcon.fromTheme("edit-undo"))
self.deleteSnippetButton = QPushButton("Delete")
self.newSnippetButton = QPushButton("New Snippet")
self.edit = QCodeEditor(HIGHLIGHT_CURRENT_LINE=False, SyntaxHighlighter=PythonHighlighter)
self.edit.setPlaceholderText("python code")
self.resetting = False
self.columns = 3
self.context = context
self.keySequenceEdit = QKeySequenceEdit(self)
self.currentHotkey = QKeySequence()
self.currentHotkeyLabel = QLabel("")
self.currentFileLabel = QLabel()
self.currentFile = ""
self.snippetDescription = QLineEdit()
self.snippetDescription.setPlaceholderText("optional description")
#Set Editbox Size
font = getMonospaceFont(self)
self.edit.setFont(font)
font = QFontMetrics(font)
self.edit.setTabStopWidth(4 * font.width(' ')); #TODO, replace with settings API
#Files
self.files = QFileSystemModel()
self.files.setRootPath(snippetPath)
self.files.setNameFilters(["*.py"])
#Tree
self.tree = QTreeView()
self.tree.setModel(self.files)
self.tree.setSortingEnabled(True)
self.tree.hideColumn(2)
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.tree.setRootIndex(self.files.index(snippetPath))
for x in range(self.columns):
#self.tree.resizeColumnToContents(x)
self.tree.header().setSectionResizeMode(x, QHeaderView.ResizeToContents)
treeLayout = QVBoxLayout()
treeLayout.addWidget(self.tree)
treeButtons = QHBoxLayout()
#treeButtons.addWidget(self.newFolderButton)
treeButtons.addWidget(self.browseButton)
treeButtons.addWidget(self.newSnippetButton)
treeButtons.addWidget(self.deleteSnippetButton)
treeLayout.addLayout(treeButtons)
treeWidget = QWidget()
treeWidget.setLayout(treeLayout)
# Create layout and add widgets
buttons = QHBoxLayout()
buttons.addWidget(self.clearHotkeyButton)
buttons.addWidget(self.keySequenceEdit)
buttons.addWidget(self.currentHotkeyLabel)
buttons.addWidget(self.closeButton)
buttons.addWidget(self.runButton)
buttons.addWidget(self.saveButton)
description = QHBoxLayout()
description.addWidget(QLabel(self.tr("Description: ")))
description.addWidget(self.snippetDescription)
vlayoutWidget = QWidget()
vlayout = QVBoxLayout()
vlayout.addLayout(description)
vlayout.addWidget(self.edit)
vlayout.addLayout(buttons)
vlayoutWidget.setLayout(vlayout)
hsplitter = QSplitter()
hsplitter.addWidget(treeWidget)
hsplitter.addWidget(vlayoutWidget)
hlayout = QHBoxLayout()
hlayout.addWidget(hsplitter)
self.showNormal() #Fixes bug that maximized windows are "stuck"
#Because you can't trust QT to do the right thing here
if (sys.platform == "darwin"):
self.settings = QSettings("Vector35", "Snippet Editor")
else:
self.settings = QSettings("Vector 35", "Snippet Editor")
if self.settings.contains("ui/snippeteditor/geometry"):
self.restoreGeometry(self.settings.value("ui/snippeteditor/geometry"))
else:
self.edit.setMinimumWidth(80 * font.averageCharWidth())
self.edit.setMinimumHeight(30 * font.lineSpacing())
# Set dialog layout
self.setLayout(hlayout)
# Add signals
self.saveButton.clicked.connect(self.save)
self.closeButton.clicked.connect(self.close)
self.runButton.clicked.connect(self.run)
self.clearHotkeyButton.clicked.connect(self.clearHotkey)
self.tree.selectionModel().selectionChanged.connect(self.selectFile)
self.newSnippetButton.clicked.connect(self.newFileDialog)
self.deleteSnippetButton.clicked.connect(self.deleteSnippet)
#self.newFolderButton.clicked.connect(self.newFolder)
self.browseButton.clicked.connect(self.browseSnippets)
if self.settings.contains("ui/snippeteditor/selected"):
selectedName = self.settings.value("ui/snippeteditor/selected")
self.tree.selectionModel().select(self.files.index(selectedName), QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
if self.tree.selectionModel().hasSelection():
self.selectFile(self.tree.selectionModel().selection(), None)
self.edit.setFocus()
cursor = self.edit.textCursor()
cursor.setPosition(self.edit.document().characterCount()-1)
self.edit.setTextCursor(cursor)
else:
self.readOnly(True)
else:
self.readOnly(True)
@staticmethod
def registerAllSnippets():
for action in list(filter(lambda x: x.startswith("Snippets\\"), UIAction.getAllRegisteredActions())):
if action == "Snippets\\Snippet Editor...":
continue
UIActionHandler.globalActions().unbindAction(action)
Menu.mainMenu("Tools").removeAction(action)
UIAction.unregisterAction(action)
for snippet in includeWalk(snippetPath, ".py"):
snippetKeys = None
(snippetDescription, snippetKeys, snippetCode) = loadSnippetFromFile(snippet)
actionText = actionFromSnippet(snippet, snippetDescription)
if snippetCode:
if snippetKeys == None:
UIAction.registerAction(actionText)
else:
UIAction.registerAction(actionText, snippetKeys)
UIActionHandler.globalActions().bindAction(actionText, UIAction(makeSnippetFunction(snippetCode)))
Menu.mainMenu("Tools").addAction(actionText, "Snippets")
def clearSelection(self):
self.keySequenceEdit.clear()
self.currentHotkey = QKeySequence()
self.currentHotkeyLabel.setText("")
self.currentFileLabel.setText("")
self.snippetDescription.setText("")
self.edit.clear()
self.tree.clearSelection()
self.currentFile = ""
def reject(self):
self.settings.setValue("ui/snippeteditor/geometry", self.saveGeometry())
if self.snippetChanged():
question = QMessageBox.question(self, self.tr("Discard"), self.tr("You have unsaved changes, quit anyway?"))
if question != QMessageBox.StandardButton.Yes:
return
self.accept()
def browseSnippets(self):
url = QUrl.fromLocalFile(snippetPath)
QDesktopServices.openUrl(url);
def newFolder(self):
(folderName, ok) = QInputDialog.getText(self, self.tr("Folder Name"), self.tr("Folder Name: "))
if ok and folderName:
index = self.tree.selectionModel().currentIndex()
selection = self.files.filePath(index)
if QFileInfo(selection).isDir():
QDir(selection).mkdir(folderName)
else:
QDir(snippetPath).mkdir(folderName)
def selectFile(self, new, old):
if (self.resetting):
self.resetting = False
return
if len(new.indexes()) == 0:
self.clearSelection()
self.currentFile = ""
self.readOnly(True)
return
newSelection = self.files.filePath(new.indexes()[0])
self.settings.setValue("ui/snippeteditor/selected", newSelection)
if QFileInfo(newSelection).isDir():
self.readOnly(True)
self.clearSelection()
self.currentFile = ""
return
if old and old.length() > 0:
oldSelection = self.files.filePath(old.indexes()[0])
if not QFileInfo(oldSelection).isDir() and self.snippetChanged():
question = QMessageBox.question(self, self.tr("Discard"), self.tr("Snippet changed. Discard changes?"))
if question != QMessageBox.StandardButton.Yes:
self.resetting = True
self.tree.selectionModel().select(old, QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
return False
self.currentFile = newSelection
self.loadSnippet()
def loadSnippet(self):
self.currentFileLabel.setText(QFileInfo(self.currentFile).baseName())
(snippetDescription, snippetKeys, snippetCode) = loadSnippetFromFile(self.currentFile)
self.snippetDescription.setText(snippetDescription) if snippetDescription else self.snippetDescription.setText("")
self.keySequenceEdit.setKeySequence(snippetKeys) if snippetKeys else self.keySequenceEdit.setKeySequence(QKeySequence(""))
self.edit.setPlainText(snippetCode) if snippetCode else self.edit.setPlainText("")
self.readOnly(False)
def newFileDialog(self):
(snippetName, ok) = QInputDialog.getText(self, self.tr("Snippet Name"), self.tr("Snippet Name: "))
if ok and snippetName:
if not snippetName.endswith(".py"):
snippetName += ".py"
index = self.tree.selectionModel().currentIndex()
selection = self.files.filePath(index)
if QFileInfo(selection).isDir():
path = os.path.join(selection, snippetName)
else:
path = os.path.join(snippetPath, snippetName)
self.readOnly(False)
open(path, "w").close()
self.tree.setCurrentIndex(self.files.index(path))
log_debug("Snippet %s created." % snippetName)
def readOnly(self, flag):
self.keySequenceEdit.setEnabled(not flag)
self.snippetDescription.setReadOnly(flag)
self.edit.setReadOnly(flag)
if flag:
self.snippetDescription.setDisabled(True)
self.edit.setDisabled(True)
else:
self.snippetDescription.setEnabled(True)
self.edit.setEnabled(True)
def deleteSnippet(self):
selection = self.tree.selectedIndexes()[::self.columns][0] #treeview returns each selected element in the row
snippetName = self.files.fileName(selection)
question = QMessageBox.question(self, self.tr("Confirm"), self.tr("Confirm deletion: ") + snippetName)
if (question == QMessageBox.StandardButton.Yes):
log_debug("Deleting snippet %s." % snippetName)
self.clearSelection()
self.files.remove(selection)
self.registerAllSnippets()
def snippetChanged(self):
if (self.currentFile == "" or QFileInfo(self.currentFile).isDir()):
return False
(snippetDescription, snippetKeys, snippetCode) = loadSnippetFromFile(self.currentFile)
if snippetKeys == None and not self.keySequenceEdit.keySequence().isEmpty():
return True
if snippetKeys != None and snippetKeys != self.keySequenceEdit.keySequence().toString():
return True
return self.edit.toPlainText() != snippetCode or \
self.snippetDescription.text() != snippetDescription
def save(self):
log_debug("Saving snippet %s" % self.currentFile)
outputSnippet = codecs.open(self.currentFile, "w", "utf-8")
outputSnippet.write("#" + self.snippetDescription.text() + "\n")
outputSnippet.write("#" + self.keySequenceEdit.keySequence().toString() + "\n")
outputSnippet.write(self.edit.toPlainText())
outputSnippet.close()
self.registerAllSnippets()
def run(self):
if self.context == None:
log_warn("Cannot run snippets outside of the UI at this time.")
return
if self.snippetChanged():
question = QMessageBox.question(self, self.tr("Confirm"), self.tr("You have unsaved changes, must save first. Save?"))
if (question == QMessageBox.StandardButton.No):
return
else:
self.save()
actionText = actionFromSnippet(self.currentFile, self.snippetDescription.text())
UIActionHandler.globalActions().executeAction(actionText, self.context)
log_debug("Saving snippet %s" % self.currentFile)
outputSnippet = codecs.open(self.currentFile, "w", "utf-8")
outputSnippet.write("#" + self.snippetDescription.text() + "\n")
outputSnippet.write("#" + self.keySequenceEdit.keySequence().toString() + "\n")
outputSnippet.write(self.edit.toPlainText())
outputSnippet.close()
self.registerAllSnippets()
def clearHotkey(self):
self.keySequenceEdit.clear()
class FileSystemWidget(QWidget):
def __init__(self, parent, *args, **kwargs):
super().__init__(*args, **kwargs)
self.currentRootPath = '/'
self.currentPath = QDir.currentPath()
self.mainWindow = parent
self.chooseDirAction = QAction(IconFactory.getIcon('folder'),
'Root directory',
self,
statusTip="Change root directory",
triggered=self.chooseRootDir)
self.showOFAction = QAction(IconFactory.getIcon('filter_alt'),
'Show only FITS files',
self,
statusTip="Show only FITS/all files",
triggered=self.showOFFiles)
self.showOFAction.setCheckable(True)
self.showOFAction.toggled.connect(self.showOFFiles)
self.chooseDirBtn = QToolButton()
self.chooseDirBtn.setDefaultAction(self.chooseDirAction)
self.showOFBtn = QToolButton()
self.showOFBtn.setDefaultAction(self.showOFAction)
iconlayout = QHBoxLayout()
iconlayout.setAlignment(Qt.AlignLeft)
iconlayout.addWidget(self.chooseDirBtn)
iconlayout.addWidget(self.showOFBtn)
self.viewsSplitter = QSplitter(Qt.Horizontal)
self.viewsSplitter.splitterMoved.connect(self.splitterMoved)
self.dirsModel = QFileSystemModel(self)
self.dirsModel.setOption(QFileSystemModel.DontWatchForChanges, True)
self.dirsModel.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)
self.dirsModel.setNameFilterDisables(False)
self.dirs = QTreeView()
self.dirs.setModel(self.dirsModel)
self.dirs.hideColumn(1)
self.dirs.hideColumn(2)
self.dirs.hideColumn(3)
self.dirs.clicked.connect(self.onDirsClick)
self.dirs.doubleClicked.connect(self.onDirsDoubleClick)
self.filesModel = QFileSystemModel(self)
self.filesModel.setOption(QFileSystemModel.DontWatchForChanges, True)
self.filesModel.setFilter(QDir.NoDotAndDotDot | QDir.Files)
self.filesModel.setNameFilterDisables(False)
self.files = QListView()
self.files.setModel(self.filesModel)
self.files.doubleClicked.connect(self.onFilesDoubleClick)
self.viewsSplitter.addWidget(self.dirs)
self.viewsSplitter.addWidget(self.files)
viewslayout = QHBoxLayout()
viewslayout.addWidget(self.viewsSplitter)
layout = QVBoxLayout()
layout.addLayout(iconlayout)
layout.addLayout(viewslayout)
self.setLayout(layout)
self.dirsModel.setRootPath(self.currentRootPath)
self.dirs.setRootIndex(self.dirsModel.index(self.currentRootPath))
index = self.dirsModel.index(self.currentPath)
self.dirs.setCurrentIndex(index)
self.dirs.setExpanded(index, True)
self.filesModel.setRootPath(self.currentPath)
self.files.setRootIndex(self.filesModel.index(self.currentPath))
def splitterMoved(self, pos, index):
if pos == 0:
self.filesModel.setFilter(QDir.NoDot | QDir.AllEntries
| QDir.DirsFirst | QDir.Type)
elif pos == self.viewsSplitter.width(
) - self.viewsSplitter.handleWidth():
self.dirsModel.setFilter(QDir.NoDotAndDotDot | QDir.AllEntries)
else:
self.dirsModel.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)
self.filesModel.setFilter(QDir.NoDotAndDotDot | QDir.Files)
def onDirsClick(self, item):
index = self.dirs.selectedIndexes()[0]
info = self.dirsModel.fileInfo(index)
if info.isDir():
self.currentPath = info.filePath()
self.files.setRootIndex(
self.filesModel.setRootPath(info.filePath()))
def onDirsDoubleClick(self, item):
index = self.dirs.selectedIndexes()[0]
info = self.dirsModel.fileInfo(index)
if info.isDir():
self.currentPath = info.filePath()
self.files.setRootIndex(
self.filesModel.setRootPath(info.filePath()))
else:
self.mainWindow.open_fits(info.filePath())
def onFilesDoubleClick(self, item):
index = self.files.selectedIndexes()[0]
info = self.filesModel.fileInfo(index)
if info.isDir():
self.setPath(info.filePath())
else:
try:
self.mainWindow.open_fits(info.filePath())
except FileNotFoundError:
self.setPath(self.currentPath) # refesh maybe?
def setPath(self, path):
self.currentPath = path
index = self.dirsModel.index(self.currentPath)
self.dirs.setCurrentIndex(index)
self.dirs.setExpanded(index, True)
self.files.setRootIndex(self.filesModel.setRootPath(self.currentPath))
def chooseRootDir(self):
dir = QFileDialog.getExistingDirectory(self, 'Select directory')
if dir:
self.setRootPath(dir)
def setRootPath(self, dir):
self.currentRootPath = dir
self.dirsModel.setRootPath(self.currentRootPath)
self.dirs.setRootIndex(self.dirsModel.index(self.currentRootPath))
self.setPath(self.currentRootPath)
def showOFFiles(self):
if self.showOFAction.isChecked():
self.dirsModel.setNameFilters(["*.FITS", "*.fits"])
self.filesModel.setNameFilters(["*.FITS", "*.fits"])
else:
self.dirsModel.setNameFilters(["*"])
self.filesModel.setNameFilters(["*"])
def writeSettings(self, settings):
settings.beginGroup("fileWidget")
settings.setValue('splitterGeometry',
self.viewsSplitter.saveGeometry())
settings.setValue('splitterState', self.viewsSplitter.saveState())
settings.setValue('rootPath', self.currentRootPath)
settings.setValue('path', self.currentPath)
settings.endGroup()
def readSettings(self, settings):
settings.beginGroup("fileWidget")
self.viewsSplitter.restoreGeometry(settings.value("splitterGeometry"))
self.viewsSplitter.restoreState(settings.value("splitterState"))
rootPath = settings.value("rootPath")
path = settings.value("path")
settings.endGroup()
if rootPath is None:
rootPath = '/'
self.setRootPath(rootPath)
if path is None:
path = QDir.currentPath()
self.setPath(path)
self.splitterMoved(self.viewsSplitter.handle(1).pos().x(), 0)
class SearchReplaceDialog(QDialog):
"""Search & Replace window
"""
def __init__(self, parent, initial_query=None):
"""Initialize the search window
"""
super(SearchReplaceDialog, self).__init__(parent)
self.parent = parent
self.prefs = parent.prefs
self.items_checked = 0
self.search_button = QPushButton('Search')
self.search_text = MySearchField(self.search_button)
self.search_text.setPlaceholderText("Enter search query here")
self.search_button.clicked.connect(self.submit_search)
input_layout = QHBoxLayout()
input_layout.addWidget(self.search_text)
input_layout.addWidget(self.search_button)
self.results_tree = QTreeView()
self.results_tree.setRootIsDecorated(False)
self.results_tree.setAlternatingRowColors(True)
self.results_tree.setAllColumnsShowFocus(True)
self.results_tree.setSelectionBehavior(QAbstractItemView.SelectRows)
self.results_tree.setSelectionMode(QAbstractItemView.SingleSelection)
self.results_tree.doubleClicked.connect(self.go_to_object)
self.whole_field_checkbox = QCheckBox("Whole Field Only", self)
self.advanced_search_checkbox = QCheckBox("Advanced Search", self)
self.advanced_search_checkbox.stateChanged.connect(
self.advanced_search_checked)
self.ignore_geometry_checkbox = QCheckBox("Ignore Geometry", self)
self.go_button = QPushButton('Go')
self.go_button.clicked.connect(self.go_to_object)
checks_layout = QHBoxLayout()
checks_layout.addWidget(self.whole_field_checkbox)
checks_layout.addWidget(self.advanced_search_checkbox)
checks_layout.addWidget(self.ignore_geometry_checkbox)
checks_layout.addStretch()
checks_layout.addWidget(self.go_button)
self.query_label = QLabel("Query:")
self.query_label.setEnabled(False)
self.query_text = QLineEdit()
self.query_text.setEnabled(True)
self.query_text.setReadOnly(True)
self.query_text.setFrame(False)
self.query_text.setStyleSheet("""QLineEdit {
background-color: LightGray;
color: white;
} """)
query_layout = QHBoxLayout()
query_layout.addWidget(self.query_label)
query_layout.addWidget(self.query_text)
self.select_label = QLabel("Select:")
self.select_all_button = QPushButton("All")
self.select_none_button = QPushButton("None")
self.select_invert_button = QPushButton("Invert")
self.delete_button = QPushButton("Delete Objects")
self.select_all_button.clicked.connect(self.select_all_clicked)
self.select_none_button.clicked.connect(self.select_none_clicked)
self.select_invert_button.clicked.connect(self.select_invert_clicked)
self.delete_button.clicked.connect(self.delete_button_clicked)
self.delete_button.setEnabled(False)
selection_layout = QHBoxLayout()
selection_layout.addWidget(self.select_label)
selection_layout.addWidget(self.select_all_button)
selection_layout.addWidget(self.select_none_button)
selection_layout.addWidget(self.select_invert_button)
selection_layout.addStretch()
selection_layout.addWidget(self.delete_button)
self.replace_with_text = QLineEdit()
self.replace_with_label = QLabel("Replace With:")
self.replace_button = QPushButton("Replace")
self.replace_button.clicked.connect(self.replace_button_clicked)
self.replace_button.setEnabled(False)
replace_layout = QHBoxLayout()
replace_layout.addWidget(self.replace_with_label)
replace_layout.addWidget(self.replace_with_text)
replace_layout.addWidget(self.replace_button)
layout = QVBoxLayout()
layout.addLayout(input_layout)
layout.addLayout(checks_layout)
layout.addLayout(query_layout)
layout.addWidget(self.results_tree)
layout.addLayout(selection_layout)
layout.addLayout(replace_layout)
self.resize(650, 450)
self.setLayout(layout)
self.setWindowTitle("IDF+ Search & Replace")
self.search_text.setFocus()
self.setTabOrder(self.search_text, self.search_button)
self.setTabOrder(self.search_button, self.whole_field_checkbox)
self.setTabOrder(self.whole_field_checkbox,
self.advanced_search_checkbox)
self.setTabOrder(self.advanced_search_checkbox, self.select_all_button)
self.setTabOrder(self.select_all_button, self.select_none_button)
self.setTabOrder(self.select_none_button, self.select_invert_button)
self.setTabOrder(self.select_invert_button, self.replace_with_text)
self.setTabOrder(self.replace_with_text, self.replace_button)
self.setTabOrder(self.replace_button, self.search_text)
self.results_tree.setModel(self.create_results_model([]))
self.results_tree.setColumnHidden(2, True)
if initial_query is not None:
self.search_text.setText(initial_query)
self.search_button.click()
def create_results_model(self, results):
def add_result_row(row_model, value, obj_class, uuid):
row_model.insertRow(0)
row_model.setData(model.index(0, 0), value)
row_model.setData(model.index(0, 1), obj_class)
row_model.setData(model.index(0, 2), uuid)
item_0 = model.itemFromIndex(model.index(0, 0))
item_0.setCheckState(Qt.Unchecked)
item_0.setFlags(item_0.flags() | Qt.ItemIsUserCheckable)
item_0.setEditable(False)
item_1 = model.itemFromIndex(model.index(0, 1))
item_1.setEditable(False)
model = QStandardItemModel(0, 3, self)
model.setHeaderData(0, Qt.Horizontal, "Value")
model.setHeaderData(1, Qt.Horizontal, "Class")
model.setHeaderData(2, Qt.Horizontal, "UUID")
for hit in results:
add_result_row(model, hit['value'], hit['obj_class_display'],
hit['uuid'])
return model
def submit_search(self):
"""Submits a search based on the current query
"""
user_query = self.search_text.text()
idf = self.parent.idf
if not user_query or len(user_query) < 2 or not idf:
return [], ""
results, my_query = idf.search(
user_query, self.whole_field_checkbox.isChecked(),
self.advanced_search_checkbox.isChecked(),
self.ignore_geometry_checkbox.isChecked())
self.query_text.setText(str(my_query))
self.results_tree.setModel(self.create_results_model(results))
self.results_tree.model().itemChanged.connect(self.item_checked)
# self.results_tree.setColumnHidden(2, True)
self.results_tree.resizeColumnToContents(0)
self.results_tree.resizeColumnToContents(1)
self.results_tree.setSortingEnabled(True)
def item_checked(self, item):
if item.checkState() == Qt.Checked:
self.items_checked += 1
else:
self.items_checked -= 1
if self.items_checked > 0:
self.delete_button.setEnabled(True)
self.replace_button.setEnabled(True)
else:
self.delete_button.setEnabled(False)
self.replace_button.setEnabled(False)
def select_all_clicked(self):
model = self.results_tree.model()
result_count = model.rowCount()
for i in range(result_count):
model.itemFromIndex(model.index(i, 0)).setCheckState(Qt.Checked)
def select_none_clicked(self):
model = self.results_tree.model()
result_count = model.rowCount()
for i in range(result_count):
model.itemFromIndex(model.index(i, 0)).setCheckState(Qt.Unchecked)
def select_invert_clicked(self):
model = self.results_tree.model()
result_count = model.rowCount()
for i in range(result_count):
item = model.itemFromIndex(model.index(i, 0))
if item.checkState() == Qt.Checked:
new_state = Qt.Unchecked
else:
new_state = Qt.Checked
item.setCheckState(new_state)
def delete_button_clicked(self):
model = self.results_tree.model()
result_count = model.rowCount()
if result_count <= 0 or self.items_checked <= 0:
return
question = "Are you sure you want to perform this deletion?\n" \
"Undo is currently NOT supported for this operation."
response = self.confirm_action(question)
if response is not True:
return
for i in range(result_count):
item_0 = model.itemFromIndex(model.index(i, 0))
item_2 = model.itemFromIndex(model.index(i, 2))
if item_0.checkState() != Qt.Checked:
continue
field = self.parent.idf.field_by_uuid(item_2.text())
obj = field._outer
obj_class = self.parent.idf.idf_objects(obj.obj_class)
try:
index = obj_class.index(obj)
self.parent.idf.remove_objects(obj.obj_class, index, index + 1)
except ValueError:
pass # already deleted
self.parent.set_dirty(True)
self.submit_search()
self.parent.load_table_view(self.parent.current_obj_class)
QMessageBox.information(self, "Delete Action", "Deletion Complete!")
def advanced_search_checked(self):
if self.advanced_search_checkbox.isChecked():
self.whole_field_checkbox.setEnabled(False)
self.whole_field_checkbox.setChecked(True)
self.ignore_geometry_checkbox.setEnabled(False)
self.ignore_geometry_checkbox.setChecked(False)
else:
self.whole_field_checkbox.setEnabled(True)
self.whole_field_checkbox.setChecked(False)
self.ignore_geometry_checkbox.setEnabled(True)
self.ignore_geometry_checkbox.setChecked(False)
def replace_button_clicked(self):
search_text = self.search_text.text()
replace_with_text = self.replace_with_text.text()
if not search_text:
return
model = self.results_tree.model()
result_count = model.rowCount()
if result_count <= 0 or self.items_checked <= 0:
return
question = "Are you sure you want to perform this replacement?\n" \
"Undo is currently NOT supported for this operation."
response = self.confirm_action(question)
if response is not True:
return
for i in range(result_count):
item_0 = model.itemFromIndex(model.index(i, 0))
item_2 = model.itemFromIndex(model.index(i, 2))
if item_0.checkState() != Qt.Checked:
continue
field = self.parent.idf.field_by_uuid(item_2.text())
if self.whole_field_checkbox.isChecked(
) or self.advanced_search_checkbox.isChecked():
field.value = replace_with_text
else:
regex = re.compile(re.escape(search_text), re.IGNORECASE)
field.value = regex.sub(replace_with_text, field.value)
self.parent.set_dirty(True)
self.submit_search()
self.parent.load_table_view(self.parent.current_obj_class)
QMessageBox.information(self, "Replacement", "Replacement Complete!")
def confirm_action(self, question):
"""Confirm user wants to perform action
"""
flags = QMessageBox.StandardButton.Yes
flags |= QMessageBox.StandardButton.No
response = QMessageBox.question(self, "Are you sure?", question, flags)
if response == QMessageBox.Yes:
return True
elif QMessageBox.No:
return False
else:
return False
def go_to_object(self, index=None):
if index is None:
selected = self.results_tree.selectedIndexes()
if not selected:
return
index = selected[0]
model = self.results_tree.model()
item = model.itemFromIndex(model.index(index.row(), 2))
field = self.parent.idf.field_by_uuid(item.text())
self.parent.activateWindow()
self.parent.jump_to_field(field)
class SVDBrowser(QDialog):
def __init__(self, context, parent=None):
super(SVDBrowser, self).__init__(parent)
QWebEngineProfile.defaultProfile().downloadRequested.connect(
self.on_downloadRequested)
# Create widgets
#self.setWindowModality(Qt.ApplicationModal)
self.title = QLabel(self.tr("SVD Browser"))
self.closeButton = QPushButton(self.tr("Close"))
self.setWindowTitle(self.title.text())
self.browseButton = QPushButton("Browse SVD Folder")
self.deleteSvdButton = QPushButton("Delete")
self.applySvdButton = QPushButton("Apply SVD")
self.view = QWebEngineView()
url = "https://developer.arm.com/tools-and-software/embedded/cmsis/cmsis-search"
self.view.load(QUrl(url))
self.columns = 3
self.context = context
self.currentFileLabel = QLabel()
self.currentFile = ""
#Files
self.files = QFileSystemModel()
self.files.setRootPath(svdPath)
self.files.setNameFilters(["*.svd", "*.patched"])
#Tree
self.tree = QTreeView()
self.tree.setModel(self.files)
self.tree.setSortingEnabled(True)
self.tree.hideColumn(2)
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.tree.setRootIndex(self.files.index(svdPath))
for x in range(self.columns):
#self.tree.resizeColumnToContents(x)
self.tree.header().setSectionResizeMode(
x, QHeaderView.ResizeToContents)
treeLayout = QVBoxLayout()
treeLayout.addWidget(self.tree)
treeButtons = QHBoxLayout()
#treeButtons.addWidget(self.newFolderButton)
treeButtons.addWidget(self.browseButton)
treeButtons.addWidget(self.applySvdButton)
treeButtons.addWidget(self.deleteSvdButton)
treeLayout.addLayout(treeButtons)
treeWidget = QWidget()
treeWidget.setLayout(treeLayout)
# Create layout and add widgets
buttons = QHBoxLayout()
buttons.addWidget(self.closeButton)
vlayoutWidget = QWidget()
vlayout = QVBoxLayout()
vlayout.addWidget(self.view)
vlayout.addLayout(buttons)
vlayoutWidget.setLayout(vlayout)
hsplitter = QSplitter()
hsplitter.addWidget(treeWidget)
hsplitter.addWidget(vlayoutWidget)
hlayout = QHBoxLayout()
hlayout.addWidget(hsplitter)
self.showMaximized() #Fixes bug that maximized windows are "stuck"
#Because you can't trust QT to do the right thing here
# Set dialog layout
self.setLayout(hlayout)
# Add signals
self.closeButton.clicked.connect(self.close)
self.tree.selectionModel().selectionChanged.connect(self.selectFile)
self.applySvdButton.clicked.connect(self.applySvd)
self.deleteSvdButton.clicked.connect(self.deleteSvd)
self.browseButton.clicked.connect(self.browseSvd)
def browseSvd(self):
url = QUrl.fromLocalFile(svdPath)
QDesktopServices.openUrl(url)
def selectFile(self, new, old):
if len(new.indexes()) == 0:
self.tree.clearSelection()
self.currentFile = ""
return
newSelection = self.files.filePath(new.indexes()[0])
if QFileInfo(newSelection).isDir():
self.tree.clearSelection()
self.currentFile = ""
return
self.currentFile = newSelection
def applySvd(self):
selection = self.tree.selectedIndexes()[::self.columns][
0] #treeview returns each selected element in the row
svdName = self.files.fileName(selection)
if (svdName != ""):
question = QMessageBox.question(
self, self.tr("Confirm"),
self.
tr(f"Confirm applying {svdName} to {os.path.basename(self.context.file.filename)} : "
))
if (question == QMessageBox.StandardButton.Yes):
log_debug("SVD Browser: Applying SVD %s." % svdName)
load_svd(self.context, self.currentFile)
self.close()
def deleteSvd(self):
selection = self.tree.selectedIndexes()[::self.columns][
0] #treeview returns each selected element in the row
svdName = self.files.fileName(selection)
question = QMessageBox.question(
self, self.tr("Confirm"),
self.tr("Confirm deletion: ") + svdName)
if (question == QMessageBox.StandardButton.Yes):
log_debug("SVD Browser: Deleting SVD %s." % svdName)
self.files.remove(selection)
self.tree.clearSelection()
def on_downloadRequested(self, download):
old_path = download.url().path() # download.path()
suffix = QFileInfo(old_path).suffix()
if (suffix.lower() in ["zip", "svd", "pack", "patched"]):
log_debug(f"SVD Browser: Downloading {str(download.url())}")
if suffix.lower() == "svd" or suffix.lower() == "patched":
download.setDownloadDirectory(svdPath)
download.accept()
else:
with TemporaryDirectory() as tempfolder:
log_debug(
f"SVD Browser: Downloading pack/zip to {tempfolder}")
fname = download.url().fileName()
r = requests.get(download.url().toString(),
allow_redirects=True)
dlfile = os.path.join(tempfolder, fname)
open(dlfile, "wb").write(r.content)
'''
# TODO: See if the original QT Downloader can be fixed since it would
# help with situations where the user entered credentials in the browser.
download.setDownloadDirectory(tempfolder)
download.accept()
while not download.finished:
import time
time.sleep(100)
'''
if fname.endswith(".zip") or fname.endswith(".pack"):
destFolder = os.path.join(svdPath,
os.path.splitext(fname)[0])
log_debug(f"SVD Browser: Creating {destFolder}")
if not os.path.exists(destFolder):
os.mkdir(destFolder)
with ZipFile(dlfile, 'r') as zipp:
for ifname in zipp.namelist():
if ifname.endswith(".svd"):
info = zipp.getinfo(ifname)
info.filename = os.path.basename(
info.filename)
log_debug(
f"SVD Browser: Extracting {info.filename} from {ifname}"
)
zipp.extract(info, path=destFolder)
else:
#Move file into place
shutil.move(dlfile, svdPath)
else:
show_message_box(
"Invalid file",
"That download does not appear to be a valid SVD/ZIP/PACK file."
)
download.cancel()
