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 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 __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_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 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 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 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 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 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 _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 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 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 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 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 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 fill_widgets_with_emails(self):
if not self.template or not self.xlsx_rows_list:
return
for xlsx_row in self.xlsx_rows_list:
sample_row_text = ' '.join([
xlsx_row[col] if col != 'email' else ', '.join(xlsx_row[col])
for col in self.info_cols
])
item = QListWidgetItem(sample_row_text)
item.xlsx_row = xlsx_row # Именно отсюда мы возьмём данные для отправки
item.setCheckState(Qt.Checked)
if xlsx_row[OKOK] == OKOK:
item.setCheckState(Qt.Unchecked)
item.setBackground(QBrush(QColor("lightGreen"))) # Вах!
self.listWidget_emails.addItem(item)
self.listWidget_emails.itemClicked.connect(
self.update_preview_and_attaches_list)
self.listWidget_attachments.itemClicked.connect(self.show_email_attach)
self.update_preview_and_attaches_list(self.listWidget_emails.item(0))
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 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()
import sys
from PySide2.QtWidgets import QApplication, QListWidget, QListWidgetItem
from PySide2.QtCore import Qt
if __name__ == '__main__':
app = QApplication(sys.argv)
lw = QListWidget()
for i in range(5):
text = f'Item {i}'
item = QListWidgetItem(text)
item.setCheckState(Qt.Unchecked)
lw.addItem(item)
lw.setDragDropMode(lw.InternalMove)
lw.show()
sys.exit(app.exec_())
def addItems(self, items, checked=False):
for i in items:
item = QListWidgetItem(i, parent=self)
self.addItem(item)
state = Qt.Checked if checked else Qt.Unchecked
item.setCheckState(state)
class OutputWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, None)
self.layout = QGridLayout()
self.label = QLabel("Files selected:")
self.layout.addWidget(self.label, 0, 0, 1, 4)
self.file_list = QListWidget()
self.select_all = QListWidgetItem("(De)select all")
self.select_all.setFlags(self.select_all.flags()
| Qt.ItemIsUserCheckable)
self.select_all.setCheckState(Qt.Unchecked)
self.file_list.addItem(self.select_all)
self.layout.addWidget(self.file_list, 1, 0, 1, 4)
self.layout.addWidget(QLabel("First line:"), 2, 0)
self.first_line = QLineEdit("", self)
self.first_line.setValidator(QIntValidator(1, 100000))
self.layout.addWidget(self.first_line, 2, 1)
self.layout.addWidget(QLabel("Last line:"), 2, 2)
self.last_line = QLineEdit("", self)
self.last_line.setValidator(QIntValidator(1, 100000))
self.layout.addWidget(self.last_line, 2, 3)
self.convert_button = QPushButton("EXPORT")
self.convert_button.clicked.connect(parent.on_convert)
self.convert_button.setStyleSheet("background-color: green")
self.layout.addWidget(self.convert_button, 3, 0, 1, 4)
self.setLayout(self.layout)
self.list_items = {}
self.file_list.itemChanged.connect(self.on_item_changed)
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 remove_from_list(self, file):
list_item = self.list_items.pop(file, None)
if (not list_item):
return False
self.file_list.takeItem(self.file_list.row(list_item))
if (len(self.list_items) == 0):
self.select_all.setCheckState(Qt.Unchecked)
return True
def output_info(self):
res = {
"files":
self.files_selected(),
"first_line":
(0 if not self.last_line.text() else int(self.first_line.text())),
"last_line":
(0 if not self.last_line.text() else int(self.last_line.text()))
}
return res
def on_item_changed(self, item):
if (item is self.select_all):
for list_item in self.list_items.values():
list_item.setCheckState(self.select_all.checkState())
def files_selected(self):
res = []
for list_item in self.list_items.values():
if (list_item.checkState() == Qt.Checked):
res.append(list_item.text())
return res
def selectTally(self, tally_label=None):
# using active view to populate tally options live
av = self.model.activeView
# reset form layout
for i in reversed(range(self.tallySelectorLayout.count())):
self.tallySelectorLayout.itemAt(i).widget().setParent(None)
# always re-add the tally selector to the layout
self.tallySelectorLayout.addRow(self.tallySelector)
self.tallySelectorLayout.addRow(HorizontalLine())
if tally_label is None or tally_label == "None" or tally_label == "":
av.selectedTally = None
self.score_map = None
self.nuclide_map = None
self.filter_map = None
av.tallyValue = "Mean"
else:
# get the tally
tally = self.model.statepoint.tallies[av.selectedTally]
# populate filters
filter_types = {type(f) for f in tally.filters}
spatial_filters = bool(filter_types.intersection(_SPATIAL_FILTERS))
if not spatial_filters:
self.filter_description = QLabel("(No Spatial Filters)")
self.tallySelectorLayout.addRow(self.filter_description)
self._createFilterTree(spatial_filters)
self.tallySelectorLayout.addRow(self.treeExpander)
self.tallySelectorLayout.addRow(HorizontalLine())
# value selection
self.tallySelectorLayout.addRow(QLabel("Value:"))
self.valueBox = QComboBox(self)
self.values = tuple(_TALLY_VALUES.keys())
for value in self.values:
self.valueBox.addItem(value)
self.tallySelectorLayout.addRow(self.valueBox)
self.valueBox.currentTextChanged[str].connect(
self.main_window.editTallyValue)
self.updateTallyValue()
if not spatial_filters:
self.valueBox.setEnabled(False)
self.valueBox.setToolTip("Only tallies with spatial filters are viewable.")
# scores
self.score_map = {}
self.scoresListWidget.itemClicked.connect(
self.main_window.updateScores)
self.score_map.clear()
self.scoresListWidget.clear()
sorted_scores = sorted(tally.scores)
# always put total first if present
if 'total' in sorted_scores:
idx = sorted_scores.index('total')
sorted_scores.insert(0, sorted_scores.pop(idx))
for score in sorted_scores:
ql = QListWidgetItem()
ql.setText(score.capitalize())
ql.setCheckState(QtCore.Qt.Unchecked)
if not spatial_filters:
ql.setFlags(QtCore.Qt.ItemIsUserCheckable)
else:
ql.setFlags(ql.flags() | QtCore.Qt.ItemIsUserCheckable)
ql.setFlags(ql.flags() & ~QtCore.Qt.ItemIsSelectable)
self.score_map[score] = ql
self.scoresListWidget.addItem(ql)
# select the first score item by default
for item in self.score_map.values():
item.setCheckState(QtCore.Qt.Checked)
break
self.updateScores()
self.scoresGroupBoxLayout = QVBoxLayout()
self.scoresGroupBoxLayout.addWidget(self.scoresListWidget)
self.scoresGroupBox = Expander("Scores:", layout=self.scoresGroupBoxLayout)
self.tallySelectorLayout.addRow(self.scoresGroupBox)
# nuclides
self.nuclide_map = {}
self.nuclidesListWidget.itemClicked.connect(self.main_window.updateNuclides)
self.nuclide_map.clear()
self.nuclidesListWidget.clear()
sorted_nuclides = sorted(tally.nuclides)
# always put total at the top
if 'total' in sorted_nuclides:
idx = sorted_nuclides.index('total')
sorted_nuclides.insert(0, sorted_nuclides.pop(idx))
for nuclide in sorted_nuclides:
ql = QListWidgetItem()
ql.setText(nuclide.capitalize())
ql.setCheckState(QtCore.Qt.Unchecked)
if not spatial_filters:
ql.setFlags(QtCore.Qt.ItemIsUserCheckable)
else:
ql.setFlags(ql.flags() | QtCore.Qt.ItemIsUserCheckable)
ql.setFlags(ql.flags() & ~QtCore.Qt.ItemIsSelectable)
self.nuclide_map[nuclide] = ql
self.nuclidesListWidget.addItem(ql)
# select the first nuclide item by default
for item in self.nuclide_map.values():
item.setCheckState(QtCore.Qt.Checked)
break
self.updateNuclides()
self.nuclidesGroupBoxLayout = QVBoxLayout()
self.nuclidesGroupBoxLayout.addWidget(self.nuclidesListWidget)
self.nuclidesGroupBox = Expander("Nuclides:", layout=self.nuclidesGroupBoxLayout)
self.tallySelectorLayout.addRow(self.nuclidesGroupBox)
def __init__(self, parent, tiles):
self._parent = parent
self._layer_tabs = LayerTabBar(parent, self)
self._layer_tabs.setMovable(True)
self._layer_tabs.setContentsMargins(0, 0, 0, 0)
self._add_layer_button = QPushButton("+")
self._add_layer_button.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.Expanding)
self._add_layer_button.setFixedWidth(35)
self._add_layer_button.clicked.connect(self.addNewLayerTab)
self._layer_tabs_row = QWidget(parent)
self._layer_tabs_layout = QHBoxLayout(self._layer_tabs_row)
self._layer_tabs_layout.setSpacing(0)
self._layer_tabs_layout.setContentsMargins(0, 0, 0, 0)
self._layer_tabs_layout.addWidget(self._layer_tabs)
self._layer_tabs_layout.addWidget(self._add_layer_button)
self.DEFAULT_TAB_COLOR = "#EFEFEF"
self._tiles = tiles
self._layers_widget = LayerList(self)
layer_1 = QListWidgetItem("Layer 1")
layer_1.setFlags(layer_1.flags() | Qt.ItemIsUserCheckable)
layer_1.setCheckState(Qt.Checked)
layer_1.setText("Layer 1 (Selected)")
self._layers_widget.addItem(layer_1)
# Stores the Layer properties
self._layers = {
"Layer 1": {
LayerKeys.NAME: "Layer 1",
LayerKeys.LIST_ITEM: layer_1,
LayerKeys.REMOVABLE: False,
LayerKeys.TAB_COLOR: self.DEFAULT_TAB_COLOR
}
}
self._layer_tabs.setStyleSheet('''
QTabBar::tab {{}}
QTabBar::tab:selected {{background-color: {color}; border: 1px solid #777777; border-radius: 4px;}}
'''.format(color=self._layers["Layer 1"][LayerKeys.TAB_COLOR]))
self._tab_change = False
self._list_change = False
self._plus_button = QPushButton("+", parent)
self._plus_button.setFixedSize(20, 20)
first_layer = "Layer 1"
self._active_layer = first_layer
self._layer_tab_names = {}
self._layer_tab_indexes = {}
tab_index = self._layer_tabs.addTab(first_layer)
self._add_tab_index = 2
self.lockTabs()
# SIGNAL METHODS
self._layers_widget.setSelectionMode(QAbstractItemView.NoSelection)
self._layers_widget.itemDoubleClicked.connect(
self.doubleClickLayerItem)
self._layers_widget.itemChanged.connect(self.layerVisibility)
self._plus_button.clicked.connect(self.addNewLayerTab)
self._layer_tabs.currentChanged.connect(self.changeTabLayer)
self._layer_tabs.tabMoved.connect(self.layerTabMoved)
self.tabColors = {
0: 'green',
1: 'red',
2: 'yellow',
3: 'orange',
4: 'blue',
}
