def generate_item(self, track_list):
"""
Generate an QListWidgetItem, enable checkboxes and append it to a QListWidget
:param track_list:
:param list_widget:
:return:
"""
self._single_track_list.extend(track_list)
for track in track_list:
track_name = "N/A"
track_type = track._track_type
if track.track_name is not None:
track_name = track.track_name
track_item = QListWidgetItem("Track Name: " + track_name + " | " +
"Type: " + track_type)
track_item.setFlags(
track_item.flags()
| PySide2.QtCore.Qt.ItemFlag.ItemIsUserCheckable)
track_item.setFlags(track_item.flags()
| PySide2.QtCore.Qt.ItemFlag.ItemIsEnabled)
track_item.setCheckState(PySide2.QtCore.Qt.CheckState.Unchecked)
self.events.single_track_item_generated(track_item)
def add_todo_btn_clicked(self):
item = QListWidgetItem(f"Todo {self.todo_list_widget.count() + 1}")
item.setFlags(item.flags() | Qt.ItemIsUserCheckable
| Qt.ItemIsEditable)
item.setCheckState(Qt.Unchecked)
self.todo_list_widget.addItem(item)
self.todo_list_widget.edit(self.todo_list_widget.indexFromItem(item))
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 _create_c_list_item_widget(self, colleague):
widget = QWidget(parent=self._colleagues_list)
widget.colleague = colleague
main_layout = QHBoxLayout(widget)
main_layout.setSpacing(2)
icon_label = QLabel(widget)
icon_label.setPixmap(
QIcon(":images/account.svg").pixmap(
QSize(self.COLLEAGUES_LIST_WIDGET_HEIGHT - 17,
self.COLLEAGUES_LIST_WIDGET_HEIGHT - 17)))
main_layout.addWidget(icon_label)
vertical_layout = QVBoxLayout()
main_layout.addLayout(vertical_layout)
text_label = QLabel(widget)
widget.text_label = text_label
text_label.setFont(QFont('Noto Sans', 10 * self._dp))
text_label.setAlignment(Qt.AlignTop | Qt.AlignLeft)
text_label.setText(colleague.get_mail_text())
vertical_layout.addWidget(text_label)
status_label = QLabel(widget)
widget.status_label = status_label
status_label.setFont(QFont('Noto Sans', 10 * self._dp))
status_label.setAlignment(Qt.AlignTop | Qt.AlignLeft)
status_label.setText(colleague.get_status_text())
vertical_layout.addWidget(status_label)
main_layout.addStretch()
access_label = QLabel(widget)
widget.access_label = access_label
access_label.setFont(QFont('Noto Sans', 10 * self._dp))
access_label.setAlignment(Qt.AlignCenter | Qt.AlignLeft)
access_label.setText(colleague.get_access_text())
main_layout.addWidget(access_label)
def clicked(event, control):
self._show_menu(widget.colleague, control.mapToGlobal(event.pos()))
widget.mouseReleaseEvent = lambda e: clicked(e, widget)
widget.text_label.mouseReleaseEvent = lambda e: clicked(
e, widget.text_label)
widget.status_label.mouseReleaseEvent = lambda e: clicked(
e, widget.status_label)
widget.access_label.mouseReleaseEvent = lambda e: clicked(
e, widget.access_label)
item = QListWidgetItem()
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
item.setSizeHint(
QSize(self._colleagues_list.width(),
self.COLLEAGUES_LIST_WIDGET_HEIGHT))
self._colleagues_list.addItem(item)
self._items.append(widget)
self._colleagues_list.setItemWidget(item, widget)
def addSpot(self, spot):
self.spots.append(spot)
item = QListWidgetItem("Spot " + str(self.count))
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked)
self.addItem(item)
self.count += 1
def add_to_list(self, file):
if (self.list_items.get(file)):
return False
list_item = QListWidgetItem(file)
list_item.setFlags(list_item.flags() | Qt.ItemIsUserCheckable)
list_item.setCheckState(Qt.Checked)
self.file_list.addItem(list_item)
self.list_items[file] = list_item
return True
def AddItem(self, name):
item = QListWidgetItem(name)
item.setTextAlignment(Qt.AlignCenter)
# item.setBackground(QColor(87, 195, 194))
item.setBackground(QColor(0, 0, 0, 0))
item.setSizeHint(QSize(90, 30))
item.setFlags(item.flags() & (~Qt.ItemIsSelectable))
self.addItem(item)
def add_item(self, text):
"""add editable text item
need to use item widget to make it editable
:param text str: content of the item
"""
item = QListWidgetItem(text)
item.setFlags(item.flags() | Qt.ItemIsEditable | Qt.ItemIsSelectable)
self.addItem(item)
def go_select(self):
self.ui.list_select.clear()
for name, path in futil.get_name_path_from_dataset():
item = QListWidgetItem(f"{name}")
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
item.setData(Qt.UserRole, path)
self.ui.list_select.addItem(item)
self.ui.front.setCurrentIndex(2)
def fill_list(self, list_items):
self.list_widget.clear()
for column in list_items:
item = QListWidgetItem(column)
item.setFlags(item.flags() | QtCore.Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
self.list_widget.addItem(item)
self.show()
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 go_tanswermenu(self):
self._weight = None
self.ui.list_tanswermenu_stages.clear()
for i, stg in enumerate(self._tds.stage_list):
item = QListWidgetItem(f"{stg}")
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Checked)
item.setData(Qt.UserRole, i)
self.ui.list_tanswermenu_stages.addItem(item)
self.ui.front.setCurrentIndex(6)
def create_current_item(self, flags):
if self.active_stack.index() == 0:
txt = _(' 0: Geladener Zustand des Dokuments')
else:
txt = _(' 0: Aktueller Zustand des Dokuments')
current_item = QListWidgetItem(txt)
current_item.setForeground(self.fg_black)
current_item.setBackground(self.bg_grey)
current_item.setFlags(flags)
current_item.setIcon(IconRsc.get_icon('options'))
return current_item
def _updateGroupList(self):
newGroup = self.gSelector.currentItem().text()
sStruct = self.chartData[newGroup].getColStructure()
self.sSelector.clear()
for ws in sStruct:
firstChannel = sStruct[ws][0]
isOneSignal = self.chartData[newGroup][firstChannel][ws][0]
if isOneSignal:
item = QListWidgetItem(ws, self.sSelector)
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Unchecked)
def update_watcherlist(self):
self.watcherlist.clear()
for n in range(0, len(self.workspace.cartprograph.watchers)):
label = (", ".join(
[str(r) for r in self.workspace.cartprograph.watchers[n][1]]) +
" @ " + hex(self.workspace.cartprograph.watchers[n][0]))
item = QListWidgetItem(label)
item.setFlags(item.flags() | QtCore.Qt.ItemIsUserCheckable)
if self.workspace.cartprograph.watchers[n][2]:
item.setCheckState(QtCore.Qt.Checked)
else:
item.setCheckState(QtCore.Qt.Unchecked)
self.watcherlist.addItem(item)
def notify(self, updateType):
self.itemSelectionChanged.disconnect(self.selectionSlot)
if updateType == UpdateType.MATERIAL_SELECTION:
self.clearSelection()
else:
self.itemChanged.disconnect(self.itemEditSlot)
self.clear()
for o in self.scene.getObjectIterator():
item = QListWidgetItem(o.name, self)
item.setFlags(item.flags() | Qt.ItemIsEditable)
item.setData(QtCore.Qt.UserRole, o)
self.itemChanged.connect(self.itemEditSlot)
self.itemSelectionChanged.connect(self.selectionSlot)
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 create_history_item(self, c: int, txt: str, icon, redo_idx):
num = c - redo_idx
if num >= 0:
num += 1
item = QListWidgetItem(f'{txt} [{num: 3d}]', self.viewList)
item.setData(Qt.UserRole, c)
item.setFlags(self.enabled_flags)
item.setIcon(icon)
if num > 0:
item.setForeground(self.fg_grey)
item.setFont(FontRsc.italic)
return item
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)
def generate_track_item(self, ref_num: int):
"""
Generate the track list for the two input directories with the first file in the list
:return:
"""
if len(self._source_1_list) != 0 and ref_num == 1:
self._tracks_1 = PymkvWrapper.process_file(self._source_1_list[0])
#TODO turn item generate into GUI helper
for track in self._tracks_1:
track_name = "N/A"
track_type = track._track_type
if track.track_name is not None:
track_name = track.track_name
track_item_1 = QListWidgetItem("Track Name: " + track_name +
" | " + "Type: " + track_type)
track_item_1.setFlags(
track_item_1.flags()
| PySide2.QtCore.Qt.ItemFlag.ItemIsUserCheckable)
track_item_1.setFlags(
track_item_1.flags()
| PySide2.QtCore.Qt.ItemFlag.ItemIsEnabled)
track_item_1.setCheckState(
PySide2.QtCore.Qt.CheckState.Unchecked)
self.events.ref_tracks_generated(self._source_1_list[0],
track_item_1, 1)
if len(self._source_2_list) != 0 and ref_num == 2:
self._tracks_2 = PymkvWrapper.process_file(self._source_2_list[0])
# TODO turn item generate into GUI helper
for track in self._tracks_2:
track_name = "N/A"
track_type = track._track_type
if track.track_name is not None:
track_name = track.track_name
track_item_2 = QListWidgetItem("Track Name: " + track_name +
" | " + "Type: " + track_type)
track_item_2.setFlags(
track_item_2.flags()
| PySide2.QtCore.Qt.ItemFlag.ItemIsUserCheckable)
track_item_2.setFlags(
track_item_2.flags()
| PySide2.QtCore.Qt.ItemFlag.ItemIsEnabled)
track_item_2.setCheckState(
PySide2.QtCore.Qt.CheckState.Unchecked)
self.events.ref_tracks_generated(self._source_2_list[0],
track_item_2, 2)
def set_item(self, item, status):
# Пока просто выставляет пустой элемент, переписать под заполнение
# из класса InputDBClass
# Каким образом - смотреть, что выбрано в категориях и делать срез
# с пандаса и вставлять его поэлементно
# Подумать на тему того, чтобы изначально был пункт "Все",
# и как это красиво можно связать со структурами
# (в плане редактирования, чтобы не удалить случайно)
checkbox_item = QListWidgetItem(item)
checkbox_item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
if status:
checkbox_item.setCheckState(Qt.Checked)
else:
checkbox_item.setCheckState(Qt.Unchecked)
self.listWidget.addItem(checkbox_item)
def create_item(self, name, icon, parent):
"""Create a standard list widget item, for option panel.
Args:
name: Name of option button
icon: Icon name of option button
parent: The QListWidget
Returns:
item: created option button
"""
item = QListWidgetItem(parent)
item.setText(name)
item.setIcon(QIcon(icon))
item.setStatusTip(name)
item.setTextAlignment(Qt.AlignLeft)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
def _add_file_to_file_list(self,
index,
file_list,
items_dict,
obj_id,
rel_path,
created_time,
was_updated,
is_deleted,
transfered,
size=0,
state=None,
is_file=True):
item = file_list.item(index)
if item:
item.setData(Qt.UserRole, [
rel_path, created_time, size, was_updated, is_deleted,
transfered, state, is_file, obj_id
])
self._update_file_list_item_widget(file_list, item)
items_dict[obj_id].append(item)
return
item = QListWidgetItem()
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
item.setSizeHint(QSize(file_list.width(), self.FILE_LIST_ITEM_SIZE))
item.setData(Qt.UserRole, [
rel_path, created_time, size, was_updated, is_deleted, transfered,
state, is_file, obj_id
])
file_list.addItem(item)
rect = file_list.viewport().contentsRect()
top = file_list.indexAt(rect.topLeft())
if top.isValid():
bottom = file_list.indexAt(rect.bottomLeft())
if not bottom.isValid():
bottom = file_list.model().index(file_list.count() - 1)
if top.row() <= file_list.row(item) <= bottom.row() + 1:
widget = self._create_file_list_item_widget(
file_list, [
rel_path, created_time, size, was_updated, is_deleted,
transfered, state, is_file, obj_id
])
file_list.setItemWidget(item, widget)
if item not in items_dict[obj_id]:
items_dict[obj_id].append(item)
def create_item(self, name, icon):
"""Create a standard list widget item, for option panel.
Args:
name: Name of option button
icon: Icon name of option button
Returns:
item: created option button
"""
item = QListWidgetItem(self)
item.setText(name)
item.setIcon(QIcon(icon))
item.setStatusTip(name)
item.setSizeHint(QSize(75, 70))
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
return item
def _add_file_to_file_list(self, index, rel_path,
created_time, was_updated, icon_info):
item = self._ui.file_list.item(index)
if not item:
item = QListWidgetItem()
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
item.setSizeHint(QSize(
self.FILE_LIST_ITEM_SIZE, self.FILE_LIST_ITEM_SIZE))
self._ui.file_list.insertItem(index, item)
widget = self._ui.file_list.itemWidget(item)
if not widget:
widget = self._create_file_list_item_widget(
rel_path, created_time, was_updated, icon_info)
self._ui.file_list.setItemWidget(item, widget)
else:
self._update_file_list_item_widget(
widget, rel_path, created_time, was_updated, icon_info)
self._files[FilePath(rel_path)] = icon_info
def use_settings(self, settings):
try:
self.table_mappings = {
table: MappingListModel([dict_to_map(m) for m in mappings],
table)
for table, mappings in settings.get("table_mappings",
{}).items()
}
except ValueError as error:
self._ui_error.showMessage(f"{error}")
return
table_types = {
tn: {
int(col): value_to_convert_spec(spec)
for col, spec in cols.items()
}
for tn, cols in settings.get("table_types", {}).items()
}
table_row_types = {
tn: {
int(col): value_to_convert_spec(spec)
for col, spec in cols.items()
}
for tn, cols in settings.get("table_row_types", {}).items()
}
self.connector.set_table_options(settings.get("table_options", {}))
self.connector.set_table_types(table_types)
self.connector.set_table_row_types(table_row_types)
self._ui.source_list.blockSignals(True)
self._ui.source_list.clear()
selected_tables = settings.get("selected_tables")
if selected_tables is None:
selected_tables = set(self.table_mappings.keys())
for table_name in self.table_mappings:
item = QListWidgetItem()
item.setText(table_name)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked if table_name in
selected_tables else Qt.Unchecked)
self._ui.source_list.addItem(item)
self._ui.source_list.blockSignals(False)
def add_crew_member(self):
w = QDialog()
w.setWindowTitle("Add New Crew Member")
w.setLayout(QFormLayout())
crew_name = QLineEdit("New Crew Member")
w.layout().addRow(QLabel("Crew Member Name:"), crew_name)
specialization = QComboBox()
specialization.addItems([
"Directing", "Cinematography", "Producing", "Production Design",
"Editing", "Visual Effects"
])
w.layout().addRow(QLabel("Specialization:"), specialization)
accept = QPushButton("Create")
accept.clicked.connect(w.accept)
reject = QPushButton("Cancel")
reject.clicked.connect(w.reject)
w.layout().addRow(accept, reject)
if w.exec_() == QDialog.Accepted:
new_crew_item = QListWidgetItem(crew_name.text())
new_crew_item.setFlags(new_crew_item.flags() | Qt.ItemIsEditable)
self.crew_list_widget.addItem(new_crew_item)
def addNewLayerTab(self):
if not self._list_change:
self._add_tab_index = self.getNewTabIndex()
layer_name = " ".join(["Layer", str(self._add_tab_index)])
layer_item = QListWidgetItem(layer_name)
layer_item.setFlags(layer_item.flags() | Qt.ItemIsUserCheckable)
layer_item.setCheckState(Qt.Checked)
self._layers_widget.addItem(layer_item)
self._layers[layer_name] = {
LayerKeys.NAME: layer_name,
LayerKeys.LIST_ITEM: layer_item,
LayerKeys.REMOVABLE: True,
LayerKeys.TAB_COLOR: self.DEFAULT_TAB_COLOR
}
# ADD LAYER TO TILES
self._tiles.createNewLayer(layer_name)
# ADD LAYER TAB INDEX TO TAB NAME KEYS
tab_index = self._layer_tabs.addTab(layer_name)
self.lockTabs()
def add_position(self):
w = QDialog()
w.setWindowTitle("Create New Position")
w.setLayout(QFormLayout())
pos_name = QLineEdit("New Position")
w.layout().addRow(QLabel("Position Name:"), pos_name)
pre_pro_days = QSpinBox()
post_pro_days = QSpinBox()
w.layout().addRow(QLabel("Days of pre-production:"), pre_pro_days)
w.layout().addRow(QLabel("Days of immediate post-production:"),
post_pro_days)
accept = QPushButton("Create")
accept.clicked.connect(w.accept)
reject = QPushButton("Cancel")
reject.clicked.connect(w.reject)
w.layout().addRow(accept, reject)
if w.exec_() == QDialog.Accepted:
print("Days of pre-production", pre_pro_days.value(),
"Days of post-productions", post_pro_days.value())
new_pos_item = QListWidgetItem(pos_name.text())
new_pos_item.setFlags(new_pos_item.flags() | Qt.ItemIsEditable)
self.pos_list_widget.addItem(new_pos_item)
