def add_list_widget_item(self, broker: Broker):
item = QListWidgetItem()
item.setText(broker.name)
self.ui.lw_brokers_list.addItem(item)
self.enable_widgets()
self.ui.lw_brokers_list.setCurrentRow(self.ui.lw_brokers_list.count() -
1)
def add_list_widget_item(self, objective: Objective):
item = QListWidgetItem()
item.setText(objective.name)
self.ui.lw_objectives_list.addItem(item)
self.enable_widgets()
self.ui.lw_objectives_list.setCurrentRow(
self.ui.lw_objectives_list.count() - 1)
def __init__(self):
super(ExportDialog, self).__init__()
self.ui = Ui_ExportDialog()
self.ui.setupUi(self)
self.okay = False
self.name_lambda = None
self.ui.selectCharacterButton.clicked.connect(
lambda: self.select_all(self.ui.characterBox))
self.ui.selectMoodButton.clicked.connect(
lambda: self.select_all(self.ui.moodBox))
self.accepted.connect(self.pressed_ok)
self.ui.fileNameBox.textChanged.connect(self.update_preview)
self.ui.formatBox.currentIndexChanged.connect(self.update_preview)
self.ui.reservedBox.stateChanged.connect(self.update_preview)
self.ui.spaceBox.stateChanged.connect(self.update_preview)
self.ui.fileNameBox.setText("{h}_{m}_{s}_{c}_{md}_{nl}_{t}")
all_chars = set()
all_moods = set()
jsonpath = os.path.dirname(
os.path.realpath(__file__)) + "/saved_changes/"
for f in os.listdir(jsonpath):
c, m = import_export.get_chars_and_moods(os.path.join(jsonpath, f))
all_chars = all_chars | c
all_moods = all_moods | m
for c in sorted(all_chars):
item = QListWidgetItem()
item.setText(c)
item.setCheckState(Qt.Checked)
self.ui.characterBox.addItem(item)
for m in sorted(all_moods):
item = QListWidgetItem()
item.setText(m)
item.setCheckState(Qt.Checked)
self.ui.moodBox.addItem(item)
def update_model_info(self, idx=None):
self.transitionListWidget.clear()
self.nodeTypeComboBox.setCurrentIndex(0)
selected_item = self.graphTreeWidget.currentItem()
if selected_item is None:
return
item_type = str(selected_item.text(1))
if item_type != "primitive":
return
item_name = str(selected_item.text(0))
mp_id = str(selected_item.data(0, Qt.UserRole))
action_name = str(selected_item.parent().text(0))
if action_name not in self.data["nodes"]:
return
if mp_id not in self.data["nodes"][action_name]:
print("mp id not in nodes", mp_id)
return
for transiton_key in self.data["nodes"][action_name][mp_id]["transitions"]:
item = QListWidgetItem()
item.setText(transiton_key)
self.transitionListWidget.addItem(item)
node_type = self.data["nodes"][action_name][mp_id]["type"]
index = self.nodeTypeComboBox.findText(node_type, Qt.MatchFixedString)
if index >= 0:
self.nodeTypeComboBox.setCurrentIndex(index)
print("node_type", node_type, index, mp_id)
def fill_joints_list(self):
self.jointList.clear()
joints = list(self.skeleton.nodes.keys())
for idx, joint_name in enumerate(joints):
item = QListWidgetItem()
item.setText(joint_name)
self.jointList.addItem(item)
def __init__(self):
super(LoadDialog, self).__init__()
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.detox_filenames()
self.ui.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
self.ui.listWidget.itemSelectionChanged.connect(self.selected_episode)
self.accepted.connect(self.pressed_ok)
self.episode_data = None
self.okay = False
for k, v in hashes.friendly_names.items():
item = QListWidgetItem()
path1 = (os.path.dirname(os.path.realpath(__file__)) +
"/saved_changes/" + k + ".json")
path2 = (os.path.dirname(os.path.realpath(__file__)) + "/labels/" +
k + ".txt")
if os.path.exists(path1):
item.setData(32, path1)
progress = import_export.check_progress(path1)
item.setText(v + " (" + str(progress) + "% complete)")
if progress == 100:
item.setBackgroundColor(QColor(20, 180, 20))
else:
item.setBackgroundColor(QColor(180, 64, 20))
elif os.path.exists(path2):
item.setData(32, path2)
item.setText(v)
else:
continue
self.ui.listWidget.addItem(item)
def add_list_widget_item(self, asset: Asset):
item = QListWidgetItem()
item.setText(asset.name)
self.ui.lw_assets_list.addItem(item)
self.enable_widgets()
self.ui.lw_assets_list.setCurrentRow(self.ui.lw_assets_list.count() -
1)
def add_list_widget_item(self, liability: Liability):
item = QListWidgetItem()
item.setText(liability.name)
self.ui.lw_liabilities_list.addItem(item)
self.enable_widgets()
self.ui.lw_liabilities_list.setCurrentRow(
self.ui.lw_liabilities_list.count() - 1)
def update_tables(self, tables):
"""
Update list of tables
"""
# create and delete mappings for tables
if isinstance(tables, list):
tables = {t: None for t in tables}
for t_name, t_mapping in tables.items():
if t_name not in self.table_mappings:
if t_mapping is None:
t_mapping = ObjectClassMapping()
else:
# add table to selected if connector gave a mapping object
# for the table
self.selected_source_tables.add(t_name)
self.table_mappings[t_name] = MappingListModel([t_mapping])
for k in list(self.table_mappings.keys()):
if k not in tables:
self.table_mappings.pop(k)
if not tables:
self._ui.source_list.clear()
self._ui.source_list.clearSelection()
return
# current selected table
selected = self._ui.source_list.selectedItems()
self.selected_source_tables = set(tables.keys()).intersection(
self.selected_source_tables)
# empty tables list and add new tables
self._ui.source_list.blockSignals(True)
self._ui.source_list.currentItemChanged.disconnect(self.select_table)
self._ui.source_list.clear()
self._ui.source_list.clearSelection()
for t in tables:
item = QListWidgetItem()
item.setText(t)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
if t in self.selected_source_tables:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
self._ui.source_list.addItem(item)
self._ui.source_list.currentItemChanged.connect(self.select_table)
self._ui.source_list.blockSignals(False)
# reselect table if existing otherwise select first table
if selected and selected[0].text() in tables:
table = selected[0].text()
self._ui.source_list.setCurrentRow(
tables.index(table), QItemSelectionModel.SelectCurrent)
elif tables:
# select first item
self._ui.source_list.setCurrentRow(
0, QItemSelectionModel.SelectCurrent)
if self._ui.source_list.selectedItems():
self.select_table(self._ui.source_list.selectedItems()[0])
self.tableChecked.emit()
def initializePage(self) -> None:
for course in self.courseList:
courseItem = QListWidgetItem()
courseItem.setText(course['courseTitle'])
courseItem.setData(-1, course)
# courseItem.setFlags(courseItem.flags() | Qt.ItemIsUserCheckable)
# courseItem.setCheckState(Qt.Checked)
self.courseListWidget.addItem(courseItem)
def _fill_list_with_scene_objects(self, scene):
for sceneObject in get_animation_controllers(scene):
item = QListWidgetItem()
item.setText(sceneObject.name)
item.setData(Qt.UserRole, sceneObject.node_id)
self.sceneObjectListWidget.addItem(item)
self.controllers[sceneObject.name] = sceneObject._components[
"animation_controller"]
def rebuild_selected_packages_list_widget(self):
# remove all items
self.selected_packages_list_widget.clear()
for f in self.file_paths:
file_item = QListWidgetItem()
file_item.setText(f)
self.selected_packages_list_widget.addItem(file_item)
def update_animation_controller_list(self):
self.animationControllerListWidget.clear()
if self._controller is None:
return
for anim_controller in self._controller.get_animation_controllers():
item = QListWidgetItem()
item.setText(anim_controller.scene_object.name)
self.animationControllerListWidget.addItem(item)
def _left_panel(self):
panel = QWidget()
box = QVBoxLayout()
btn_menu = QPushButton()
icn = QtGui.QIcon.fromTheme("application-menu")
btn_menu.setIcon(icn)
btn_menu.setIconSize(QSize(BTN_MENU_SIZE, BTN_MENU_SIZE))
btn_menu.setMaximumWidth(BTN_MENU_SIZE)
btn_menu.setMaximumHeight(BTN_MENU_SIZE)
btn_menu.setToolTip(_("Options"))
btn_menu.setObjectName("menuButton")
# box.addWidget(btn_menu,Qt.Alignment(1))
indexes = []
for index, option in self.stacks.items():
idx = index
lst_widget = QListWidgetItem()
lst_widget.setText(option['name'])
mod = option.get('module', None)
if mod:
try:
idx = mod.index
except:
pass
if idx > 0:
icn = QtGui.QIcon.fromTheme(option['icon'])
lst_widget.setIcon(icn)
if 'tooltip' in option.keys():
lst_widget.setToolTip(option['tooltip'])
while idx in indexes:
idx += 1
indexes.append(index)
self.stacks[idx]['widget'] = lst_widget
orderedStacks = {}
orderedStacks[0] = self.stacks[0]
#self.lst_options.addItem(orderedStacks[0]['widget'])
cont = 0
indexes.sort()
for index in indexes:
if index:
orderedStacks[cont] = self.stacks[index].copy()
if self.stacks[index].get('visible', True) == True:
self.lst_options.addItem(orderedStacks[cont]['widget'])
cont += 1
self.stacks = orderedStacks.copy()
box.addWidget(self.lst_options)
self.lst_options.currentRowChanged.connect(self._show_stack)
self.lst_options.setCurrentIndex(QModelIndex())
self.last_index = None
panel.setLayout(box)
self.resize(self.size().width() + box.sizeHint().width(),
self.size().height() + box.sizeHint().height() / 2)
self.lst_options.setFixedSize(
self.lst_options.sizeHintForColumn(0) + 2 *
(self.lst_options.frameWidth() + 15), self.height()
) #self.lst_options.sizeHintForRow(0) * self.lst_options.count() + 2 * (self.lst_options.frameWidth()+15))
return (panel)
def update_animation_file_list(self):
self.animationFileListWidget.clear()
if self._controller is None:
return
for anim_file in self._controller.get_animation_files():
item = QListWidgetItem()
item.setText(anim_file)
self.animationFileListWidget.addItem(item)
self.animationFileListWidget.itemClicked.connect(self.on_select_file)
def update_action_sequence_list(self):
self.actionListWidget.clear()
if self._action_sequence is None:
return
for action in self._action_sequence:
item = QListWidgetItem()
item.setText(action[0])
item.setData(Qt.UserRole, action[1])
self.actionListWidget.addItem(item)
def populate_unforged_list(list_widget, unforged):
list_widget.clear()
for k, v in unforged.items():
oc = QListWidgetItem(None)
try:
oc.setText(f'{v["weapon"]}: {v["name"]} ({k})')
except:
oc.setText(f"Cosmetic: {k}")
list_widget.addItem(oc)
def source_selected(self, current, previous):
if current is None:
return
self.current_source = current.text()
self.specListWidget.clear()
for spec in self.spec_data[self.current_source]:
if spec:
specItem = QListWidgetItem()
specItem.setText(spec)
self.specListWidget.addItem(specItem)
def populate_unforged_list(list_widget, unforged):
# populates the list on acquired but unforged overclocks (includes cosmetics)
list_widget.clear()
for k, v in unforged.items():
oc = QListWidgetItem(None)
try: # cosmetic overclocks don't have these values
oc.setText(f'{v["weapon"]}: {v["name"]} ({k})')
except:
oc.setText(f"Cosmetic: {k}")
list_widget.addItem(oc)
def create_project(self,
project_name: str,
visualization: bool = False,
stimulus: bool = False,
analysis: bool = False) -> None:
"""Create a new project with a template and open it."""
icon = QIcon()
icon_name = 'icon_sti'
if visualization:
icon_name = 'icon_viz'
item = QListWidgetItem(
self.parent_frame.listWidget_projects_visualizations)
default_project = '_default_visualization'
self.mode = 'visualization'
elif stimulus:
icon_name = 'icon_sti'
item = QListWidgetItem(
self.parent_frame.listWidget_projects_delivery)
default_project = '_default_stimuli_delivery'
self.mode = 'delivery'
elif analysis:
icon_name = 'icon_ana'
item = QListWidgetItem(
self.parent_frame.listWidget_projects_analysis)
default_project = '_default_data_analysis'
self.mode = 'analysis'
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEditable
| Qt.ItemIsDragEnabled | Qt.ItemIsUserCheckable
| Qt.ItemIsEnabled)
item.setText(project_name)
item.previous_name = project_name
item.path = self.normalize_path(project_name)
ext = 0
while item.path in os.listdir(self.projects_dir):
ext += 1
item.path = f"{self.normalize_path(project_name)}{ext}"
icon.addFile(f"bci:primary/{icon_name}.svg", QSize(), QIcon.Normal,
QIcon.Off)
item.setIcon(icon)
item.icon_name = icon_name
source = os.path.join(os.getenv('BCISTREAM_ROOT'),
'default_extensions', default_project)
target = os.path.join(self.projects_dir, item.path)
shutil.copytree(source, target)
pickle.dump({
'name': project_name,
'files': []
}, open(os.path.join(self.projects_dir, item.path, BCIFR_FILE), 'wb'))
self.open_project(item.path)
def populate(self):
"""Actualize the list of word sets"""
self.view.clear()
self.set_names = list()
for data in get_wordsets(self.conn):
set_name = data["name"]
item = QListWidgetItem()
item.setText(set_name)
item.setIcon(FIcon(0xF0A38))
self.view.addItem(item)
self.set_names.append(set_name)
def fill_graph_list(self):
self.graphListWidget.clear()
skeleton = str(self.skeletonListComboBox.currentText())
graph_list = get_graph_list_from_db(self.db_url, skeleton)
if graph_list is None:
return
for graph_id, name in graph_list:
item = QListWidgetItem()
item.setText(name)
item.setData(Qt.UserRole, graph_id)
self.graphListWidget.addItem(item)
def load_projects(clientname):
global window
window.project_listwidget.clear()
for c in clientlist:
if (c.name() == clientname):
plist = c.projects()
for p in plist:
item = QListWidgetItem()
item.setText(p.name())
window.project_listwidget.addItem(item)
window.project_listwidget.itemPressed.connect(
select_project_item)
def __init__(self, parent, packages):
super(SelectPackages_Dialog, self).__init__(parent)
self.file_paths = []
self.required_packages = packages
self.setLayout(QVBoxLayout())
self.layout().addWidget(
QLabel(
'You need to select the locations of the following required node packages'
))
# package lists
required_packages_list_widget = QListWidget()
for p in packages:
package_item = QListWidgetItem()
package_item.setText(p)
required_packages_list_widget.addItem(package_item)
selected_items_widget = QWidget()
selected_items_widget.setLayout(QVBoxLayout())
self.selected_packages_list_widget = QListWidget()
selected_items_widget.layout().addWidget(
self.selected_packages_list_widget)
auto_import_button = QPushButton('auto import')
auto_import_button.setFocus()
auto_import_button.clicked.connect(self.auto_import_button_clicked)
selected_items_widget.layout().addWidget(auto_import_button)
add_package_button = QPushButton('add')
add_package_button.clicked.connect(self.add_package_button_clicked)
selected_items_widget.layout().addWidget(add_package_button)
clear_package_list_button = QPushButton('clear')
clear_package_list_button.clicked.connect(
self.clear_selected_packages_list)
selected_items_widget.layout().addWidget(clear_package_list_button)
finished_button = QPushButton('OK')
finished_button.clicked.connect(self.finished_button_clicked)
selected_items_widget.layout().addWidget(finished_button)
packages_lists_widget = QWidget()
packages_lists_widget.setLayout(QHBoxLayout())
packages_lists_widget.layout().addWidget(required_packages_list_widget)
packages_lists_widget.layout().addWidget(selected_items_widget)
self.layout().addWidget(packages_lists_widget)
self.setWindowTitle('select required packages')
def redraw_candidates_list(self):
self.lstCandidates.clear()
for candidate in self.existingSettings.CANDIDATES:
ticker = candidate.ticker
reason = candidate.reason
o = 3
item_to_add = QListWidgetItem()
item_to_add.setText(ticker)
item_to_add.setToolTip(reason)
self.lstCandidates.addItem(item_to_add)
self.btnRemoveC.setEnabled(False)
self.set_clear_button_state()
def __init__(self, videos_list):
super().__init__()
self.ui = Ui_downloadList()
self.ui.setupUi(self)
for i in range(len(videos_list)):
list_item = QListWidgetItem()
list_item.setText(str(videos_list[i]))
self.ui.listWidget.addItem(list_item)
self.ui.listWidget.setCurrentRow(0)
self.ui.btn_download.clicked.connect(self.download)
self.currentItem = 0
self.download_pressed = False
def update_tables(self, tables):
"""
Update list of tables
"""
new_tables = list()
for t_name, t_mapping in tables.items():
if t_name not in self.table_mappings:
if t_mapping is None:
t_mapping = ObjectClassMapping()
self.table_mappings[t_name] = MappingListModel([t_mapping],
t_name)
new_tables.append(t_name)
for k in list(self.table_mappings.keys()):
if k not in tables:
self.table_mappings.pop(k)
if not tables:
self._ui.source_list.clear()
self._ui.source_list.clearSelection()
return
# current selected table
selected = self._ui.source_list.selectedItems()
# empty tables list and add new tables
tables_to_select = set(self.checked_tables + new_tables)
self._ui.source_list.blockSignals(True)
self._ui.source_list.clear()
self._ui.source_list.clearSelection()
for t in tables:
item = QListWidgetItem()
item.setText(t)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
if t in tables_to_select:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
self._ui.source_list.addItem(item)
self._ui.source_list.blockSignals(False)
# reselect table if existing otherwise select first table
if selected and selected[0].text() in tables:
table = selected[0].text()
self._ui.source_list.setCurrentRow(
tables.index(table), QItemSelectionModel.SelectCurrent)
elif tables:
# select first item
self._ui.source_list.setCurrentRow(
0, QItemSelectionModel.SelectCurrent)
self.tableChecked.emit()
def add_component_controller(
self, component_controller: ComponentController) -> None:
label = component_controller.get_q_svg_component_widget()
controller_item = QListWidgetItem()
controller_item.parent = component_controller
controller_item.setText("Testtest")
pixmap = component_controller.pixmap
controller_item.setIcon(pixmap)
controller_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
controller_item.component_controller = component_controller
self.setItemWidget(controller_item, label)
self.addItem(controller_item)
logger.debug("Component added")
def add_spec(self):
spec = self.specLineEdit.text()
# TODO: Verify validity of spec.
self.spec_data[self.current_source].append(spec)
specItem = QListWidgetItem()
specItem.setText(spec)
self.specListWidget.addItem(specItem)
# Select the newly added item.
self.specListWidget.addItem(specItem)
self.specLineEdit.setText('')
def addLayerListItem(self, layer_name, z_level):
layer_key_name = self.getLayerKeyName(layer_name)
layer_item = QListWidgetItem(layer_name)
layer_item.setFlags(layer_item.flags() | Qt.ItemIsUserCheckable)
if self._tiles._layers[layer_key_name][LayerKeys.VISIBLE]:
layer_item.setCheckState(Qt.Checked)
else:
layer_item.setCheckState(Qt.Unchecked)
self._layers[layer_key_name][LayerKeys.LIST_ITEM] = layer_item
self._tiles._layers[layer_key_name][LayerKeys.Z_LEVEL] = z_level
self._tiles._layers[layer_key_name][LayerKeys.ITEM_GROUP].setZValue(
z_level)
if layer_name == self._layers[self._active_layer][LayerKeys.NAME]:
layer_item.setText(layer_name + " (Selected)")
self._layers_widget.addItem(layer_item)
