def create_ui(self):
fields_label = QLabel(_("Class fields"), self)
self.layout.addWidget(fields_label, 0, 0)
self._fields_tree = QTreeWidget(self)
fields_label.setBuddy(self._fields_tree)
self._fields_tree.currentItemChanged.connect(
self.on_fields_tree_sel_changed)
self.layout.addWidget(self._fields_tree, 1, 0)
operator_label = QLabel(_("Operator"), self)
self.layout.addWidget(operator_label, 0, 1)
self._operator = QListWidget(self)
operator_label.setBuddy(self._operator)
self.layout.addWidget(self._operator, 1, 1)
self._operator.currentRowChanged.connect(self.on_operator_choice)
self._operator.setCurrentRow(0)
add_button = QPushButton(_("&Add condition"), self)
add_button.clicked.connect(self.on_add_clicked)
self.layout.addWidget(add_button, 2, 0, 1, 3)
criteria_label = QLabel(_("Current search criteria"), self)
self.layout.addWidget(criteria_label, 3, 0, 1, 3)
self._criteria_list = QListWidget(self)
criteria_label.setBuddy(self._criteria_list)
self.layout.addWidget(self._criteria_list, 4, 0, 1, 3)
remove_button = QPushButton(_("&Remove condition"), self)
remove_button.clicked.connect(self.on_remove_clicked)
self.layout.addWidget(remove_button, 5, 0, 1, 3)
distance_label = QLabel(_("Search objects to distance"), self)
self.layout.addWidget(distance_label, 6, 0)
self._distance_field = QSpinBox(self)
self._distance_field.setMaximum(100000)
self._distance_field.setSuffix(" " + _("meters"))
self._distance_field.setSpecialValueText(_("No limit"))
distance_label.setBuddy(self._distance_field)
self.layout.addWidget(self._distance_field, 6, 1)
def _createFilterTree(self, spatial_filters):
av = self.model.activeView
tally = self.model.statepoint.tallies[av.selectedTally]
filters = tally.filters
# create a tree for the filters
self.treeLayout = QVBoxLayout()
self.filterTree = QTreeWidget()
self.treeLayout.addWidget(self.filterTree)
self.treeExpander = Expander("Filters:", layout=self.treeLayout)
self.treeExpander.expand() # start with filters expanded
header = QTreeWidgetItem(["Filters"])
self.filterTree.setHeaderItem(header)
self.filterTree.setItemHidden(header, True)
self.filterTree.setColumnCount(1)
self.filter_map = {}
self.bin_map = {}
for tally_filter in filters:
filter_label = str(type(tally_filter)).split(".")[-1][:-2]
filter_item = QTreeWidgetItem(self.filterTree, (filter_label,))
self.filter_map[tally_filter] = filter_item
# make checkable
if not spatial_filters:
filter_item.setFlags(QtCore.Qt.ItemIsUserCheckable)
filter_item.setToolTip(0, "Only tallies with spatial filters are viewable.")
else:
filter_item.setFlags(filter_item.flags() | QtCore.Qt.ItemIsTristate | QtCore.Qt.ItemIsUserCheckable)
filter_item.setCheckState(0, QtCore.Qt.Unchecked)
if isinstance(tally_filter, MeshFilter):
filter_item.setCheckState(0, QtCore.Qt.Checked)
filter_item.setFlags(QtCore.Qt.ItemIsUserCheckable)
filter_item.setToolTip(0, "All Mesh bins are selected automatically")
continue
def _bin_sort_val(bin):
if isinstance(bin, Iterable) and all([isinstance(val, float) for val in bin]):
return np.sum(bin)
else:
return bin
for bin in sorted(tally_filter.bins, key=_bin_sort_val):
item = QTreeWidgetItem(filter_item, [str(bin),])
if not spatial_filters:
item.setFlags(QtCore.Qt.ItemIsUserCheckable)
item.setToolTip(0, "Only tallies with spatial filters are viewable.")
else:
item.setFlags(item.flags() | QtCore.Qt.ItemIsUserCheckable)
item.setCheckState(0, QtCore.Qt.Unchecked)
bin = bin if not isinstance(bin, Iterable) else tuple(bin)
self.bin_map[tally_filter, bin] = item
# start with all filters selected if spatial filters are present
if spatial_filters:
filter_item.setCheckState(0, QtCore.Qt.Checked)
def __init__(self, path, settings, session):
QWidget.__init__(self)
ABookCore.__init__(self, path, settings, session)
self.signal = CourseTreeWidgetSignals()
self.selectedList = []
self.treeWidget = QTreeWidget()
self.treeWidget.setHeaderLabels(['Name', "Course ID", "Chapter ID"])
self.treeWidget.itemChanged.connect(self.checkbox_toggled)
self.treeWidget.clicked.connect(self.loadResourceList)
self.addDownloadTaskButton = QPushButton("Add to Downloader")
self.addDownloadTaskButton.clicked.connect(self.addDownloadTask)
self.importCourseButton = QPushButton("Import Courses")
self.importCourseButton.clicked.connect(self.startImportCourseWidget)
main_layout = QGridLayout()
main_layout.addWidget(self.treeWidget, 0, 0, 1, 2)
main_layout.addWidget(self.importCourseButton, 1, 0)
main_layout.addWidget(self.addDownloadTaskButton, 1, 1)
main_layout.setMargin(0)
self.setLayout(main_layout)
if settings['first_launch'] is True:
settings['first_launch'] = False
self.importCourseButton.click()
else:
self.createTreeRoot()
def __init__(self):
super(SelectTiVoWidget, self).__init__()
self.tivos_found = []
self.label = QLabel(self)
self.label.setText('Below is a listing of all TiVos discovered on your'
' network, which will refresh every 5 seconds. If y'
'ou do not see your TiVo, '
'<a href="#specify_ip">click here to specify an IP'
' address.</a>')
self.label.linkActivated.connect(self.specify_ip_address)
self.tivo_listings = QTreeWidget(self)
self.tivo_listings.itemDoubleClicked.connect(self.tivo_selected)
self.tivo_listings.setHeaderLabels(["Name", "IP Address"])
self.layout = QVBoxLayout(self)
self.layout.addWidget(self.label)
self.layout.addWidget(self.tivo_listings)
self.setWindowTitle("Select TiVo")
self.resize(512, 384)
self.setModal(True)
def __init__(self,
parent,
title,
person,
unsorted_objects,
autoshow=True,
progress_indicator=None):
super().__init__(None)
act = QAction("close", self)
act.triggered.connect(self._do_close)
act.setShortcut(QKeySequence("escape"))
self.addAction(act)
layout = QGridLayout()
bar = QMenuBar(self)
self._object_actions = bar.addMenu(_("Object actions"))
property_actions = bar.addMenu(_("Property actions"))
self._create_item(property_actions, _("Copy property value"), "ctrl+c",
self.on_copypropvalue_selected)
self._create_item(property_actions, _("Copy property name"), "alt+c",
self.on_copypropname_selected)
self._create_item(property_actions, _("Copy property name and value"),
"ctrl+alt+c", self.on_copypropline_selected)
objects_label = QLabel(_("Objects"), self)
layout.addWidget(objects_label, 0, 0)
self._objects_list = QListWidget(self)
self._objects_list.setAccessibleName(objects_label.text())
self._objects_list.setContextMenuPolicy(Qt.CustomContextMenu)
self._objects_list.currentRowChanged.connect(self.on_objects_listbox)
self._objects_list.customContextMenuRequested.connect(
self._on_objects_list_menu)
objects_label.setBuddy(self._objects_list)
layout.addWidget(self._objects_list, 1, 0)
props_label = QLabel(_("Object properties"), self)
layout.addWidget(props_label, 0, 1)
self._props = QTreeWidget(self)
self._props.setAccessibleName(props_label.text())
props_label.setBuddy(self._props)
layout.addWidget(self._props, 1, 1)
goto_button = QPushButton(_("Go to"), self)
goto_button.setDefault(True)
goto_button.clicked.connect(self.on_goto_clicked)
self._objects_list.itemActivated.connect(goto_button.click)
layout.addWidget(goto_button, 2, 0)
close_button = QPushButton(_("Close"), self)
close_button.clicked.connect(self.close)
layout.addWidget(close_button, 2, 1)
self.setLayout(layout)
self.setWindowTitle(title + _(" ({num_objects} objects shown)").format(
num_objects=len(unsorted_objects)))
self._person = person
self._autoshow = autoshow
self._progress_indicator = progress_indicator
self._all_actions = []
for member in object_actions.__dict__.values():
if inspect.isclass(member) and issubclass(member, ObjectAction):
self._all_actions.append(member)
self._objects_list.setCurrentRow(0)
self._sorter = ObjectsSorter(unsorted_objects, person)
self._sorter.objects_sorted.connect(self._objects_sorted)
self._sorter.start()
def _init_widgets(self):
self._tree = QTreeWidget()
self._tree.setHeaderHidden(True)
self._tree.itemDoubleClicked.connect(self.on_item_doubleclicked)
layout = QVBoxLayout()
layout.addWidget(self._tree)
self.setLayout(layout)
def initUI(self):
self.listWidget = QListWidget()
self.initDevices()
self.treeWidget = QTreeWidget()
self.treeWidget.itemPressed.connect(self.onItemPressed)
self.treeWidget.setColumnCount(4)
self.treeWidget.setColumnWidth(0, 250)
self.treeWidget.setColumnWidth(1, 300)
self.treeWidget.setColumnWidth(2, 300)
self.treeWidget.setColumnWidth(3, 150)
self.treeWidget.setHeaderLabels(["Service", "Service UUID", "Characteristic UUID", "Characteristic Property"])
btn = QPushButton("Read Services")
btn.clicked.connect(self.onPushButton)
groupDevices = QGroupBox("Devices")
groupDevices.setMaximumWidth(300)
vbox = QVBoxLayout()
vbox.addWidget(self.listWidget)
vbox.addWidget(btn)
groupDevices.setLayout(vbox)
self.btnR = QPushButton("Read")
self.btnR.clicked.connect(self.onReadButton)
self.btnW = QPushButton("Write")
self.btnW.clicked.connect(self.onWriteButton)
self.lneI = QLineEdit()
self.chkN = QCheckBox("Notify")
self.chkN.toggled.connect(self.onNotifyCheck)
hbox = QHBoxLayout()
hbox.addWidget(self.btnR)
hbox.addWidget(self.btnW)
hbox.addWidget(self.lneI)
hbox.addWidget(self.chkN)
groupProperty = QGroupBox("Property")
#groupProperty.setLayout(vbox)
groupProperty.setLayout(hbox)
groupServices = QGroupBox("Services")
vbox = QVBoxLayout()
vbox.addWidget(self.treeWidget)
vbox.addWidget(groupProperty)
groupServices.setLayout(vbox)
hbox = QHBoxLayout()
hbox.addWidget(groupDevices)
hbox.addWidget(groupServices)
self.setLayout(hbox)
self.setGeometry(300, 300, 800, 600)
self.setWindowTitle('BLE Discover')
self.show()
def setup_ui(self):
layout = QGridLayout()
table = QTreeWidget()
table.setHeaderLabels(['name', 'width', 'height', 'ratio'])
table.setSortingEnabled(True)
items = []
for size in self.manager.project.sizes:
i = ComparingTreeWidgetItem(None, [
f'{size.width}x{size.height}',
str(size.width),
str(size.height),
str(size.ratio())
])
i.__data__ = size
items.append(i)
table.addTopLevelItems(items)
@table.currentItemChanged.connect
def _(item, prev):
del_btn.setEnabled(item is not None)
layout.addWidget(table, 0, 0, 1, 2)
add_btn = QPushButton('add new')
@add_btn.clicked.connect
def _(*args):
diag = SizeInput(self.manager.project.sizes, self)
if diag.exec_() != QDialog.Accepted:
return
size = diag.value
self.manager.add_size(size)
item = ComparingTreeWidgetItem(None, [
f'{size.width}x{size.height}',
str(size.width),
str(size.height),
str(size.ratio())
])
table.addTopLevelItem(item)
layout.addWidget(add_btn, 1, 0)
del_btn = QPushButton('delete')
del_btn.setEnabled(False)
@del_btn.clicked.connect
def _(*args):
item = table.currentItem()
size = item.__data__
self.manager.del_size(size)
shiboken2.delete(item)
layout.addWidget(del_btn, 1, 1)
self.setLayout(layout)
def __init__(self):
super().__init__()
self.tree = QTreeWidget()
self.tree.setHeaderHidden(True)
layout = QVBoxLayout()
layout.addWidget(self.tree)
self.setLayout(layout)
self.tree.setIndentation(0)
self.sections = []
self.define_sections()
self.add_sections()
def testWidgetIterator(self):
treeWidget = QTreeWidget()
treeWidget.setColumnCount(1)
items = []
for i in range(10):
items.append(QTreeWidgetItem(None, ['item: %d' % i]))
treeWidget.insertTopLevelItems(0, items)
index = 0
for it in QTreeWidgetItemIterator(treeWidget):
self.assertEqual(it.value().text(0), 'item: %d' % index)
index += 1
def __init__(self):
super().__init__()
self.tree = QTreeWidget()
self.tree.setHeaderHidden(True)
self.tree.setPalette(get_verifone_color())
self.setStyleSheet("background-color: rgba(3, 169, 229, 0)")
layout = QVBoxLayout()
self.buttonGroup = QButtonGroup()
layout.addWidget(self.tree)
self.setLayout(layout)
self.tree.setIndentation(0)
self.setPalette(get_verifone_color())
self.sections = []
self.setFixedWidth(500)
def testCase(self):
treeWidget = QTreeWidget()
treeWidget.setColumnCount(1)
items = []
for i in range(10):
items.append(QTreeWidgetItem(None, ["item: %i" % i]))
treeWidget.insertTopLevelItems(0, items);
_iter = QTreeWidgetItemIterator(treeWidget)
index = 0
while(_iter.value()):
item = _iter.value()
self.assertTrue(item is items[index])
index += 1
_iter += 1
def initializePage(self):
if self.layout() != None:
# print("clean up previous entries")
while self.layout().count() > 0:
self.layout().removeItem(self.layout().itemAt(0))
self.tree = QTreeWidget()
if self.wizard().defaultShare != None:
self.tree.addTopLevelItem(
MyTreeWidgetItem(self.tree,
self.wizard().defaultShare))
else:
shares = self.wizard().getShares()
if shares == None:
print("No shares found...")
return
print(",".join([x.name for x in shares]))
for m in shares:
if m.name not in [
"ADMIN$", "C$", "IPC$", "NETLOGON", "SYSVOL"
]:
self.tree.addTopLevelItem(MyTreeWidgetItem(self.tree, m))
shareListBox = QWidget()
shareListBoxLayout = QVBoxLayout()
self.tree.setHeaderLabel("Freigaben")
self.tree.itemClicked.connect(self.treeViewItemClicked)
shareListBoxLayout.addWidget(self.tree)
shareListBox.setLayout(shareListBoxLayout)
self.folderList = QListWidget()
folderListBox = QWidget()
folderListBoxLayout = QVBoxLayout()
folderListHeaderMessage = "Verzeichnisinhalt"
folderListBoxLayout.addWidget(QLabel(folderListHeaderMessage))
folderListBoxLayout.addWidget(self.folderList)
folderListBox.setLayout(folderListBoxLayout)
layout = QHBoxLayout()
layout.addWidget(shareListBox)
layout.addWidget(folderListBox)
self.setLayout(layout)
def reset_model(self, index):
"""Setup model according to current relationship_class selected in combobox.
"""
self.class_name, self.object_class_name_list = self.relationship_class_keys[
index]
object_class_name_list = self.object_class_name_list.split(",")
self.model.set_horizontal_header_labels(object_class_name_list)
self.existing_items_model.set_horizontal_header_labels(
object_class_name_list)
self.new_items_model.set_horizontal_header_labels(
object_class_name_list)
self.relationship_ids.clear()
for db_map in self.db_maps:
relationship_classes = self.db_map_rel_cls_lookup[db_map]
rel_cls = relationship_classes.get(
(self.class_name, self.object_class_name_list), None)
if rel_cls is None:
continue
for relationship in self.db_mngr.get_items_by_field(
db_map, "relationship", "class_id", rel_cls["id"]):
key = tuple(relationship["object_name_list"].split(","))
self.relationship_ids[key] = relationship["id"]
existing_items = list(self.relationship_ids)
self.existing_items_model.reset_model(existing_items)
self.model.refresh()
self.model.modelReset.emit()
for wg in self.splitter_widgets():
wg.deleteLater()
for name in object_class_name_list:
tree_widget = QTreeWidget(self)
tree_widget.setSelectionMode(QAbstractItemView.ExtendedSelection)
tree_widget.setColumnCount(1)
tree_widget.setIndentation(0)
header_item = QTreeWidgetItem([name])
header_item.setTextAlignment(0, Qt.AlignHCenter)
tree_widget.setHeaderItem(header_item)
objects = self.db_mngr.get_items_by_field(self.db_map, "object",
"class_name", name)
items = [QTreeWidgetItem([obj["name"]]) for obj in objects]
tree_widget.addTopLevelItems(items)
tree_widget.resizeColumnToContents(0)
self.splitter.addWidget(tree_widget)
sizes = [wg.columnWidth(0) for wg in self.splitter_widgets()]
self.splitter.setSizes(sizes)
for widget in self.hidable_widgets:
widget.show()
def _crateSelectors(self):
self.mLayout = QVBoxLayout(self)
wsLayout = QVBoxLayout()
alg = self.algManager
self.wsSelector = WorkspaceChooser(alg)
self.wsSelector.setMaximumHeight(70)
groups = self.chartData.getDataGroups()
self.wsSelector.addItems(groups)
self.wsSelector.currentTextChanged.connect(self._updateAll)
self.chartData.dataGroupAdded.connect(self.addNewGroup)
self.mLayout.addWidget(QLabel('Workspaces'))
self.mLayout.addWidget(self.wsSelector)
self.chartData.allRemoved.connect(self._resetWorkspaces)
self.chSelector = QTreeWidget()
self.chSelector.setHeaderHidden(True)
self.chSelector.itemClicked.connect(self.changeCurrentSelect)
self.chSelector.itemChanged.connect(self.itemChanged)
self.mLayout.addWidget(QLabel('Channels'))
self.mLayout.addWidget(self.chSelector)
self.sSelector = SignalChooser()
self.sSelector.setHeaderHidden(True)
self.sSelector.setDragEnabled(True)
self.sSelector.setDropIndicatorShown(True)
self.sSelector.setContextMenuPolicy(Qt.CustomContextMenu)
self.createSignalPopupMenu(self.sSelector)
self.sSelector.customContextMenuRequested.connect(self.onSignalContextMenu)
self.sSelector.itemClicked.connect(self.changeCurrentSelect)
self.sSelector.itemPressed.connect(self.signalPress)
self.sSelector.itemChanged.connect(self.itemChanged)
self.mLayout.addWidget(QLabel('Signals'))
self.mLayout.addWidget(self.sSelector)
self.gSelector = SignalGroupsChooser(self.chartData, self.wsSelector)
self.mLayout.addWidget(QLabel('Signal Groups'))
self.mLayout.addWidget(self.gSelector)
self.wsSelector.setCurrentRow(0)
self.chartData.signalAdded.connect(self._updateAll)
self.chartData.signalRemoved.connect(self._updateAll)
self.chartData.signalGroupAdded.connect(self._updateAll)
self.chartData.signalGroupRemoved.connect(self._updateAll)
self.chartData.signalToGrupAdded.connect(self._updateAll)
self.chartData.signalFromGroupRemoved.connect(self._updateAll)
def _init_finds_tab(self, tab):
finds_list = QTreeWidget()
finds_list.setHeaderHidden(True)
self._finds_list = finds_list
layout = QVBoxLayout()
layout.addWidget(finds_list)
frame = QFrame()
frame.setLayout(layout)
import_button = QPushButton("Import List")
import_button.clicked.connect(lambda: self._import_to_list(self._finds_list))
layout.addWidget(import_button)
tab.addTab(frame, 'Finds')
self._finds_list.itemChanged.connect(self._on_explore_addr_changed)
def add_tree_no_header(self, parent):
tw = QTreeWidget()
parent.addWidget(tw)
tw.setHeaderHidden(True)
tw.setAlternatingRowColors(True)
i1 = QTreeWidgetItem(tw, ['Mammal'])
i2 = QTreeWidgetItem(i1, ['Rodent'])
i3 = QTreeWidgetItem(i2, ['Rat'])
i3 = QTreeWidgetItem(i2, ['Beaver'])
i2 = QTreeWidgetItem(i1, ['Primate'])
i3 = QTreeWidgetItem(i2, ['Baboon'])
i3 = QTreeWidgetItem(i2, ['Human'])
i1 = QTreeWidgetItem(tw, ['Reptile'])
i2 = QTreeWidgetItem(i1, ['Snake'])
i3 = QTreeWidgetItem(i1, ['Crocodile'])
self.add_expand_collapse_buttons(parent, tw)
def add_tree_with_header(self, parent):
tw = QTreeWidget()
parent.addWidget(tw)
tw.setHeaderLabels(['Type', 'Legs', 'Has Hair/Fur'])
tw.setSortingEnabled(True)
tw.setAlternatingRowColors(True)
i1 = QTreeWidgetItem(tw, ['Mammal'])
i2 = QTreeWidgetItem(i1, ['Rodent'])
i3 = QTreeWidgetItem(i2, ['Rat', '4', 'True'])
i3 = QTreeWidgetItem(i2, ['Beaver', '2', 'True'])
i2 = QTreeWidgetItem(i1, ['Primate'])
i3 = QTreeWidgetItem(i2, ['Baboon', '2', 'True'])
i3 = QTreeWidgetItem(i2, ['Human', '2', 'True'])
i1 = QTreeWidgetItem(tw, ['Reptile'])
i2 = QTreeWidgetItem(i1, ['Snake', '0', 'False'])
i3 = QTreeWidgetItem(i1, ['Crocodile', '4', 'False'])
self.add_expand_collapse_buttons(parent, tw)
def make_viewer(self, exif_reader):
self.exif_reader = exif_reader
ifds = self.exif_reader.get_exif()
self.qw_tree = QTreeWidget(self)
qt_util_init_tree(self.qw_tree, header_list=['ifd_name'])
self.qw_stack = QStackedWidget(self)
self.tree_type_to_stack_idx = {}
for tree_item_type, (ifd_name, ifd) in enumerate(ifds.items()):
# -----------------------
# treeにifd nameを書き込んでroot_treeに登録する.
# -----------------------
qw_tree_item = QTreeWidgetItem(['{} ifd'.format(ifd_name), ''],
type=tree_item_type)
self.qw_tree.addTopLevelItem(qw_tree_item)
# -----------------------
# text_editにexif情報を書き込んでstacked_widgetに登録する.
# -----------------------
qw_text_edit = QTextEdit(self)
qt_util_init_text_edit(qw_text_edit)
qt_util_append_text_edit(qw_text_edit, None, head=True)
for _, tag in ifd.items():
qt_util_append_text_edit(qw_text_edit,
tag,
head=False,
display_max_len=50)
qt_util_reset_text_edit_cursor(qw_text_edit)
idx = self.qw_stack.addWidget(qw_text_edit)
self.tree_type_to_stack_idx[tree_item_type] = idx
else:
self.qw_tree.itemClicked.connect(self._tree_item_clicked)
# -----------------------
# widgetをlayoutに登録する.
# -----------------------
widgets = [self.qw_tree, self.qw_stack]
self._make_layout(widgets)
self._make_toolbar()
self.show() # widgetを表示する.
def _init_widgets(self):
# search box
self._search_box = QLineEdit()
# tree view
self._treewidget = QTreeWidget()
self._treewidget.setHeaderHidden(True)
# refresh button
self._apply_btn = QPushButton("Apply")
self._apply_btn.clicked.connect(self._code_view.decompile)
layout = QVBoxLayout()
layout.addWidget(self._search_box)
layout.addWidget(self._treewidget)
layout.addWidget(self._apply_btn)
self.setLayout(layout)
def _init_widgets(self):
# search box
self._search_box = QLineEdit()
# tree view
self._treewidget = QTreeWidget()
self._treewidget.setHeaderHidden(True)
self._treewidget.itemChanged.connect(self._on_item_changed)
# refresh button
self._apply_btn = QPushButton("Apply")
self._apply_btn.clicked.connect(self._on_apply_pressed)
layout = QVBoxLayout()
layout.addWidget(self._search_box)
layout.addWidget(self._treewidget)
layout.addWidget(self._apply_btn)
self.setLayout(layout)
def testSetItemWidget(self):
treeWidget = QTreeWidget()
treeWidget.setColumnCount(2)
item = QTreeWidgetItem(['text of column 0', ''])
treeWidget.insertTopLevelItem(0, item)
# Adding QPushButton inside the method
treeWidget.setItemWidget(item, 1,
QPushButton('Push button on column 1'))
# Getting the widget back
w = treeWidget.itemWidget(treeWidget.itemAt(0, 1), 1)
self.assertIsInstance(w, QPushButton)
p = QPushButton('New independent button')
# Adding QPushButton object from variable
treeWidget.setItemWidget(item, 0, p)
w = treeWidget.itemWidget(treeWidget.itemAt(0, 0), 0)
self.assertIsInstance(w, QPushButton)
def init_ui(self):
self.vbox = QVBoxLayout()
self.refresh = QPushButton('Refresh')
self.refresh.clicked.connect(lambda: self.get_map())
self.vbox.addWidget(self.refresh)
self.tree = QTreeWidget()
self.tree.itemDoubleClicked.connect(self.open_region)
self.tree.setColumnCount(3)
self.tree.header().setSectionResizeMode(QHeaderView.ResizeToContents)
self.tree.header().setStretchLastSection(False)
self.tree.setHeaderLabels(
['Memory Region', 'Start Address', 'End Address'])
self.vbox.addWidget(self.tree)
self.setLayout(self.vbox)
self.setGeometry(100, 100, 500, 300)
self.setWindowTitle("Memory Tree")
self.show()
def setup_ui(self):
layout = QGridLayout()
table = QTreeWidget()
table.setHeaderLabels(['name', 'type', 'width', 'height'])
table.setSortingEnabled(True)
items = []
for photo in self.manager.project.photos:
if not photo.is_available():
w = h = 'N/A!'
else:
w, h = photo.raw_size()
i = ComparingTreeWidgetItem(
None,
[str(photo), type(photo).__name__,
str(w), str(h)])
i.__data__ = photo
items.append(i)
table.addTopLevelItems(items)
@table.currentItemChanged.connect
def _(item, prev):
del_btn.setEnabled(item is not None)
layout.addWidget(table, 0, 0)
del_btn = QPushButton('delete')
del_btn.setEnabled(False)
@del_btn.clicked.connect
def _(*args):
item = table.currentItem()
size = item.__data__
self.manager.del_photo(size)
shiboken2.delete(item)
layout.addWidget(del_btn, 1, 0)
self.setLayout(layout)
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 initUI(self):
self.setWindowTitle("My Form")
self.mainWindowWidget = QWidget(self)
self.mainLeftWidget = QWidget(self)
self.mainRightWidget = QWidget(self)
self.i = 0
self.vlayout_left = QVBoxLayout()
self.vlayout_right = QVBoxLayout()
self.hlayout_all = QHBoxLayout()
showFilePath = QLineEdit(self)
self.tools = ToolsWidget(self)
# tools.setStyleSheet("background:rgb(0,255,255)")
toolBoxTree = QTreeWidget(self)
self.canvas = CanvasWidget(self)
self.canvas.setText("label")
# self.canvas.setStyleSheet("background:rgb(255,0,255)")
self.vlayout_left.addWidget(self.tools)
self.vlayout_left.addWidget(toolBoxTree)
self.vlayout_left.setStretchFactor(self.tools, 1)
self.vlayout_left.setStretchFactor(toolBoxTree, 1)
self.vlayout_right.addWidget(showFilePath)
self.vlayout_right.addWidget(self.canvas)
# self.vlayout_right.setStretchFactor(showFilePath,1)
# self.vlayout_right.setStretchFactor(showSrcPicture,1)
self.mainLeftWidget.setLayout(self.vlayout_left)
self.mainRightWidget.setLayout(self.vlayout_right)
self.hlayout_all.addWidget(self.mainLeftWidget)
self.hlayout_all.addWidget(self.mainRightWidget)
self.hlayout_all.setStretchFactor(self.mainLeftWidget, 1)
self.hlayout_all.setStretchFactor(self.mainRightWidget, 3)
self.mainWindowWidget.setLayout(self.hlayout_all)
self.setCentralWidget(self.mainWindowWidget)
#菜单
menu = self.menuBar()
openMenu = menu.addMenu("&Open")
oFAct = QAction("Open File", self)
openMenu.addAction(oFAct)
testMenu = menu.addMenu("&Test")
test1 = QAction("Bezier", self)
testMenu.addAction(test1)
test2 = QAction("test2", self)
testMenu.addAction(test2)
toolMenu = menu.addMenu("&Tools")
penTool = QAction("Pen", self)
toolMenu.addAction(penTool)
scissorTool = QAction("Scissor", self)
toolMenu.addAction(scissorTool)
# 连接槽函数
# self.tools.generate_contour.clicked.connect(self.generateContour)
self.tools.generate_contour.clicked.connect(self.b1Click)
self.tools.b2.clicked.connect(self.b2Click)
self.tools.b3.clicked.connect(self.b3Click)
self.tools.b4.clicked.connect(self.b4Click)
# 打开文件
oFAct.triggered.connect(self.onOpenFile)
test1.triggered.connect(self.test1)
test2.triggered.connect(self.test2)
penTool.triggered.connect(self.penToolClick)
scissorTool.triggered.connect(self.scissorTool)
pass
def _init_widgets(self):
layout = QGridLayout()
row = 0
validation_failures = set()
# name
name_label = QLabel(self)
name_label.setText("Name")
name_box = QLineEdit(self)
name_box.setText(NameGenerator.random_name())
def handle_name(txt):
nonlocal validation_failures
key = {'name'}
if txt and not any(s.gui_data.name == txt
for s in self.instance.states):
validation_failures -= key
else:
validation_failures |= key
validation_update()
name_box.textEdited.connect(handle_name)
layout.addWidget(name_label, row, 0)
layout.addWidget(name_box, row, 1)
row += 1
# address
address_label = QLabel(self)
address_label.setText("Address")
address_box = QLineEdit(self)
address_box.setText(
hex(self.instance.project.entry
) if self._addr is None else hex(self._addr))
def handle_address(_):
nonlocal validation_failures
key = {'addr'}
if parse_address() is not None:
validation_failures -= key
else:
validation_failures |= key
validation_update()
def parse_address():
txt = address_box.text()
try:
return self.instance.project.kb.labels.lookup(txt)
except KeyError:
pass
try:
return int(txt, 16)
except ValueError:
return None
address_box.textEdited.connect(handle_address)
layout.addWidget(address_label, row, 0)
layout.addWidget(address_box, row, 1)
row += 1
# template
template_label = QLabel(self)
template_label.setText("Template")
template_combo = QComboBox()
template_combo.addItem("Blank State", 'blank')
template_combo.addItem("Call state", 'call')
template_combo.addItem("Entry state", 'entry')
template_combo.addItem("Full-init state", 'full')
def handle_template(_):
base_allowed = template_combo.currentData() in ('blank', 'call')
base_state_combo.setHidden(not base_allowed)
base_state_label.setHidden(not base_allowed)
template_combo.currentIndexChanged.connect(handle_template)
layout.addWidget(template_label, row, 0)
layout.addWidget(template_combo, row, 1)
row += 1
# base state
base_state_label = QLabel(self)
base_state_label.setText('Base state')
base_state_combo = QStateComboBox(self.instance, self)
self._base_state_combo = base_state_combo
layout.addWidget(base_state_label, row, 0)
layout.addWidget(base_state_combo, row, 1)
row += 1
# mode
mode_label = QLabel(self)
mode_label.setText("Mode")
mode_combo = QComboBox(self)
mode_combo.addItem("Symbolic", "symbolic")
mode_combo.addItem("Static", "static")
mode_combo.addItem("Fast-path", "fastpath")
mode_combo.addItem("Tracing", "tracing")
self._mode_combo = mode_combo
def mode_changed():
self._options.clear()
self._options.update(
angr.sim_options.modes[mode_combo.currentData()])
for child in children_items:
child.setCheckState(
0, Qt.Checked
if child.text(0) in self._options else Qt.Unchecked)
mode_combo.currentIndexChanged.connect(mode_changed)
self._options.clear()
self._options.update(angr.sim_options.modes[mode_combo.currentData()])
layout.addWidget(mode_label, row, 0)
layout.addWidget(mode_combo, row, 1)
row += 1
# options tree
options_label = QLabel(self)
options_label.setText("Options")
options_tree = QTreeWidget(self)
options_tree.setHeaderHidden(True)
children_items = []
for name, members in angr.sim_options.__dict__.items():
if type(members) is not set:
continue
if name == 'resilience_options':
continue
parent = QTreeWidgetItem(options_tree)
parent.setText(0, name)
parent.setFlags(parent.flags() | Qt.ItemIsTristate
| Qt.ItemIsUserCheckable)
for option in members:
child = QTreeWidgetItem(parent)
child.setText(0, option)
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setCheckState(
0, Qt.Checked if option in self._options else Qt.Unchecked)
children_items.append(child)
parent = QTreeWidgetItem(options_tree)
parent.setText(0, "All options")
parent.setFlags(parent.flags() | Qt.ItemIsTristate
| Qt.ItemIsUserCheckable)
for option in {
x
for x in angr.sim_options.__dict__.values()
if type(x) is str and is_option(x)
}:
child = QTreeWidgetItem(parent)
child.setText(0, option)
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setCheckState(
0, Qt.Checked if option in self._options else Qt.Unchecked)
children_items.append(child)
def maintain_model(item: QTreeWidgetItem, _):
option = item.text(0)
if not is_option(option):
return
checked = item.checkState(0)
if (option in self._options) == checked:
return
if checked:
self._options.add(option)
else:
self._options.remove(option)
for child in children_items:
if child is not item and child.text(0) == option:
child.setCheckState(0, checked)
options_tree.itemChanged.connect(maintain_model)
layout.addWidget(options_label, row, 0)
layout.addWidget(options_tree, row, 1)
row += 1
# options filter
options_filter_label = QLabel(self)
options_filter_label.setText("")
options_filter_box = QLineEdit(self)
options_filter_box.setPlaceholderText("Filter")
def do_filter(text):
for child in children_items:
child.setHidden(text.upper() not in child.text(0))
options_filter_box.textEdited.connect(do_filter)
layout.addWidget(options_filter_label, row, 0)
layout.addWidget(options_filter_box, row, 1)
row += 1
# buttons
ok_button = QPushButton(self)
ok_button.setText('OK')
def do_ok():
name = name_box.text()
template = template_combo.currentData()
addr = parse_address()
base_state = base_state_combo.state
mode = mode_combo.currentData()
if template in ('blank', 'call') and base_state is not None:
if template == 'blank':
self.state = self.instance.project.factory.blank_state(
addr=addr,
base_state=base_state,
options=self._options)
else:
self.state = self.instance.project.factory.call_state(
addr, base_state=base_state, options=self._options)
self.state.gui_data.base_name = base_state.gui_data.name
else:
if template == 'blank':
self.state = self.instance.project.factory.blank_state(
addr=addr, mode=mode, options=self._options)
elif template == 'call':
self.state = self.instance.project.factory.call_state(
addr, mode=mode, options=self._options)
elif template == 'entry':
self.state = self.instance.project.factory.entry_state(
mode=mode, options=self._options)
else:
self.state = self.instance.project.factory.full_init_state(
mode=mode, options=self._options)
self.state.gui_data.base_name = name
self.state.gui_data.is_base = True
self.state.gui_data.name = name
self.state.gui_data.is_original = True
if self._create_simgr:
self.instance.workspace.create_simulation_manager(
self.state, name)
self.close()
ok_button.clicked.connect(do_ok)
def validation_update():
ok_button.setDisabled(bool(validation_failures))
cancel_button = QPushButton(self)
cancel_button.setText('Cancel')
def do_cancel():
self.close()
cancel_button.clicked.connect(do_cancel)
buttons_layout = QHBoxLayout()
buttons_layout.addWidget(ok_button)
buttons_layout.addWidget(cancel_button)
self.main_layout.addLayout(layout)
self.main_layout.addLayout(buttons_layout)
# ---------------------------
# Treeにitemに子itemを追加する
# ---------------------------
import sys
from PySide2.QtWidgets import QApplication, QTreeWidget, QTreeWidgetItem
app = QApplication(sys.argv)
qw_tree = QTreeWidget()
qw_tree.setHeaderLabels(["name", "tel", "mail"])
qw_tree_parent_item = QTreeWidgetItem(['family'])
qw_tree_parent_item.addChild(
QTreeWidgetItem(['A', '111-111-111', '*****@*****.**'])) # Itemに子Itemを追加
qw_tree.addTopLevelItem(qw_tree_parent_item)
qw_tree.expandAll() # TreeのItemを全て開く
qw_tree.show()
sys.exit(app.exec_())
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()
from PySide2.QtWidgets import QTreeWidget device_props_tree_widget = QTreeWidget() #device_props_tree_widget.setExpanded(True)
