class TableWidget(QTableWidget):
def __init__(self, parent: Optional[QWidget] = None) -> None:
super().__init__(parent)
self._context_menu = QMenu(self)
self._copy_table_action = self._context_menu.addAction('Copy table to clipboard',
self._copyTableActionTriggered)
self._copy_row_action = self._context_menu.addAction('Copy row to clipboard',
self._copyRowActionTriggered)
self.addActions((self._copy_table_action, self._copy_row_action))
def contextMenuEvent(self, event: QEvent) -> None:
self._copy_table_action.setEnabled(bool(self.rowCount()))
self._copy_row_action.setEnabled(bool(self.selectedItems()))
self._context_menu.exec_(self.viewport().mapToGlobal(event.pos()))
def _copyRowsToClipboard(self, rows: Iterable[int]) -> None:
if not rows or not self.columnCount():
return
rows_text = ['\t'.join(self.model().headerData(column, Qt.Horizontal) for column in range(self.columnCount()))]
for row in rows:
rows_text.append('\t'.join(self.item(row, column).text() for column in range(self.columnCount())))
QApplication.clipboard().setText('\n'.join(rows_text))
def _copyTableActionTriggered(self) -> None:
self._copyRowsToClipboard(tuple(range(self.rowCount())))
def _copyRowActionTriggered(self) -> None:
selected_rows = sorted({self.row(selected_item) for selected_item in self.selectedItems()})
self._copyRowsToClipboard(selected_rows)
def _setup_difficulties_menu(self, game: RandovaniaGame,
menu: QtWidgets.QMenu):
from randovania.game_description import default_database
game = default_database.game_description_for(game)
tricks_in_use = used_tricks(game)
menu.clear()
for trick in sorted(game.resource_database.trick,
key=lambda _trick: _trick.long_name):
if trick not in tricks_in_use:
continue
trick_menu = QtWidgets.QMenu(self)
trick_menu.setTitle(_t(trick.long_name))
menu.addAction(trick_menu.menuAction())
used_difficulties = difficulties_for_trick(game, trick)
for trick_level in enum_lib.iterate_enum(LayoutTrickLevel):
if trick_level in used_difficulties:
difficulty_action = QtGui.QAction(self)
difficulty_action.setText(trick_level.long_name)
trick_menu.addAction(difficulty_action)
difficulty_action.triggered.connect(
functools.partial(self._open_trick_details_popup, game,
trick, trick_level))
def createTrayIcon(self):
self.showProgramsAction = QAction("Programs", self)
self.showProgramsAction.triggered.connect(self.showProgramsPage)
self.showNewProgramAction = QAction("New Program", self)
self.showNewProgramAction.triggered.connect(self.newProgram)
self.showSetProgramAction = QAction("Logs", self)
self.showSetProgramAction.triggered.connect(self.showLogsPage)
self.showDocumentationAction = QAction("Documentation", self)
self.showDocumentationAction.triggered.connect(self.showDocumentation)
self.quitAction = QAction("Quit", self)
self.quitAction.triggered.connect(self.quit)
self.trayIconMenu = QMenu(self)
self.trayIconMenu.addAction(self.showProgramsAction)
self.trayIconMenu.addAction(self.showSetProgramAction)
self.trayIconMenu.addAction(self.showNewProgramAction)
self.trayIconMenu.addAction(self.showDocumentationAction)
self.trayIconMenu.addSeparator()
self.trayIconMenu.addAction(self.quitAction)
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setContextMenu(self.trayIconMenu)
self.trayIcon.activated.connect(self.iconActivated)
self.trayIcon.setIcon(QIcon(":/images/yammi-banana-icon.png"))
self.trayIcon.show()
def outputContextMenu(self, listview: QListView, pos: QPoint):
current_model = listview.model()
menu = QMenu()
edit_action = QAction(
"Edit clicked" if len(listview.selectedIndexes()) > 1 else "Edit",
menu)
edit_action.triggered.connect(self.editCurrentTarget)
menu.addAction(edit_action)
delete_action = QAction("Remove", menu)
delete_action.triggered.connect(lambda: current_model.__delitem__(
[i.row() for i in listview.selectedIndexes()]))
menu.addAction(delete_action)
selected_istemp = current_model[
listview.currentIndex().row()].temporary
mark_temp_action = QAction("Mark temp", menu)
mark_temp_action.setCheckable(True)
mark_temp_action.setChecked(selected_istemp)
mark_temp_action.triggered.connect(lambda: [
current_model[i.row()].switch_temporary(not selected_istemp)
for i in listview.selectedIndexes()
])
menu.addAction(mark_temp_action)
self.addTargetActions(menu)
menu.exec_(listview.mapToGlobal(pos))
def __init__(self, selection_handler, *args, **kwargs):
"""selection_handler: a function in the parent window to pass selected indices to"""
self.selection_handler = selection_handler
super().__init__(*args, **kwargs)
size_policy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
size_policy.setHorizontalStretch(1)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(size_policy)
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.setObjectName("treeView")
self.setIndentation(10)
self.setIconSize(QSize(16, 24))
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.tree_menu = QMenu()
self.context_action_expand = QAction('Expand all', self.tree_menu)
self.tree_menu.addAction(self.context_action_expand)
self.context_action_scan = QAction('Scan wiki for selected objects',
self.tree_menu)
self.tree_menu.addAction(self.context_action_scan)
self.context_action_upload_page = QAction(
'Upload templates for selected objects', self.tree_menu)
self.tree_menu.addAction(self.context_action_upload_page)
self.context_action_upload_tile = QAction(
'Upload tiles for selected objects', self.tree_menu)
self.tree_menu.addAction(self.context_action_upload_tile)
self.context_action_upload_extra = QAction(
'Upload extra image(s) for selected objects', self.tree_menu)
self.tree_menu.addAction(self.context_action_upload_extra)
self.context_action_diff = QAction('Diff template against wiki',
self.tree_menu)
self.tree_menu.addAction(self.context_action_diff)
self.customContextMenuRequested.connect(self.on_context_menu)
def create_upload_nintendont_action(self, menu: QtWidgets.QMenu):
self.upload_nintendont_action = QtGui.QAction(menu)
self.upload_nintendont_action.setText(
"Upload Nintendont to Homebrew Channel")
self.upload_nintendont_action.triggered.connect(
self.on_upload_nintendont_action)
menu.addAction(self.upload_nintendont_action)
def __init__(self, parent: Optional[QWidget] = None) -> None:
super().__init__(parent)
self._context_menu = QMenu(self)
self._copy_table_action = self._context_menu.addAction('Copy table to clipboard',
self._copyTableActionTriggered)
self._copy_row_action = self._context_menu.addAction('Copy row to clipboard',
self._copyRowActionTriggered)
self.addActions((self._copy_table_action, self._copy_row_action))
def inputContextMenu(self, pos: QPoint):
menu = QMenu()
preview_action = QAction("Preview", menu)
preview_action.triggered.connect(
lambda: self.previewInput(self.list_input_files.currentItem()))
menu.addAction(preview_action)
self.addTargetActions(menu)
action = menu.exec_(self.list_input_files.mapToGlobal(pos))
def __init__(self, parent=None):
MdiWidget.__init__(self, parent)
self.setupUi(self)
self.current_index = None # this is used in onOperationContextMenu() to track item for menu
# Set icons
self.NewOperationBtn.setIcon(load_icon("new.png"))
self.CopyOperationBtn.setIcon(load_icon("copy.png"))
self.DeleteOperationBtn.setIcon(load_icon("delete.png"))
# Operations view context menu
self.contextMenu = QMenu(self.OperationsTableView)
self.actionReconcile = QAction(load_icon("reconcile.png"),
self.tr("Reconcile"), self)
self.actionCopy = QAction(load_icon("copy.png"), self.tr("Copy"), self)
self.actionDelete = QAction(load_icon("delete.png"), self.tr("Delete"),
self)
self.contextMenu.addAction(self.actionReconcile)
self.contextMenu.addSeparator()
self.contextMenu.addAction(self.actionCopy)
self.contextMenu.addAction(self.actionDelete)
# Customize UI configuration
self.balances_model = BalancesModel(self.BalancesTableView)
self.BalancesTableView.setModel(self.balances_model)
self.balances_model.configureView()
self.operations_model = OperationsModel(self.OperationsTableView)
self.OperationsTableView.setModel(self.operations_model)
self.operations_model.configureView()
self.OperationsTableView.setContextMenuPolicy(Qt.CustomContextMenu)
self.connect_signals_and_slots()
self.NewOperationMenu = QMenu()
for i in range(self.OperationsTabs.count()):
if hasattr(self.OperationsTabs.widget(i), "isCustom"):
self.OperationsTabs.widget(i).dbUpdated.connect(self.dbUpdated)
self.OperationsTabs.widget(i).dbUpdated.connect(
self.operations_model.refresh)
self.NewOperationMenu.addAction(
self.OperationsTabs.widget(i).name,
partial(self.createOperation, i))
self.NewOperationBtn.setMenu(self.NewOperationMenu)
# Setup balance and holdings parameters
current_time = QDateTime.currentDateTime()
current_time.setTimeSpec(
Qt.UTC) # We use UTC everywhere so need to force TZ info
self.BalanceDate.setDateTime(current_time)
self.BalancesCurrencyCombo.setIndex(
JalSettings().getValue('BaseCurrency'))
self.OperationsTabs.setCurrentIndex(LedgerTransaction.NA)
self.OperationsTableView.selectRow(0)
self.DateRange.setCurrentIndex(0)
def createContextMenu(self):
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.showContextMenu)
self.contextMenu = QMenu(self)
self.actionSWitch = self.contextMenu.addAction(u'Switch')
self.actionRefresh = self.contextMenu.addAction(u'Refresh')
self.actionSWitch.triggered.connect(self.switchSide)
self.actionRefresh.triggered.connect(self.reNewMenu)
def createTrayIcon(self):
self.trayIconMenu = QMenu(self)
self.trayIconMenu.addAction(self.minimizeAction)
self.trayIconMenu.addAction(self.maximizeAction)
self.trayIconMenu.addAction(self.restoreAction)
self.trayIconMenu.addSeparator()
self.trayIconMenu.addAction(self.quitAction)
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setContextMenu(self.trayIconMenu)
def __init__(self, parent):
QPushButton.__init__(self, parent)
self.p_account_id = 0
self.Menu = QMenu(self)
self.Menu.addAction(self.tr("Choose account"), self.ChooseAccount)
self.Menu.addAction(self.tr("Any account"), self.ClearAccount)
self.setMenu(self.Menu)
self.dialog = AccountListDialog()
self.setText(self.dialog.SelectedName)
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.iconGroupBox = QGroupBox()
self.iconLabel = QLabel()
self.iconComboBox = QComboBox()
self.showIconCheckBox = QCheckBox()
self.messageGroupBox = QGroupBox()
self.typeLabel = QLabel()
self.durationLabel = QLabel()
self.durationWarningLabel = QLabel()
self.titleLabel = QLabel()
self.bodyLabel = QLabel()
self.typeComboBox = QComboBox()
self.durationSpinBox = QSpinBox()
self.titleEdit = QLineEdit()
self.bodyEdit = QTextEdit()
self.showMessageButton = QPushButton()
self.minimizeAction = QAction()
self.maximizeAction = QAction()
self.restoreAction = QAction()
self.quitAction = QAction()
self.trayIcon = QSystemTrayIcon()
self.trayIconMenu = QMenu()
self.createIconGroupBox()
self.createMessageGroupBox()
self.iconLabel.setMinimumWidth(self.durationLabel.sizeHint().width())
self.createActions()
self.createTrayIcon()
self.showMessageButton.clicked.connect(self.showMessage)
self.showIconCheckBox.toggled.connect(self.trayIcon.setVisible)
self.iconComboBox.currentIndexChanged.connect(self.setIcon)
self.trayIcon.messageClicked.connect(self.messageClicked)
self.trayIcon.activated.connect(self.iconActivated)
self.mainLayout = QVBoxLayout()
self.mainLayout.addWidget(self.iconGroupBox)
self.mainLayout.addWidget(self.messageGroupBox)
self.setLayout(self.mainLayout)
self.iconComboBox.setCurrentIndex(1)
self.trayIcon.show()
self.setWindowTitle("Systray")
self.resize(400, 300)
def context_menu_event(self, event):
context_menu = QMenu()
open_in_new_tab_action = context_menu.addAction("Open in New Tab")
remove_action = context_menu.addAction("Remove...")
current_item = self._current_item()
open_in_new_tab_action.setEnabled(current_item is not None)
remove_action.setEnabled(current_item is not None)
chosen_action = context_menu.exec_(event.globalPos())
if chosen_action == open_in_new_tab_action:
self.open_bookmarkInNewTab.emit(current_item.data(_url_role))
elif chosen_action == remove_action:
self._remove_item(current_item)
def __init__(self, parent=None):
QSystemTrayIcon.__init__(self, QIcon(resource_path("icons/logo.png")), parent)
self.setVisible(True)
self.setToolTip("SSD: Zextras Drive Desktop")
menu = QMenu()
self.show_option = QAction("Mostra")
self.exit_option = QAction("Esci")
menu.addAction(self.show_option)
menu.addAction(self.exit_option)
self.setContextMenu(menu)
def show_tray(self):
if QSystemTrayIcon.isSystemTrayAvailable:
# create tray menu
traymenu = QMenu('AyoShalat', self)
openwin_menu = traymenu.addAction('Show me!')
openwin_menu.triggered.connect(self.show)
playazan_menu = traymenu.addAction('Play Azan')
playazan_menu.triggered.connect(self.playAzan)
stop_azan_menu = traymenu.addAction('Stop Azan')
stop_azan_menu.triggered.connect(self.stopAzan)
traymenu.addSeparator()
exit_menu = traymenu.addAction('Exit')
exit_menu.triggered.connect(self.exit)
# create tray icon
qtray = QSystemTrayIcon(self)
qtray.setIcon(QIcon(self.icopath))
qtray.setVisible(True)
qtray.setContextMenu(traymenu)
qtray.show()
def create_menu_bar(self):
menu_bar = self.menuBar()
file_menu = QMenu('File', self)
settings_action = QAction('Settings', self)
settings_action.triggered.connect(self.open_settings)
exit_action = QAction('Exit', self)
exit_action.triggered.connect(self.close_event)
file_menu.addAction(settings_action)
file_menu.addAction(exit_action)
help_menu = QMenu('Help', self)
about_action = QAction('About', self)
help_menu.addAction(about_action)
menu_bar.addMenu(file_menu)
menu_bar.addMenu(help_menu)
def addTargetActions(self, menu: QMenu):
selected_items = [
i.text() for i in self.list_input_files.selectedItems()
]
selected_items += [
self.currentOutputList[i.row()]
for i in self.currentOutputListView.selectedIndexes()
]
menu.addSeparator()
# cannot use default arg to force coping the type here, since the signal also provides other inputs
func_create = lambda _t, items: lambda: self.currentOutputList.appendTarget(
_t(items))
for t in target_types:
if t.validate(selected_items):
create_action = QAction(t.description, menu)
create_action.triggered.connect(func_create(t, selected_items))
menu.addAction(create_action)
menu.addSeparator()
func_create_batch = lambda _t, items: lambda: self.currentOutputList.extendTargets(
[_t(i) for i in items])
for t in target_types:
if all(t.validate([item]) for item in selected_items):
create_action = QAction("Batch " + t.description, menu)
create_action.triggered.connect(
func_create_batch(t, selected_items))
menu.addAction(create_action)
def showContextMenu(self, pos):
if not self.ui.ganttView.leftView().indexAt(pos).isValid():
self.ui.ganttView.selectionModel().clearSelection()
menu = QMenu(self.ui.ganttView.leftView())
menu.addAction(self.newEntryAction)
menu.addAction(self.removeEntryAction)
menu.exec_(self.ui.ganttView.leftView().viewport().mapToGlobal(pos))
def contextMenuEvent(self, e):
context = QMenu(self)
crap = QAction("thisone", self)
crap.triggered.connect(self.fuckthisshit)
context.addAction(crap)
context.addAction(QAction("test 2", self))
context.addAction(QAction("test 3", self))
context.exec_(e.globalPos())
class TrayIcon(QSystemTrayIcon):
def __init__(self, parent=None):
super().__init__(parent)
self.caps_ico = resource_path(os.path.join('ico', 'caps.ico'))
self.small_ico = resource_path(os.path.join('ico', 'small.ico'))
self.setIcon(QIcon(self.small_ico))
self.showMenu()
self.activated.connect(self.iconClied)
self.check_caps_status()
def showMenu(self):
self.menu = QMenu()
self.quitAction = QAction("退出", self, triggered=self.quit)
self.menu.addAction(self.quitAction)
self.setContextMenu(self.menu)
def check_caps_status(self):
self.check_thread = check_caps_status_work()
def set_icon(status):
if status == 'caps':
self.setIcon(QIcon(self.caps_ico))
self.setToolTip('大写')
else:
self.setIcon(QIcon(self.small_ico))
self.setToolTip('小写')
self.check_thread.signal.connect(set_icon)
self.check_thread.start()
def iconClied(self, reason):
k = keyboard.Controller()
if reason in (
PySide6.QtWidgets.QSystemTrayIcon.ActivationReason.Trigger,
PySide6.QtWidgets.QSystemTrayIcon.ActivationReason.DoubleClick
):
k.press(keyboard.Key.caps_lock)
k.release(keyboard.Key.caps_lock)
def quit(self):
self.setVisible(False)
if 'check_thread' in dir(self):
self.check_thread.stop()
QApplication.quit()
sys.exit()
def __init__(self, download_keyword, dirname, parent=None):
super(MainWindow,
self).__init__(parent,
Qt.WindowStaysOnTopHint | Qt.CustomizeWindowHint)
self.__dirname = dirname
self.__download_widget = None
self.__image_view = None
self.__mouse_left_press_pos = None
self.__menu = QMenu(self)
self.init_common_ui()
if download_keyword:
self.init_download_ui(download_keyword)
self.__download_widget.start_download()
else:
self.init_image_ui()
self.__image_view.start_view()
def _handle_tab_context_menu(self, point):
index = self.tabBar().tabAt(point)
if index < 0:
return
tab_count = len(self._webengineviews)
context_menu = QMenu()
duplicate_tab_action = context_menu.addAction("Duplicate Tab")
close_other_tabs_action = context_menu.addAction("Close Other Tabs")
close_other_tabs_action.setEnabled(tab_count > 1)
close_tabs_to_the_right_action = context_menu.addAction("Close Tabs to the Right")
close_tabs_to_the_right_action.setEnabled(index < tab_count - 1)
close_tab_action = context_menu.addAction("&Close Tab")
chosen_action = context_menu.exec_(self.tabBar().mapToGlobal(point))
if chosen_action == duplicate_tab_action:
current_url = self.url()
self.add_browser_tab().load(current_url)
elif chosen_action == close_other_tabs_action:
for t in range(tab_count - 1, -1, -1):
if t != index:
self.handle_tab_close_request(t)
elif chosen_action == close_tabs_to_the_right_action:
for t in range(tab_count - 1, index, -1):
self.handle_tab_close_request(t)
elif chosen_action == close_tab_action:
self.handle_tab_close_request(index)
def setupUi(self, MainWindow):
if not MainWindow.objectName():
MainWindow.setObjectName(u"MainWindow")
MainWindow.resize(353, 223)
self.actionsetting = QAction(MainWindow)
self.actionsetting.setObjectName(u"actionsetting")
self.actionabout = QAction(MainWindow)
self.actionabout.setObjectName(u"actionabout")
self.actionimg_convert = QAction(MainWindow)
self.actionimg_convert.setObjectName(u"actionimg_convert")
self.centralwidget = QWidget(MainWindow)
self.centralwidget.setObjectName(u"centralwidget")
self.gridLayout_4 = QGridLayout(self.centralwidget)
self.gridLayout_4.setObjectName(u"gridLayout_4")
self.gridLayout_3 = QGridLayout()
self.gridLayout_3.setObjectName(u"gridLayout_3")
self.stackedWidget = QStackedWidget(self.centralwidget)
self.stackedWidget.setObjectName(u"stackedWidget")
self.stackedWidget.setMinimumSize(QSize(0, 0))
self.gridLayout_3.addWidget(self.stackedWidget, 0, 0, 1, 1)
self.gridLayout_4.addLayout(self.gridLayout_3, 0, 0, 1, 1)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QMenuBar(MainWindow)
self.menubar.setObjectName(u"menubar")
self.menubar.setGeometry(QRect(0, 0, 353, 22))
self.menuabout = QMenu(self.menubar)
self.menuabout.setObjectName(u"menuabout")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QStatusBar(MainWindow)
self.statusbar.setObjectName(u"statusbar")
MainWindow.setStatusBar(self.statusbar)
self.menubar.addAction(self.menuabout.menuAction())
self.menuabout.addAction(self.actionabout)
self.retranslateUi(MainWindow)
self.stackedWidget.setCurrentIndex(-1)
QMetaObject.connectSlotsByName(MainWindow)
def __init__(self, parent):
super().__init__()
# set ui direction
ui_direction = parent.persepolis_setting.value('ui_direction')
if ui_direction == 'rtl':
self.setLayoutDirection(Qt.RightToLeft)
elif ui_direction in 'ltr':
self.setLayoutDirection(Qt.LeftToRight)
# creating context menu
self.category_tree_menu = QMenu(self)
# connecting activation event
self.activated.connect(parent.categoryTreeSelected)
self.pressed.connect(parent.categoryTreeSelected)
def __init__(self, parent):
super().__init__()
# set ui direction
ui_direction = parent.persepolis_setting.value('ui_direction')
if ui_direction == 'rtl':
self.setLayoutDirection(Qt.RightToLeft)
elif ui_direction in 'ltr':
self.setLayoutDirection(Qt.LeftToRight)
# creating context menu
self.tablewidget_menu = QMenu(self)
self.sendMenu = self.tablewidget_menu.addMenu('')
# don't wrap items
self.setWordWrap(False)
def onDataViewContextMenu(self, pos):
if not self.group_id:
return
index = self.DataView.indexAt(pos)
menu_title = QWidgetAction(self.DataView)
title_lbl = QLabel()
title_lbl.setText(self.tr("Change type to:"))
menu_title.setDefaultWidget(title_lbl)
contextMenu = QMenu(self.DataView)
contextMenu.addAction(menu_title)
contextMenu.addSeparator()
combo_model = self.GroupCombo.model()
for i in range(self.GroupCombo.count()):
type_id = combo_model.data(
combo_model.index(
i, combo_model.fieldIndex(self.group_fkey_field)))
contextMenu.addAction(self.GroupCombo.itemText(i),
partial(self.updateItemType, index, type_id))
contextMenu.popup(self.DataView.viewport().mapToGlobal(pos))
def onHoldingsContextMenu(self, pos):
index = self.HoldingsTableView.indexAt(pos)
contextMenu = QMenu(self.HoldingsTableView)
actionShowChart = QAction(text=self.tr("Show Price Chart"),
parent=self.HoldingsTableView)
actionShowChart.triggered.connect(partial(self.showPriceChart, index))
contextMenu.addAction(actionShowChart)
actionEstimateTax = QAction(text=self.tr("Estimate Russian Tax"),
parent=self.HoldingsTableView)
actionEstimateTax.triggered.connect(
partial(self.estimateRussianTax, index))
contextMenu.addAction(actionEstimateTax)
contextMenu.popup(self.HoldingsTableView.viewport().mapToGlobal(pos))
def populate(self) -> None:
for category_name in self._my_sorted(self.d.keys()):
url_list = self.d[category_name]
menu = QMenu(self.root_menu)
menu.setToolTipsVisible(True)
menu.setTitle(category_name)
self.root_menu.addMenu(menu)
for entry in self._my_sorted(url_list):
result = self.extract_parts(entry)
if result:
description, link = result
act = QAction(description, self.parent)
act.setToolTip(link)
act.triggered.connect(partial(self.open_new_browser_tab_fn, link))
menu.addAction(act)
else:
if re.search(r"^-{3,}$", entry): # "---" (with length >= 3) is a separator
menu.addSeparator()
else:
log.warning(f"couldn't parse the bookmark line '{entry}'")
def context_menu(self):
"""Add context menu triggered by right click
The two purpose is to delete the column
and change tile color
"""
menu = QMenu(self)
for color_name in TILE_STYLE:
label = QLabel(color_name, self)
label.setStyleSheet(MENU_STYLE[color_name])
action = QWidgetAction(self)
action.setDefaultWidget(label)
action.triggered.connect(
partial(self.color_change, color=color_name))
menu.addAction(action)
return menu
