def contextMenuEvent(self, event: QContextMenuEvent) -> None:
menu = QMenu(self)
complete_code = menu.addAction('代码提示')
complete_code.triggered.connect(self.autoCompleteFromAll)
complete_code.setShortcut('Ctrl+Space')
menu.addSeparator()
copy = menu.addAction('复制')
copy.setShortcut(get_event('Ctrl+C'))
copy.triggered.connect(self.copy)
paste = menu.addAction('粘贴')
paste.setShortcut(get_event('Ctrl+V'))
paste.triggered.connect(self.paste)
cut = menu.addAction('剪切')
cut.setShortcut(get_event('Ctrl+X'))
cut.triggered.connect(self.cut)
menu.addSeparator()
undo = menu.addAction('撤销')
undo.setShortcut(get_event('Ctrl+Z'))
undo.triggered.connect(self.undo)
redo = menu.addAction('撤回')
redo.setShortcut('Ctrl+Y')
redo.triggered.connect(self.redo)
menu.addSeparator()
format_code = menu.addAction('格式化代码')
format_code.triggered.connect(self.format_code.emit)
format_code.setShortcut('Ctrl+Alt+L')
sort_imports = menu.addAction('整理Import语句')
sort_imports.triggered.connect(self.sort_imports.emit)
menu.exec_(event.globalPos())
def test_label_list_view(self):
menus_before = [w for w in QApplication.topLevelWidgets() if isinstance(w, QMenu)]
global context_menu
context_menu = None # type: QMenu
def on_timeout():
global context_menu
context_menu = next(w for w in QApplication.topLevelWidgets()
if w.parent() is None and isinstance(w, QMenu) and w not in menus_before)
context_menu.close()
self.cfc.add_protocol_label(10, 20, 0, 0, False)
self.cfc.add_message_type()
self.assertEqual(self.cfc.message_type_table_model.rowCount(), 2)
self.cfc.ui.tblViewProtocol.selectRow(0)
self.assertEqual(self.cfc.ui.tblLabelValues.model().rowCount(), 1)
self.cfc.ui.tblLabelValues.selectAll()
timer = QTimer(self.cfc)
timer.setSingleShot(True)
timer.timeout.connect(on_timeout)
timer.start(1)
self.cfc.ui.tblLabelValues.contextMenuEvent(QContextMenuEvent(QContextMenuEvent.Mouse, QPoint(0, 0)))
names = [action.text() for action in context_menu.actions()]
self.assertIn("Edit...", names)
def test_simulator_graphics_view(self):
self.__setup_project()
self.add_all_signals_to_simulator()
stc = self.form.simulator_tab_controller # type: SimulatorTabController
self.assertGreater(len(stc.simulator_config.get_all_items()), 0)
self.assertEqual(len(stc.simulator_scene.selectedItems()), 0)
# select first message
messages = stc.simulator_scene.get_all_message_items()
pos = stc.ui.gvSimulator.mapFromScene(messages[0].scenePos())
QTest.mouseClick(stc.ui.gvSimulator.viewport(), Qt.LeftButton, Qt.NoModifier, pos)
self.assertEqual(len(stc.simulator_scene.selectedItems()), 1)
self.assertIsInstance(stc.simulator_scene.selectedItems()[0], MessageItem)
rules = [item for item in stc.simulator_scene.items() if isinstance(item, RuleItem)]
self.assertEqual(len(rules), 0)
self.menus_to_ignore = [w for w in QApplication.topLevelWidgets() if isinstance(w, QMenu)]
timer = QTimer(self.form)
timer.setInterval(1)
timer.setSingleShot(True)
timer.timeout.connect(self.__on_context_menu_simulator_graphics_view_timer_timeout)
timer.start()
stc.ui.gvSimulator.contextMenuEvent(QContextMenuEvent(QContextMenuEvent.Mouse, pos))
rules = [item for item in stc.simulator_scene.items() if isinstance(item, RuleItem)]
self.assertEqual(len(rules), 1)
def contextMenuEvent(self, event: QContextMenuEvent):
myDebug(self.__class__.__name__, get_current_function_name())
# print(event.type(), ' ', QContextMenuEvent.MouseButtonRelease)
# if event.type() == QContextMenuEvent.MouseButtonRelease:
# if event.button() == QtCore.Qt.RightButton:
menu = self.mkQMenu()
menu.exec_(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, a0: QtGui.QContextMenuEvent) -> None:
menu = QtWidgets.QMenu()
menu.addAction(u"Go Next Task", self.parent().goNextTask)
menu.addAction(u"Go Previous Task", self.parent().goPreviousTask)
if self.selectedText():
menu.addAction(u"View Graph", self.viewGraph)
menu.addAction(u"Back", self.back)
menu.exec(a0.globalPos())
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 mouseReleaseEvent(self, ev):
"""End a self-initiated drag; if the right button was used; send a context menu event."""
if self._dragging and ev.button() == self._dragbutton:
self.stopDrag()
if ev.button() == Qt.RightButton:
QApplication.postEvent(
self.parent(),
QContextMenuEvent(QContextMenuEvent.Mouse,
ev.pos() + self.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: QContextMenuEvent):
myDebug(self.__class__.__name__, get_current_function_name())
# print(event.type(), ' ', QContextMenuEvent.MouseButtonRelease)
# if event.type() == QContextMenuEvent.MouseButtonRelease:
# if event.button() == QtCore.Qt.RightButton:
menu = self.mkQMenu()
# set_robot_id_action = QAction('Set Robot ID', menu)
# set_robot_id_action.triggered.connect(self.slot_set_robot_id)
# menu.addAction(set_robot_id_action)
menu.exec_(event.globalPos())
def contextMenuEvent(self, event: Qtqg.QContextMenuEvent):
# print("override success")
# addVersionAction
addVersionAction = Qtqw.QAction('&添加', self)
addVersionAction.triggered.connect(self.addVersionPop)
# addExamineAction & delVersionAction & renameVersionAction
addExamineAction = Qtqw.QAction('&添加', self)
addExamineAction.triggered.connect(self.addExaminePop)
delVersionAction = Qtqw.QAction('&删除', self)
delVersionAction.triggered.connect(self.delVersionFun)
renameVersionAction = Qtqw.QAction('&重命名', self)
renameVersionAction.triggered.connect(self.renameVersionFun)
# delExamineAction & renameExamineAction & importDataAction
delExamineAction = Qtqw.QAction('&删除', self)
delExamineAction.triggered.connect(self.delExamineFun)
renameExamineAction = Qtqw.QAction('&重命名', self)
renameExamineAction.triggered.connect(self.renameExamineFun)
importDataAction = Qtqw.QAction('&导入数据', self)
importDataAction.triggered.connect(self.showIptDate)
popMenu = Qtqw.QMenu()
popMenu.clear()
pointItem = event.pos() # 右击空白处获取不到位置，会导致 下面的itme 为None, 后面报错退出程序。
point = Qtqg.QCursor.pos()
self.item = self.itemAt(pointItem)
try:
if self.item.text(0) == "新创业者竞赛场次管理":
popMenu.addAction(addVersionAction)
elif self.item.parent().text(0) == "新创业者竞赛场次管理": # 父节点为root 则为二级节点
popMenu.addAction(addExamineAction)
popMenu.addAction(delVersionAction)
popMenu.addAction(renameVersionAction)
elif self.item.parent().parent().text(
0) == "新创业者竞赛场次管理": # 父节点的父节点为root 则为三级节点
popMenu.addAction(delExamineAction)
popMenu.addAction(renameExamineAction)
popMenu.addAction(importDataAction)
except:
pass
else:
popMenu.exec(point)
event.accept()
def mousePressEvent(self, mouse_event): # pylint: disable=invalid-name
# Show the context menu with a left or right mouse click
if mouse_event.buttons() & Qt.RightButton != Qt.RightButton:
new_event = QContextMenuEvent(QContextMenuEvent.Mouse,
mouse_event.pos(),
mouse_event.globalPos(),
mouse_event.modifiers())
QCoreApplication.sendEvent(self, new_event)
return super().mousePressEvent(mouse_event)
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, event: QContextMenuEvent) -> None:
menu = QMenu()
menu.setStyleSheet(menuStyle)
menu.addAction("Play", self.play)
menu.addAction("Add to now playing", self.addToNowPlaying)
menu.addAction("Play next", self.addAfterCurrent)
if self.type != "playlist":
subMenu = QMenu("Add to playlist")
subMenu.setStyleSheet(menuStyle)
subMenu.addAction("New playlist", self.createNewPlaylist)
subMenu.addSeparator()
for playlist in self.control.library.playlists:
subMenu.addAction(playlist, self.addToExistingPlaylist)
menu.addMenu(subMenu)
else:
menu.addAction("Rename", self.renamePlaylist)
menu.addAction("Delete", self.deletePlaylist)
menu.move(event.globalX(), event.globalY())
menu.exec()
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 on_list_widget_context(self, event: QContextMenuEvent):
"""On list widget right clicked"""
menu = QMenu(parent=self)
item = self.list_widget.itemAt(event.pos())
if not item:
return
action_run = QAction(self.get_as_icon('use'), 'Use This Template',
self)
action_run.triggered.connect(
lambda: self.on_templates_selected(item.text()))
menu.addAction(action_run)
action_delete = QAction(self.get_as_icon('delete'), 'Delete Template',
self)
action_delete.triggered.connect(
lambda: self.on_delete_template_clicked(item))
menu.addAction(action_delete)
menu.exec_(event.globalPos())
def test_detector_create_delete_gui(self, qtbot):
detector_name = 'test_detector'
w = Rase([])
qtbot.addWidget(w)
w.show()
qtbot.waitForWindowShown(w)
def add_detector():
qtbot.keyClicks(w.d_dialog.txtDetector, detector_name)
qtbot.mouseClick(w.d_dialog.buttonBox.button(QDialogButtonBox.Ok),
Qt.LeftButton)
QTimer.singleShot(100, add_detector)
qtbot.mouseClick(w.btnAddDetector, Qt.LeftButton)
helper = Helper()
def handle_timeout():
menu = None
for tl in QApplication.topLevelWidgets():
if isinstance(tl,
QMenu) and len(tl.actions()) > 0 and tl.actions(
)[0].text() == "Delete Instrument":
menu = tl
break
assert menu is not None
delete_action = None
for action in menu.actions():
if action.text() == 'Delete Instrument':
delete_action = action
break
assert delete_action is not None
rect = menu.actionGeometry(delete_action)
QTimer.singleShot(100, helper.finished.emit)
qtbot.mouseClick(menu, Qt.LeftButton, pos=rect.center())
with qtbot.waitSignal(helper.finished, timeout=5 * 1000):
QTimer.singleShot(1000, handle_timeout)
item = None
for row in range(w.tblDetectorReplay.rowCount()):
if w.tblDetectorReplay.item(row, 0).text() == detector_name:
item = w.tblDetectorReplay.item(row, 0)
break
assert item is not None
rect = w.tblDetectorReplay.visualItemRect(item)
event = QContextMenuEvent(QContextMenuEvent.Mouse, rect.center())
QApplication.postEvent(w.tblDetectorReplay.viewport(), event)
# make sure the detector is not in the database or the instrument table
assert w.tblDetectorReplay.rowCount() == 0
session = Session()
assert not session.query(Detector).filter_by(
name=detector_name).first()
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):
myDebug(self.__class__.__name__, get_current_function_name())
# print(event.type(), ' ', QContextMenuEvent.MouseButtonRelease)
# if event.type() == QContextMenuEvent.MouseButtonRelease:
# if event.button() == QtCore.Qt.RightButton:
menu = self.mkQMenu()
image_save_dir_set_action = QAction('设置图片保存路径', menu)
image_save_dir_set_action.triggered.connect(self.on_image_save_dir_set)
menu.addAction(image_save_dir_set_action)
menu.exec_(event.globalPos())
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:
if self.currentItem():
try:
if self.currentItem().objectName == 'table':
self.context_menu_duplicate_row.exec(event.globalPos())
except:
pass
try:
if self.currentItem().objectName == 'colName':
self.context_menu_duplicate_column.exec(event.globalPos())
except:
pass
try:
if self.currentItem().objectName == 'replace':
self.context_menu_duplicate_replace.exec(event.globalPos())
except:
pass
else:
self.context_menu_duplicate_row.exec(event.globalPos())
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 rightClick(self, pos):
"""Called when the right mouse button is released.
(Use this instead of the contextMenuEvent as that one also
fires when starting a right-button selection.)
The default implementation emits the rightClicked(pos) signal and also
sends a ContextMenu event to the View widget.
"""
self.rightClicked.emit(pos)
QApplication.postEvent(
self.view().viewport(),
QContextMenuEvent(QContextMenuEvent.Mouse, pos + self.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 eventFilter(self, viewport, ev):
"""Act on events in the viewport:
* keep on the same place when the viewport resizes
* start dragging the selection if showbutton clicked (preventing the
contextmenu if the showbutton is the right button)
* end a drag on mousebutton release, if that button would have shown
the context menu, show it on button release.
"""
if ev.type() == QEvent.Resize and self.isVisible():
view = self.parent().parent()
if not view.viewMode():
# fixed scale, try to keep ourselves in the same position on resize
self.move(self._getLayoutOffset())
elif (self.showbutton == Qt.RightButton
and isinstance(ev, QContextMenuEvent)
and ev.reason() == QContextMenuEvent.Mouse):
# suppress context menu event if that would coincide with start selection
if not self._dragging or (self.geometry()
and self.edge(ev.pos()) == _INSIDE):
return False
return True
elif not self._dragging:
if ev.type() == QEvent.MouseButtonPress and ev.button(
) == self.showbutton:
if self.isVisible():
# this cancels a previous selection if we were visible
self._setSelectionFromGeometry(QRect())
self.setGeometry(QRect(ev.pos(), QSize(0, 0)))
self._setLayoutOffset(ev.pos())
self._oldZoom = viewport.parent().zoomFactor()
self.startDrag(ev.pos(), ev.button())
self._dragedge = _RIGHT | _BOTTOM
self.adjustCursor(self._dragedge)
self.show()
return True
elif self._dragging:
if ev.type() == QEvent.MouseMove:
self.drag(ev.pos())
return True
elif ev.type() == QEvent.MouseButtonRelease and ev.button(
) == self._dragbutton:
self.stopDrag()
if ev.button() == Qt.RightButton:
QApplication.postEvent(
viewport,
QContextMenuEvent(QContextMenuEvent.Mouse, ev.pos()))
return True
return False
def contextMenuEvent(self, event: QContextMenuEvent):
menu = QMenu(self)
new_dir_action = menu.addAction("New Directory")
new_dir_action.setIcon(QIcon.fromTheme("folder"))
del_action = menu.addAction("Delete")
del_action.setIcon(QIcon.fromTheme("edit-delete"))
action = menu.exec_(self.mapToGlobal(event.pos()))
if action == new_dir_action:
self.create_directory()
elif action == del_action:
self.remove()
def contextMenuEvent(self, evt: QtGui.QContextMenuEvent) -> None:
menu = QtWidgets.QMenu()
if not self.__player_state.playing(
) and self.__player_state.currentTime() is not None:
set_loop_start = QtWidgets.QAction("Set loop start", menu)
set_loop_start.triggered.connect(lambda _: self.onSetLoopStart(
self.__player_state.currentTime()))
menu.addAction(set_loop_start)
set_loop_end = QtWidgets.QAction("Set loop end", menu)
set_loop_end.triggered.connect(
lambda _: self.onSetLoopEnd(self.__player_state.currentTime()))
menu.addAction(set_loop_end)
clear_loop = QtWidgets.QAction("Clear loop", menu)
clear_loop.triggered.connect(lambda _: self.onClearLoop())
menu.addAction(clear_loop)
if not menu.isEmpty():
menu.exec_(evt.globalPos())
evt.accept()
return
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.create_context_menu().exec_(self.mapToGlobal(event.pos()))
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.menu.exec(event.globalPos())
