def contextMenuEvent(self, event: QContextMenuEvent):
if self.ctrl_mode:
return
self.context_menu_position = event.pos()
menu = self.create_context_menu()
menu.exec_(self.mapToGlobal(event.pos()))
self.context_menu_position = None
def handleNewNodeContextMenu(self, event: QContextMenuEvent):
if DEBUG_CONTEXT: print('Context: New Node')
context_menu = self.initNodesContextMenu()
action = context_menu.exec_(self.mapToGlobal(
event.pos())) # draw to scene and get the selected action
if action is not None:
new_calc_node = NodeFactory.from_op_code(action.data())(self.scene)
scene_pos = self.scene.getView().mapToScene(event.pos())
new_calc_node.setPos(scene_pos.x(), scene_pos.y())
if self.scene.getView().isEdgeDragging():
# in dragging edge mode, connect the current edge to the first input
target_socket = self.determine_target_socket_of_node(
self.scene.getView().dragging.drag_start_socket.is_output,
new_calc_node)
if target_socket is not None:
self.scene.getView().dragging.edgeDragEnd(
target_socket.grSocket)
self.finish_new_node_state(new_calc_node)
# select the newly create node
new_calc_node.doSelect(True)
else:
self.scene.history.storeHistory(
f'Created {new_calc_node.__class__.__name__}')
def contextMenuEvent(self, evt: QContextMenuEvent) -> None:
index: QModelIndex = self.indexAt(evt.pos())
actions = []
if index.isValid():
node: CustomNode = index.internalPointer()
index: QModelIndex = self.indexAt(evt.pos())
menu = QMenu()
menu.triggered.connect(self.context_menu_actions_handler)
if node.level == 1:
actions = [
QAction(gui.get_icon('new_folder.png'), self.CTX_MENU_ADD_REPOSITORY_ACTION)
]
elif node.level == 2:
actions = [
QAction(gui.get_icon('delete.png'), self.CTX_MENU_DELETE_REPO_ACTION),
QAction(gui.get_icon('refresh.png'), self.CTX_MENU_UPDATE_REPO_ACTION)
]
elif node.level == 3:
actions = [
QAction(gui.get_icon('robotic-hand.png'), self.CTX_MENU_AUTO_LABEL_ACTION)
]
if actions:
for act in actions:
act.setData(index)
menu.addAction(act)
menu.exec_(self.mapToGlobal(evt.pos()))
def contextMenuEvent(self, event: QContextMenuEvent) -> None:
col = self.columnAt(event.pos().x())
row = self.rowAt(event.pos().y())
if col == 3:
item = self.item(row, col)
vtype = item.value_type
if vtype != "unknown":
menu = QMenu(self)
as_int = QAction("repr as int", self)
as_int.triggered.connect(lambda: self.repr_as_int(row, col))
as_hex = QAction("repr as hex", self)
as_hex.triggered.connect(lambda: self.repr_as_hex(row, col))
as_flt = QAction("repr as floating", self)
as_flt.triggered.connect(
lambda: self.repr_as_floating(row, col))
as_str = QAction("repr as str", self)
as_str.triggered.connect(lambda: self.repr_as_str(row, col))
as_bys = QAction("repr as bytes", self)
as_bys.triggered.connect(lambda: self.repr_as_bytes(row, col))
menu.addAction(as_int)
menu.addAction(as_hex)
menu.addAction(as_flt)
menu.addAction(as_str)
menu.addAction(as_bys)
menu.popup(QCursor.pos())
def contextMenuEvent(self, event: QContextMenuEvent):
menu = QMenu()
item = self.indexAt(event.pos()).row()
if item < 0:
return
item_name = self.item(item).text()
# Menu Entries
rmFunction = menu.addAction(self.tr("Delete"))
if constants.DECODING_DISABLED_PREFIX in item_name:
disableFunction = menu.addAction(self.tr("Enable"))
else:
disableFunction = menu.addAction(self.tr("Disable"))
menu.addSeparator()
clearAll = menu.addAction(self.tr("Clear All"))
# Menu Actions
action = menu.exec_(self.mapToGlobal(event.pos()))
if action == rmFunction:
self.active_element_text = item_name
self.takeItem(item)
ListWidget.deleteElementSignal(self)
elif action == clearAll:
while self.count() > 0:
self.takeItem(0)
ListWidget.deleteElementSignal(self)
elif action == disableFunction:
if constants.DECODING_DISABLED_PREFIX in item_name:
item_name = item_name[len(constants.DECODING_DISABLED_PREFIX):]
else:
item_name = constants.DECODING_DISABLED_PREFIX + item_name
self.takeItem(item)
self.insertItem(item, item_name)
ListWidget.internalMoveSignal(self)
def contextMenuEvent(self, event: QtGui.QContextMenuEvent) -> None:
if self.event_ is not None:
row = self.__tablewidget_admins_.rowAt(event.pos().y())
col = self.__tablewidget_admins_.columnAt(event.pos().x())
cell: cQTableWidgetItem = self.__tablewidget_admins_.item(row, col)
if row != 0:
cell.contextMenuEvent(self, event)
self.clear()
self.setTable()
self.addItems()
def contextMenuEvent(self, event: QContextMenuEvent):
menu = QMenu()
new_group_action = menu.addAction(self.tr("Create a new group"))
item = self.model().getItem(self.indexAt(event.pos()))
selected_items = [
self.model().getItem(index)
for index in self.selectionModel().selectedIndexes()
]
selected_protocols = [
item.protocol for item in selected_items if not item.is_group
]
delete_group_action = 42
close_action = 42
sort_group_elements_action = 4711
move_to_group_actions = {}
if item.is_group:
delete_group_action = menu.addAction(self.tr("Delete Group"))
elif item != self.model().rootItem:
tree_items = self.model().protocol_tree_items
other_groups = [
i for i in tree_items.keys() if item not in tree_items[i]
]
if len(selected_protocols) > 0:
close_action = menu.addAction(self.tr("Close"))
close_action.setIcon(QIcon.fromTheme("window-close"))
if len(other_groups) > 0:
move_to_group_menu = menu.addMenu("Move to Group")
for i in other_groups:
group_name = self.model().rootItem.child(i).data()
move_to_group_actions[move_to_group_menu.addAction(
group_name)] = i
if item != self.model().rootItem:
menu.addSeparator()
sort_group_elements_action = menu.addAction("Sort Group Elements")
action = menu.exec_(self.mapToGlobal(event.pos()))
if action == new_group_action:
self.model().addGroup()
self.model().update()
elif action == delete_group_action:
self.model().delete_group(item)
elif action in move_to_group_actions.keys():
i = move_to_group_actions[action]
self.model().move_to_group(selected_items, i)
elif action == close_action:
self.close_wanted.emit(selected_protocols)
elif action == sort_group_elements_action:
if item.is_group:
sortgroup_id = self.model().rootItem.index_of(item)
else:
sortgroup_id = self.model().rootItem.index_of(item.parent())
self.model().sort_group(sortgroup_id)
def contextMenuEvent(self, evt: QContextMenuEvent) -> None:
menu = QMenu()
menu.triggered.connect(self.context_menu_actions_handler)
index: QModelIndex = self.indexAt(evt.pos())
if index.isValid():
icon: QIcon = GUIUtilities.get_icon('delete_label.png')
action = menu.addAction(icon, self.CTX_MENU_DELETE_LABEL)
action.setData(index)
else:
icon: QIcon = GUIUtilities.get_icon('new_label.png')
menu.addAction(icon, self.CTX_MENU_ADD_LABEL)
menu.exec_(self.mapToGlobal(evt.pos()))
def contextMenuEvent(self, event: QContextMenuEvent):
col = self.table.columnAt(event.pos().x())
if col < len(self.cols):
return
menu = QMenu(self.table)
delete = menu.addAction('Delete this column')
# delete.setShortcut('Ctrl+D')
# delete.setShortcutContext(Qt.WidgetWithChildrenShortcut)
action = menu.exec_(self.mapToGlobal(event.pos()))
if action == delete:
self.delete_column(col)
def contextMenuEvent(self, event: QContextMenuEvent) -> None:
menu = QMenu()
self.app.set_theme(self.app.settings.current_theme(), menu)
edit = menu.addAction("Edit")
delete = menu.addAction("Delete")
action = menu.exec_(self.mapToGlobal(event.pos()))
course_id = self.itemAt(event.pos()).data(1)
if action == edit:
CourseDialog(self.app, "Edit Course", course_id).exec_()
self.app.refresh()
elif action == delete:
self.app.planner.delete_course(course_id)
self.app.refresh()
def contextMenuEvent(self, event: QContextMenuEvent):
menu = QMenu()
pos = event.pos()
index = self.indexAt(pos)
try:
if len(self.model().message.message_type) == 0:
return
except AttributeError:
return # model().message may be None
editAction = menu.addAction("Edit Fuzzing Label...")
delAction = 42
if index.isValid():
delAction = menu.addAction("Delete Fuzzing Label")
menu.addSeparator()
fuzzAllAction = menu.addAction("Check all")
unfuzzAllAction = menu.addAction("Uncheck all")
action = menu.exec_(self.mapToGlobal(pos))
if action == delAction:
self.model().delete_label_at(index.row())
elif action == editAction:
self.editActionTriggered.emit(index.row())
elif action == fuzzAllAction:
self.model().fuzzAll()
elif action == unfuzzAllAction:
self.model().unfuzzAll()
def contextMenuEvent(self, a0: QtGui.QContextMenuEvent):
contextManu = QtWidgets.QMenu(self)
returns_action = contextManu.addAction("Returns")
drawdown_action = contextManu.addAction("Drawdown")
alpha_action = contextManu.addAction('Alpha')
beta_action = contextManu.addAction('Beta')
sharpe_action = contextManu.addAction('Sharpe')
std_dev = contextManu.addAction('Std Dev')
positions = contextManu.addAction('Positions')
action = contextManu.exec_(self.mapToGlobal(a0.pos()))
if action == returns_action:
self.plotter.plot_type = 'returns'
elif action == drawdown_action:
self.plotter.plot_type = 'drawdown'
elif action == alpha_action:
self.plotter.plot_type = 'alpha'
elif action == beta_action:
self.plotter.plot_type = 'beta'
elif action == sharpe_action:
self.plotter.plot_type = 'sharpe'
elif action == std_dev:
self.plotter.plot_type = 'std_dev'
elif action == positions:
self.plotter.plot_type = 'positions'
self.update_plot(self.analysis_data)
def contextMenuEvent(self, event: QContextMenuEvent):
menu = QMenu()
pos = event.pos()
index = self.indexAt(pos)
if len(self.model().proto_container.protocol_labels) == 0:
return
editAction = menu.addAction("Edit Fuzzing Label...")
delAction = 42
if index.isValid():
delAction = menu.addAction("Delete Fuzzing Label")
editAllAction = menu.addAction("Edit all Fuzzing Values...")
menu.addSeparator()
fuzzAllAction = menu.addAction("Check all")
unfuzzAllAction = menu.addAction("Uncheck all")
action = menu.exec_(self.mapToGlobal(pos))
if action == delAction:
self.model().delete_label_at(index.row())
elif action == editAction:
self.editActionTriggered.emit(index.row())
elif action == fuzzAllAction:
self.model().fuzzAll()
elif action == unfuzzAllAction:
self.model().unfuzzAll()
elif action == editAllAction:
self.editAllActionTriggered.emit()
def contextMenuEvent(self, event: QContextMenuEvent):
menu = self.createStandardContextMenu(event.pos())
actionCopyVhead = menu.addAction("Copy CIF Keyword")
deleterow = menu.addAction("Delete Row")
actionCopyVhead.triggered.connect(self.copy_vhead_item)
deleterow.triggered.connect(self._delete_row)
choosedAction = menu.exec(event.globalPos())
def contextMenuEvent(self, evt: QtGui.QContextMenuEvent) -> None:
time = self.track.xToTime(evt.pos().x())
menu = QtWidgets.QMenu(self.track)
menu.setObjectName('context-menu')
add_sample_action = QtWidgets.QAction("Import audio file...", menu)
add_sample_action.setObjectName('add-sample')
add_sample_action.setStatusTip(
"Import an audio file and add it as a segment to the track.")
add_sample_action.triggered.connect(
functools.partial(self.onAddSampleSync, time))
menu.addAction(add_sample_action)
smpl = self.track.highlightedSample()
if smpl is not None:
delete_sample_action = QtWidgets.QAction("Delete segment", menu)
delete_sample_action.setObjectName('delete-sample')
delete_sample_action.setStatusTip(
"Remove the selected segment from the track.")
delete_sample_action.triggered.connect(
functools.partial(self.onDeleteSample, smpl.sample))
menu.addAction(delete_sample_action)
menu.popup(evt.globalPos())
evt.accept()
def contextMenuEvent(self, e: QtGui.QContextMenuEvent) -> None:
context_menu = self.createCustomContextMenu(e.pos())
# Fix white border in context menu in Windows dark mode
context_menu.setStyleSheet(
""
"QMenu{background-color: palette(window);}"
"QMenu::item:selected{background-color: palette(highlight);}")
context_menu.exec_(e.globalPos())
def contextMenuEvent(self, event: QContextMenuEvent):
item = self.itemAt(event.pos()) or self.currentItem()
if not item:
return
if item.parent():
self._scriptMenu.popup(event.globalPos())
else:
self._accountMenu.popup(event.globalPos())
def contextMenuEvent(self, evt: QContextMenuEvent) -> None:
index: QModelIndex = self.indexAt(evt.pos())
if index.isValid():
node: CustomNode = index.internalPointer()
menu = QMenu()
menu.triggered.connect(self.context_menu_actions_handler)
if node.level == 1:
icon: QIcon = GUIUtilities.get_icon('delete-dataset.png')
action: QAction = menu.addAction(
icon, self.CTX_MENU_NEW_DATASET_ACTION)
action.setData(node)
elif node.level == 3:
icon: QIcon = GUIUtilities.get_icon('delete-dataset.png')
action: QAction = menu.addAction(
icon, self.CTX_MENU_AUTO_LABEL_ACTION)
action.setData(node)
menu.exec_(self.mapToGlobal(evt.pos()))
def contextMenuEvent(self, e: QContextMenuEvent):
""" 重写鼠标右击时间的响应函数 """
hitIndex = self.indexAt(e.pos()).column()
# 显示右击菜单
if hitIndex > -1:
contextMenu = SongCardListContextMenu(self)
self.__connectMenuSignalToSlot(contextMenu)
contextMenu.exec(self.cursor().pos())
def contextMenuEvent(self, event: QContextMenuEvent):
menu = QMenu()
newGroupAction = menu.addAction(self.tr("Create a new group"))
item = self.model().getItem(self.indexAt(event.pos()))
selected_items = [
self.model().getItem(index)
for index in self.selectionModel().selectedIndexes()
]
deleteGroupAction = 42
sortGroupElementsAction = 4711
moveToGroupActions = {}
if item.is_group:
deleteGroupAction = menu.addAction(self.tr("Delete Group"))
elif item != self.model().rootItem:
pfitems = self.model().protocol_tree_items
other_groups = [
i for i in pfitems.keys() if item not in pfitems[i]
]
if len(other_groups) > 0:
moveToGroupMenu = menu.addMenu("Move to Group")
for i in other_groups:
group_name = self.model().rootItem.child(i).data()
moveToGroupActions[moveToGroupMenu.addAction(
group_name)] = i
if item != self.model().rootItem:
menu.addSeparator()
sortGroupElementsAction = menu.addAction("Sort Group Elements")
action = menu.exec_(self.mapToGlobal(event.pos()))
if action == newGroupAction:
self.model().addGroup()
self.model().layoutChanged.emit()
elif action == deleteGroupAction:
self.model().deleteGroup(item)
elif action in moveToGroupActions.keys():
i = moveToGroupActions[action]
self.model().moveToGroup(selected_items, i)
elif action == sortGroupElementsAction:
if item.is_group:
sortgroup_id = self.model().rootItem.index_of(item)
else:
sortgroup_id = self.model().rootItem.index_of(item.parent())
self.model().sort_group(sortgroup_id)
def handleEdgeContextMenu(self, event: QContextMenuEvent):
if DEBUG_CONTEXT: print('Context: Edge')
# define the context menu
context_menu = QMenu(self)
bezierAct = context_menu.addAction('Bezier Edge')
directAct = context_menu.addAction('Direct Edge')
action = context_menu.exec_(self.mapToGlobal(event.pos())) # draw to scene and get the selected action
selected = None
item = self.scene.getItemAt(event.pos())
if hasattr(item, 'edge'):
selected = item.edge
if selected and action == bezierAct:
selected.edge_type = EDGE_TYPE_BEZIER
if selected and action == directAct:
selected.edge_type = EDGE_TYPE_DIRECT
def contextMenuEvent(self, event: QtGui.QContextMenuEvent):
menu = QtWidgets.QMenu()
delete_action = menu.addAction("delete")
action = menu.exec(self.mapToGlobal(event.pos()))
if action == delete_action:
if self.duplicate.delete():
self.hide()
self.deleteLater()
self.deleted.emit(self.duplicate.path)
def contextMenuEvent(self, event: QtGui.QContextMenuEvent):
menu = QMenu(self)
remove = QAction("Remove", self)
remove.setIcon(QIcon("../resources/icon-delete.png"))
remove.triggered.connect(self.make_remove_model)
menu.addAction(remove)
menu.exec_(self.mapToGlobal(event.pos()))
def contextMenuEvent(self, event: QContextMenuEvent):
menu = QMenu()
pos = event.pos()
index = self.indexAt(pos)
min_row, max_row = self.selection_range()
editAction = menu.addAction("Edit Protocol Label...")
assign_actions = []
message_type_names = []
if min_row > -1:
menu.addAction(self.del_rows_action)
message_type_names = [
lset.name for lset in
self.model().controller.proto_analyzer.message_types
]
try:
proto_label = self.model().get_label_at(index.row())
avail_message_types = []
for message_type in self.model(
).controller.proto_analyzer.message_types:
if proto_label not in message_type:
avail_message_types.append(message_type)
if avail_message_types:
assign_menu = menu.addMenu("Copy label(s) to message type")
assign_actions = [
assign_menu.addAction(message_type.name)
for message_type in avail_message_types
]
except IndexError:
pass
menu.addSeparator()
showAllAction = menu.addAction("Show all")
hideAllAction = menu.addAction("Hide all")
menu.addSeparator()
configureAction = menu.addAction("Configure field types...")
action = menu.exec_(self.mapToGlobal(pos))
if action == editAction:
self.editActionTriggered.emit(index.row())
elif action == showAllAction:
self.model().showAll()
elif action == hideAllAction:
self.model().hideAll()
elif action == configureAction:
self.configureActionTriggered.emit()
elif action in assign_actions:
message_type_id = message_type_names.index(action.text())
self.model().add_labels_to_message_type(min_row, max_row,
message_type_id)
def contextMenuEvent(self, event: QtGui.QContextMenuEvent) -> None:
"""
Function toggle draggable of window
:param event: choice button of context menu
:return:
"""
action = self.menu.exec_(self.mapToGlobal(event.pos()))
if action:
self.actions[action.text()]()
def contextMenuEvent(self, event: QContextMenuEvent):
menu = QMenu()
pos = event.pos()
min_row, max_row, start, end = self.selection_range()
selected_label_indx = self.model().get_selected_label_index(
self.columnAt(event.pos().x()))
if selected_label_indx == -1:
fuzzingAction = menu.addAction("Create Fuzzing Label...")
else:
fuzzingAction = menu.addAction("Edit Fuzzing Label...")
menu.addSeparator()
insertColLeft = menu.addAction("Add column on the left")
insertColRight = menu.addAction("Add column on the right")
duplicateAction = menu.addAction("Duplicate Line")
menu.addSeparator()
clearAction = menu.addAction("Clear Table")
if min_row == -1:
fuzzingAction.setEnabled(False)
if self.model().col_count == 0:
clearAction.setEnabled(False)
action = menu.exec_(self.mapToGlobal(pos))
if action == fuzzingAction:
if selected_label_indx == -1:
self.create_fuzzing_label_clicked.emit(min_row, start, end)
else:
self.edit_fuzzing_label_clicked.emit(selected_label_indx)
elif action == clearAction:
self.model().clear()
elif action == duplicateAction:
row = self.rowAt(event.pos().y())
self.model().duplicate_row(row)
elif action == insertColLeft:
col = self.columnAt(event.pos().x())
self.model().insert_column(col)
elif action == insertColRight:
col = self.columnAt(event.pos().x())
self.model().insert_column(col + 1)
def contextMenuEvent(self, e: QContextMenuEvent):
""" 显示右击菜单 """
hitIndex = self.indexAt(e.pos()).column()
if hitIndex > -1:
self.menu.moveUpAct.setEnabled(True)
self.menu.moveDownAct.setEnabled(True)
if self.currentRow() == len(self.playlist) - 1:
self.menu.moveDownAct.setEnabled(False)
if self.currentRow() == 0:
self.menu.moveUpAct.setEnabled(False)
self.menu.exec_(e.globalPos())
def contextMenuEvent(self, event: QtGui.QContextMenuEvent):
if not self.detail:
return
pos = self.mapToGlobal(event.pos())
item: QtWidgets.QTreeWidgetItem = self.currentItem()
if item is None:
return
elif item.type() == 0:
self.categoryMenu.popup(pos)
elif item.type() == 1:
self.lineMenu.popup(pos)
def contextMenuEvent(self, event: QContextMenuEvent):
menu = QMenu()
pos = event.pos()
index = self.indexAt(pos)
min_row, max_row = self.selection_range()
edit_action = menu.addAction("Edit Protocol Label...")
edit_action.setIcon(QIcon.fromTheme("configure"))
assign_actions = []
message_type_names = []
if min_row > -1:
menu.addAction(self.del_rows_action)
message_type_names = [lset.name for lset in self.model().controller.proto_analyzer.message_types]
try:
proto_label = self.model().get_label_at(index.row())
avail_message_types = []
for message_type in self.model().controller.proto_analyzer.message_types:
if proto_label not in message_type:
avail_message_types.append(message_type)
if avail_message_types:
assign_menu = menu.addMenu("Copy label(s) to message type")
assign_menu.setIcon(QIcon.fromTheme("edit-copy"))
assign_actions = [assign_menu.addAction(message_type.name) for message_type in avail_message_types]
except IndexError:
pass
menu.addSeparator()
show_all_action = menu.addAction("Show all")
hide_all_action = menu.addAction("Hide all")
menu.addSeparator()
update_message_types_action = menu.addAction("Update automatically assigned message types")
update_message_types_action.setIcon(QIcon.fromTheme("view-refresh"))
configure_action = menu.addAction("Configure field types...")
action = menu.exec_(self.mapToGlobal(pos))
if action == edit_action:
self.editActionTriggered.emit(index.row())
elif action == show_all_action:
self.model().showAll()
elif action == hide_all_action:
self.model().hideAll()
elif action == configure_action:
self.configureActionTriggered.emit()
elif action == update_message_types_action:
self.auto_message_type_update_triggered.emit()
elif action in assign_actions:
message_type_id = message_type_names.index(action.text())
self.model().add_labels_to_message_type(min_row, max_row, message_type_id)
def contextMenuEvent(self, event: QtGui.QContextMenuEvent) -> None:
menu = QMenu(self)
qAct = QAction('exit', menu)
qAct.triggered.connect(lambda x: qApp.quit())
newAct = menu.addAction("new")
retAct = menu.addAction('open')
menu.addAction(qAct)
# 主要是激活menu事件
action = menu.exec_(self.mapToGlobal(event.pos()))
def contextMenuEvent(self, event: QContextMenuEvent):
menu = QMenu()
sel_indexes = [index.row() for index in self.selectedIndexes()]
edit_action = QAction("Edit", self)
if len(sel_indexes) == 0:
edit_action.setEnabled(False)
menu.addAction(edit_action)
action = menu.exec_(self.mapToGlobal(event.pos()))
if action == edit_action:
selected_indx = sel_indexes[0]
self.item_edit_clicked.emit(selected_indx)
def contextMenuEvent(self, event: QContextMenuEvent):
if self.signal is None:
return
menu = QMenu()
apply_to_all_action = menu.addAction(self.tr("Apply values (BitLen, 0/1-Threshold, Tolerance) to all signals"))
menu.addSeparator()
auto_detect_action = menu.addAction(self.tr("Auto-Detect signal parameters"))
action = menu.exec_(self.mapToGlobal(event.pos()))
if action == apply_to_all_action:
self.setCursor(Qt.WaitCursor)
self.apply_to_all_clicked.emit(self.signal)
self.unsetCursor()
elif action == auto_detect_action:
self.setCursor(Qt.WaitCursor)
self.signal.auto_detect()
self.unsetCursor()
def contextMenuEvent(self, event: QContextMenuEvent):
self.context_menu_pos = event.pos()
menu = self.create_context_menu()
menu.exec_(self.mapToGlobal(event.pos()))
self.context_menu_pos = None
def contextMenuEvent(self, event: QContextMenuEvent):
self.create_context_menu().exec_(self.mapToGlobal(event.pos()))
