class ObjectTreeDialog(QDialog):
def __init__(self, parent=None, root_object=None):
super(ObjectTreeDialog, self).__init__(parent)
self.setWindowTitle("Object Tree")
layout = QtWidgets.QVBoxLayout()
# Tree widget for displaying our object hierarchy
self.tree_widget = QTreeWidget()
self.tree_widget_columns = [
"TYPE", "OBJECT NAME", "TEXT", "ICONTEXT", "TITLE", "WINDOW_TITLE",
"CLASSES", "POINTER_ADDRESS", "GEOMETRY"
]
self.tree_widget.setColumnCount(len(self.tree_widget_columns))
self.tree_widget.setHeaderLabels(self.tree_widget_columns)
# Only show our type and object name columns. The others we only use to store data so that
# we can use the built-in QTreeWidget.findItems to query.
for column_name in self.tree_widget_columns:
if column_name == "TYPE" or column_name == "OBJECT NAME":
continue
column_index = self.tree_widget_columns.index(column_name)
self.tree_widget.setColumnHidden(column_index, True)
header = self.tree_widget.header()
header.setSectionResizeMode(0, QHeaderView.ResizeToContents)
header.setSectionResizeMode(1, QHeaderView.ResizeToContents)
# Populate our object tree widget
# If a root object wasn't specified, then use the Editor main window
if not root_object:
params = azlmbr.qt.QtForPythonRequestBus(
azlmbr.bus.Broadcast, "GetQtBootstrapParameters")
editor_id = QtWidgets.QWidget.find(params.mainWindowId)
editor_main_window = wrapInstance(int(getCppPointer(editor_id)[0]),
QtWidgets.QMainWindow)
root_object = editor_main_window
self.build_tree(root_object, self.tree_widget)
# Listen for when the tree widget selection changes so we can update
# selected item properties
self.tree_widget.itemSelectionChanged.connect(
self.on_tree_widget_selection_changed)
# Split our tree widget with a properties view for showing more information about
# a selected item. We also use a stacked layout for the properties view so that
# when nothing has been selected yet, we can show a message informing the user
# that something needs to be selected.
splitter = QSplitter()
splitter.addWidget(self.tree_widget)
self.widget_properties = QWidget(self)
self.stacked_layout = QtWidgets.QStackedLayout()
self.widget_info = QWidget()
form_layout = QtWidgets.QFormLayout()
self.name_value = QLineEdit("")
self.name_value.setReadOnly(True)
self.type_value = QLabel("")
self.geometry_value = QLabel("")
self.text_value = QLabel("")
self.icon_text_value = QLabel("")
self.title_value = QLabel("")
self.window_title_value = QLabel("")
self.classes_value = QLabel("")
form_layout.addRow("Name:", self.name_value)
form_layout.addRow("Type:", self.type_value)
form_layout.addRow("Geometry:", self.geometry_value)
form_layout.addRow("Text:", self.text_value)
form_layout.addRow("Icon Text:", self.icon_text_value)
form_layout.addRow("Title:", self.title_value)
form_layout.addRow("Window Title:", self.window_title_value)
form_layout.addRow("Classes:", self.classes_value)
self.widget_info.setLayout(form_layout)
self.widget_properties.setLayout(self.stacked_layout)
self.stacked_layout.addWidget(
QLabel("Select an object to view its properties"))
self.stacked_layout.addWidget(self.widget_info)
splitter.addWidget(self.widget_properties)
# Give our splitter stretch factor of 1 so it will expand to take more room over
# the footer
layout.addWidget(splitter, 1)
# Create our popup widget for showing information when hovering over widgets
self.hovered_widget = None
self.inspect_mode = False
self.inspect_popup = InspectPopup()
self.inspect_popup.resize(100, 50)
self.inspect_popup.hide()
# Add a footer with a button to switch to widget inspect mode
self.footer = QWidget()
footer_layout = QtWidgets.QHBoxLayout()
self.inspect_button = QPushButton("Pick widget to inspect")
self.inspect_button.clicked.connect(self.on_inspect_clicked)
footer_layout.addStretch(1)
footer_layout.addWidget(self.inspect_button)
self.footer.setLayout(footer_layout)
layout.addWidget(self.footer)
self.setLayout(layout)
# Delete ourselves when the dialog is closed, so that we don't stay living in the background
# since we install an event filter on the application
self.setAttribute(Qt.WA_DeleteOnClose, True)
# Listen to events at the application level so we can know when the mouse is moving
app = QtWidgets.QApplication.instance()
app.installEventFilter(self)
def eventFilter(self, obj, event):
# Look for mouse movement events so we can see what widget the mouse is hovered over
event_type = event.type()
if event_type == QEvent.MouseMove:
global_pos = event.globalPos()
# Make our popup follow the mouse, but we need to offset it by 1, 1 otherwise
# the QApplication.widgetAt will always return our popup instead of the Editor
# widget since it is on top
self.inspect_popup.move(global_pos + QtCore.QPoint(1, 1))
# Find out which widget is under our current mouse position
hovered_widget = QtWidgets.QApplication.widgetAt(global_pos)
if self.hovered_widget:
# Bail out, this is the same widget we are already hovered on
if self.hovered_widget is hovered_widget:
return False
# Update our hovered widget and label
self.hovered_widget = hovered_widget
self.update_hovered_widget_popup()
elif event_type == QEvent.KeyRelease:
if event.key() == Qt.Key_Escape:
# Cancel the inspect mode if the Escape key is pressed
# We don't need to actually hide the inspect popup here because
# it will be hidden already by the Escape action
self.inspect_mode = False
elif event_type == QEvent.MouseButtonPress or event_type == QEvent.MouseButtonRelease:
# Trigger inspecting the currently hovered widget when the left mouse button is clicked
# Don't continue processing this event
if self.inspect_mode and event.button() == Qt.LeftButton:
# Only trigger the inspect on the click release, but we want to also eat the press
# event so that the widget we clicked on isn't stuck in a weird state (e.g. thinks its being dragged)
# Also hide the inspect popup since it won't be hidden automatically by the mouse click since we are
# consuming the event
if event_type == event_type == QEvent.MouseButtonRelease:
self.inspect_popup.hide()
self.inspect_widget()
return True
# Pass every event through
return False
def build_tree(self, obj, parent_tree):
if len(obj.children()) == 0:
return
for child in obj.children():
object_type = type(child).__name__
object_name = child.objectName()
text = icon_text = title = window_title = geometry_str = classes = "(N/A)"
if isinstance(child, QtGui.QWindow):
title = child.title()
if isinstance(child, QAction):
text = child.text()
icon_text = child.iconText()
if isinstance(child, QWidget):
window_title = child.windowTitle()
if not (child.property("class") == ""):
classes = child.property("class")
if isinstance(child, QAbstractButton):
text = child.text()
# Keep track of the pointer address for this object so we can search for it later
pointer_address = str(int(getCppPointer(child)[0]))
# Some objects might not have a geometry (e.g. actions, generic qobjects)
if hasattr(child, 'geometry'):
geometry_rect = child.geometry()
geometry_str = "x: {x}, y: {y}, width: {width}, height: {height}".format(
x=geometry_rect.x(),
y=geometry_rect.y(),
width=geometry_rect.width(),
height=geometry_rect.height())
child_tree = QTreeWidgetItem([
object_type, object_name, text, icon_text, title, window_title,
classes, pointer_address, geometry_str
])
if isinstance(parent_tree, QTreeWidget):
parent_tree.addTopLevelItem(child_tree)
else:
parent_tree.addChild(child_tree)
self.build_tree(child, child_tree)
def update_hovered_widget_popup(self):
if self.inspect_mode and self.hovered_widget:
if not self.inspect_popup.isVisible():
self.inspect_popup.show()
self.inspect_popup.update_widget(self.hovered_widget)
else:
self.inspect_popup.hide()
def on_inspect_clicked(self):
self.inspect_mode = True
self.update_hovered_widget_popup()
def on_tree_widget_selection_changed(self):
selected_items = self.tree_widget.selectedItems()
# If nothing is selected, then switch the stacked layout back to 0
# to show the message
if not selected_items:
self.stacked_layout.setCurrentIndex(0)
return
# Update the selected widget properties and switch to the 1 index in
# the stacked layout so that all the rows will be visible
item = selected_items[0]
self.name_value.setText(
item.text(self.tree_widget_columns.index("OBJECT NAME")))
self.type_value.setText(
item.text(self.tree_widget_columns.index("TYPE")))
self.geometry_value.setText(
item.text(self.tree_widget_columns.index("GEOMETRY")))
self.text_value.setText(
item.text(self.tree_widget_columns.index("TEXT")))
self.icon_text_value.setText(
item.text(self.tree_widget_columns.index("ICONTEXT")))
self.title_value.setText(
item.text(self.tree_widget_columns.index("TITLE")))
self.window_title_value.setText(
item.text(self.tree_widget_columns.index("WINDOW_TITLE")))
self.classes_value.setText(
item.text(self.tree_widget_columns.index("CLASSES")))
self.stacked_layout.setCurrentIndex(1)
def inspect_widget(self):
self.inspect_mode = False
# Find the tree widget item that matches our hovered widget, and then set it as the current item
# so that the tree widget will scroll to it, expand it, and select it
widget_pointer_address = str(int(
getCppPointer(self.hovered_widget)[0]))
pointer_address_column = self.tree_widget_columns.index(
"POINTER_ADDRESS")
items = self.tree_widget.findItems(
widget_pointer_address, Qt.MatchFixedString | Qt.MatchRecursive,
pointer_address_column)
if items:
item = items[0]
self.tree_widget.clearSelection()
self.tree_widget.setCurrentItem(item)
else:
print("Unable to find widget")
class AddOrManageObjectGroupDialog(QDialog):
def __init__(self, parent, object_class_item, db_mngr, *db_maps):
"""
Args:
parent (SpineDBEditor): data store widget
object_class_item (ObjectClassItem)
db_mngr (SpineDBManager)
*db_maps: database mappings
"""
super().__init__(parent)
self.object_class_item = object_class_item
self.db_mngr = db_mngr
self.db_maps = db_maps
self.db_map = db_maps[0]
self.db_maps_by_codename = {
db_map.codename: db_map
for db_map in db_maps
}
self.db_combo_box = QComboBox(self)
self.header_widget = QWidget(self)
self.group_name_line_edit = QLineEdit(self)
header_layout = QHBoxLayout(self.header_widget)
header_layout.addWidget(QLabel(f"Group name: "))
header_layout.addWidget(self.group_name_line_edit)
header_layout.addSpacing(32)
header_layout.addWidget(QLabel("Database"))
header_layout.addWidget(self.db_combo_box)
self.non_members_tree = QTreeWidget(self)
self.non_members_tree.setHeaderLabel("Non members")
self.non_members_tree.setSelectionMode(QTreeWidget.ExtendedSelection)
self.non_members_tree.setColumnCount(1)
self.non_members_tree.setIndentation(0)
self.members_tree = QTreeWidget(self)
self.members_tree.setHeaderLabel("Members")
self.members_tree.setSelectionMode(QTreeWidget.ExtendedSelection)
self.members_tree.setColumnCount(1)
self.members_tree.setIndentation(0)
self.add_button = QToolButton()
self.add_button.setToolTip("<p>Add selected non-members.</p>")
self.add_button.setIcon(QIcon(":/icons/menu_icons/cube_plus.svg"))
self.add_button.setIconSize(QSize(24, 24))
self.add_button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.add_button.setText(">>")
self.remove_button = QToolButton()
self.remove_button.setToolTip("<p>Remove selected members.</p>")
self.remove_button.setIcon(QIcon(":/icons/menu_icons/cube_minus.svg"))
self.remove_button.setIconSize(QSize(24, 24))
self.remove_button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.remove_button.setText("<<")
self.vertical_button_widget = QWidget()
vertical_button_layout = QVBoxLayout(self.vertical_button_widget)
vertical_button_layout.addStretch()
vertical_button_layout.addWidget(self.add_button)
vertical_button_layout.addWidget(self.remove_button)
vertical_button_layout.addStretch()
self.button_box = QDialogButtonBox(self)
self.button_box.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
layout = QGridLayout(self)
layout.addWidget(self.header_widget, 0, 0, 1, 3, Qt.AlignHCenter)
layout.addWidget(self.non_members_tree, 1, 0)
layout.addWidget(self.vertical_button_widget, 1, 1)
layout.addWidget(self.members_tree, 1, 2)
layout.addWidget(self.button_box, 2, 0, 1, 3)
self.setAttribute(Qt.WA_DeleteOnClose)
self.db_combo_box.addItems(list(self.db_maps_by_codename))
self.db_map_object_ids = {
db_map: {
x["name"]: x["id"]
for x in self.db_mngr.get_items_by_field(
self.db_map, "object", "class_id",
self.object_class_item.db_map_id(db_map))
}
for db_map in db_maps
}
self.reset_list_widgets(db_maps[0].codename)
self.connect_signals()
def connect_signals(self):
"""Connect signals to slots."""
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
self.db_combo_box.currentTextChanged.connect(self.reset_list_widgets)
self.add_button.clicked.connect(self.add_members)
self.remove_button.clicked.connect(self.remove_members)
def reset_list_widgets(self, database):
self.db_map = self.db_maps_by_codename[database]
object_ids = self.db_map_object_ids[self.db_map]
members = []
non_members = []
for obj_name, obj_id in object_ids.items():
if obj_id in self.initial_member_ids():
members.append(obj_name)
elif obj_id != self.initial_entity_id():
non_members.append(obj_name)
member_items = [QTreeWidgetItem([obj_name]) for obj_name in members]
non_member_items = [
QTreeWidgetItem([obj_name]) for obj_name in non_members
]
self.members_tree.addTopLevelItems(member_items)
self.non_members_tree.addTopLevelItems(non_member_items)
def initial_member_ids(self):
raise NotImplementedError()
def initial_entity_id(self):
raise NotImplementedError()
@Slot(bool)
def add_members(self, checked=False):
indexes = sorted([
self.non_members_tree.indexOfTopLevelItem(x)
for x in self.non_members_tree.selectedItems()
],
reverse=True)
items = [
self.non_members_tree.takeTopLevelItem(ind) for ind in indexes
]
self.members_tree.addTopLevelItems(items)
@Slot(bool)
def remove_members(self, checked=False):
indexes = sorted([
self.members_tree.indexOfTopLevelItem(x)
for x in self.members_tree.selectedItems()
],
reverse=True)
items = [self.members_tree.takeTopLevelItem(ind) for ind in indexes]
self.non_members_tree.addTopLevelItems(items)
def _check_validity(self):
if not self.members_tree.topLevelItemCount():
self.parent().msg_error.emit(
"Please select at least one member object.")
return False
return True
