def mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent) -> None: #pylint: disable=unused-argument
menu = QMenu()
def _select_states():
if self.disasm_view:
self.disasm_view.redraw_current_graph()
symexec_view = self.symexec_view
if symexec_view:
symexec_view.select_states(self.states)
symexec_view.workspace.raise_view(symexec_view)
def _move_states():
disasm_view = self.disasm_view
symexec_view = self.symexec_view
if disasm_view is None or symexec_view is None:
return
to_stash, ok = QInputDialog.getText(disasm_view, "Move to?",
"Target Stash Name:",
QLineEdit.Normal)
if ok:
symexec_view.current_simgr.move("active", to_stash,
lambda s: s in self.states)
symexec_view._simgrs._simgr_viewer.refresh()
disasm_view.refresh()
menu.addAction("Select", _select_states)
menu.addAction("Move To", _move_states)
menu.exec_(QCursor.pos())
class BracketItem(QGraphicsItem):
def __init__(self, id):
super(BracketItem, self).__init__()
self.zoomFactor = 1
self.rootSlot = SlotItem(1, self)
self.leftChild = SlotItem(2, self)
self.rightChild = SlotItem(3, self)
self.rootSlot.setPos(120, 20)
self.leftChild.setPos(20, 140)
self.rightChild.setPos(220, 140)
self.scaleFactor = 1
def boundingRect(self):
return QRectF(0, 0, 340, 230)
def paint(self, painter, option, widget):
# self.scaleFactor -= 0.1
# painter.scale(self.scaleFactor, self.scaleFactor)
rect = self.boundingRect()
painter.drawRect(rect)
painter.drawLine(170, 90, 70, 140)
painter.drawLine(170, 90, 270, 140)
def contextMenuEvent(self, event):
self.menu = QMenu()
self.showModeAction = QAction('Bracket')
self.menu.addAction(self.showModeAction)
self.menu.exec_(event.screenPos())
def onCustomContextMenu(self, localPosition: QPoint):
"""
Show a custom context menu with a "Download file" action when a file is right-clicked.
:param localPosition: position where the user clicked.
"""
selectedFile = self.selectedFile()
if selectedFile is None:
return
globalPosition = self.listWidget.mapToGlobal(localPosition)
downloadAction = QAction("Download file")
downloadAction.setEnabled(selectedFile.type in [FileSystemItemType.File])
downloadAction.triggered.connect(self.downloadFile)
downloadRecursiveAction = QAction("Download files recursively")
downloadRecursiveAction.setEnabled(selectedFile.type in [FileSystemItemType.Directory])
downloadRecursiveAction.triggered.connect(self.downloadDirectoryRecursively)
itemMenu = QMenu()
itemMenu.addAction(downloadAction)
itemMenu.addAction(downloadRecursiveAction)
itemMenu.exec_(globalPosition)
def contextMenuEvent(self, event):
index = self.tabBar().tabAt(event.pos())
if index < 0:
return
menu = QMenu(self)
closeSelected = QAction("Close", self)
closeAllAction = QAction("Close All", self)
closeOthersAction = QAction("Close Others", self)
closeUnmodified = QAction("Close Unmodified", self)
closeSelected.triggered.connect(lambda: self.closeTab(index))
closeOthersAction.triggered.connect(lambda: self.closeOthers(index))
closeAllAction.triggered.connect(self.closeAllTabs)
closeUnmodified.triggered.connect(
lambda: self.closeAllTabs(closeUnmodified=True))
menu.addAction(closeSelected)
menu.addAction(closeOthersAction)
menu.addAction(closeAllAction)
menu.addAction(closeUnmodified)
if index != 0:
closeAllToTheLeft = QAction("Close All to the Left", self)
closeAllToTheLeft.triggered.connect(
lambda: self.closeAllToTheSide(index, "left"))
menu.addAction(closeAllToTheLeft)
if index != len(self.tabs) - 1:
closeAllToTheRight = QAction("Close All to the Right", self)
closeAllToTheRight.triggered.connect(
lambda: self.closeAllToTheSide(index, "right"))
menu.addAction(closeAllToTheRight)
menu.exec_(self.mapToGlobal(event.pos()))
class MyItem(QGraphicsItem):
def __init__(self, _id):
super(MyItem, self).__init__()
self.setFlag(QGraphicsItem.ItemIsMovable)
self.itemId = _id
self.scaleFactor = 1
def paint(self, painter, options, widget):
painter.scale(self.scaleFactor, self.scaleFactor)
rect = self.boundingRect()
if self.itemId == 1:
pen = QPen(Qt.red, 2)
painter.drawRect(rect)
else:
pen = QPen(Qt.blue, 2)
painter.drawEllipse(rect)
def setScaleFactor(self, value):
self.scaleFactor = value
self.update()
def boundingRect(self):
return QRectF(0, 0, 100, 100)
def contextMenuEvent(self, event):
self.menu = QMenu()
self.action = QAction(f'Item {self.itemId}')
self.menu.addAction(self.action)
self.menu.exec_(event.screenPos())
def chooseFileContextMenu(self):
if hasattr(self, 'dataDisplay'):
menu = QMenu(self)
addStatementAction = QAction('Add Statement')
addStatementAction.triggered.connect(self.addFile)
menu.addAction(addStatementAction)
menu.exec_(QCursor.pos())
def contextMenuEvent(self, event):
"""Context menu of tab options. """
tab_index = self.tabBar().tabAt(event.pos())
tab_menu = None
# Currently over a tab
if tab_index > -1:
#rename_action = QAction("Rename", self)
#rename_action.triggered.connect(self._setNewTabName(tab_index))
remove_tab_action = QAction(
QIcon(os.path.join('images', 'edit-delete.png')), "Close",
self)
remove_tab_action.triggered.connect(
self._removeSelectedTab(tab_index))
tab_menu = QMenu(self)
#tab_menu.addAction(rename_action)
tab_menu.addSeparator()
tab_menu.addAction(remove_tab_action)
if tab_index == 0:
remove_tab_action.setDisabled(True)
# In tab bar, but not over any tabs
else:
new_page_action = QAction("Insert New Page", self)
new_page_action.triggered.connect(self.newPage)
tab_menu = QMenu(self)
tab_menu.addAction(new_page_action)
tab_menu.exec_(event.globalPos())
self.focusInEvent(QFocusEvent(QEvent.FocusIn))
def contextMenuRequested(self, point):
menu = QMenu()
actionFile = menu.addAction(QIcon.fromTheme("video-x-generic"),
"open File (o)")
actionclipboard = menu.addSeparator()
actionURL = menu.addAction(QIcon.fromTheme("browser"),
"URL from Clipboard (u)")
actionclipboard = menu.addSeparator()
actionYTurl = menu.addAction(QIcon.fromTheme("youtube"),
"URL from YouTube (y)")
actionclipboard = menu.addSeparator()
actionToggle = menu.addAction(QIcon.fromTheme("next"),
"show / hide Slider (s)")
actionFull = menu.addAction(QIcon.fromTheme("view-fullscreen"),
"Fullscreen (f)")
action169 = menu.addAction(QIcon.fromTheme("tv-symbolic"), "16 : 9")
action43 = menu.addAction(QIcon.fromTheme("tv-symbolic"), "4 : 3")
actionSep = menu.addSeparator()
actionInfo = menu.addAction(QIcon.fromTheme("help-about"), "Info (i)")
action5 = menu.addSeparator()
actionQuit = menu.addAction(QIcon.fromTheme("application-exit"),
"Exit (q)")
actionFile.triggered.connect(self.openFile)
actionQuit.triggered.connect(self.handleQuit)
actionFull.triggered.connect(self.handleFullscreen)
actionInfo.triggered.connect(self.handleInfo)
actionToggle.triggered.connect(self.toggleSlider)
actionURL.triggered.connect(self.playFromURL)
actionYTurl.triggered.connect(self.getYTUrl)
action169.triggered.connect(self.screen169)
action43.triggered.connect(self.screen43)
menu.exec_(self.mapToGlobal(point))
def _execTreeViewContextMenu(self, point):
index = self.treeView.indexAt(point)
item = self.model.data(index, ITEM_ROLE)
if isinstance(item, ConfigurationModel.SubConfigContent):
m = QMenu()
a1 = QAction("Edit graph")
m.addAction(a1)
a1.triggered.connect(lambda: self._addGraphView(item.subConfig))
if self.model.isApplication(index):
a2 = QAction("Select Application")
a2.triggered.connect(lambda: self.changeActiveApp(
self.model.data(index, Qt.DisplayRole)))
a3 = QAction("Init Application")
a3.triggered.connect(lambda: self._changeActiveAppAndInit(
self.model.data(index, Qt.DisplayRole)))
m.addActions([a2, a3])
pbsrv = Services.getService("PlaybackControl")
m2 = m.addMenu("Init and load sequence")
m3 = m.addMenu("Init, load and play")
s1 = []
s2 = []
for a in pbsrv.recentSeqs:
assert isinstance(a, QAction)
if a.isVisible():
# pylint: disable=cell-var-from-loop
# the below statements are tested and work
aseq = QAction(a.text())
aseq.triggered.connect(lambda arg1=a.data(
), seq=a.data(): self._changeActiveAppInitAndLoad(
self.model.data(index, Qt.DisplayRole), seq, False)
)
s1.append(aseq)
aseq = QAction(a.text())
aseq.triggered.connect(lambda arg1=a.data(
), seq=a.data(): self._changeActiveAppInitAndLoad(
self.model.data(index, Qt.DisplayRole), seq, True))
# pylint: enable=cell-var-from-loop
s2.append(aseq)
m2.addActions(s1)
m3.addActions(s2)
m.exec_(self.treeView.mapToGlobal(point))
return
if self.model.isSubConfigParent(
index) == Configuration.CONFIG_TYPE_APPLICATION:
m = QMenu()
a = QAction("Add application")
m.addAction(a)
a = m.exec_(self.treeView.mapToGlobal(point))
if a is not None:
self._configuration.addNewApplication()
return
if self.model.isSubConfigParent(
index) == Configuration.CONFIG_TYPE_COMPOSITE:
m = QMenu()
a = QAction("Add composite filter")
m.addAction(a)
a = m.exec_(self.treeView.mapToGlobal(point))
if a is not None:
self._configuration.addNewCompositeFilter()
return
class WorkspaceChooser(QListWidget):
def __init__(self, algManager, parent=None):
QListWidget.__init__(self, parent)
self.algManager = algManager
self._createPopupMenu()
def _createPopupMenu(self):
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.onContextMenu)
self.algorithmMenu = QMenu(None)
self.algorithmMenu.addAction("Adjust parameters...", self.adjustAlgorithm)
def onContextMenu(self, pos):
self.clickedItem = self.itemAt(pos)
if self.clickedItem is None:
return
if self.clickedItem.data(1)[:9] == 'Algorithm':
self.algorithmMenu.exec_(self.mapToGlobal(pos))
def adjustAlgorithm(self):
wsName = self.clickedItem.text()
self.algManager.adjustAlogrithmParameters(wsName)
def set_menu(self, _):
delete_option = QMenu()
delete_option.addAction(
QAction("删除",
delete_option,
triggered=self.delete_table_thread.start))
delete_option.exec_(QCursor.pos())
def contextMenuEvent(self, event):
# print("Right Clicked!", event)
menu = QMenu(self)
menu.addAction(self.loadAudioAction)
menu.addAction(self.extAudioAction)
menu.addAction(self.selectRegion)
menu.addAction(self.remSelection)
menu.exec_(event.globalPos())
def _showItemMenu(self, pos: QPoint):
globalPos = self._list.mapToGlobal(pos)
actions_menu = QMenu()
actions_menu.addAction("Renommer", self._renameItem)
actions_menu.addAction("Supprimer", self._eraseItem)
actions_menu.exec_(globalPos)
def handle_context_menu_event(self, event):
menu = QMenu()
self.add_menu_action(menu, "Copy state", self.copy_states)
self.add_menu_action(menu, "Cut state", self.cut_states)
self.add_menu_action(menu, "Delete state", self.delete_states)
if self.simgr_viewer.state_clipboard:
self.add_menu_action(menu, "Paste state", self.paste_states)
menu.exec_(QCursor.pos())
def contextMenuEvent(self, event: QContextMenuEvent):
item = self.itemAt(event.pos())
if item is not None:
item.handle_context_menu_event(event)
else:
menu = QMenu()
menu.addAction("Create new stash", self._create_new_stash)
menu.exec_(QCursor.pos())
def createStandardContextMenu(self, position):
""" Creates the right-click menu for creating additional exclude expressions. """
menu = QMenu()
self.addExcludeExpressionAction = menu.addAction(
maya.stringTable['y_expressionLabels.kAddExcludeExpression'])
self.addExcludeExpressionAction.triggered.connect(
self.addExcludeExpression)
menu.exec_(self.mapToGlobal(position))
def contextMenuEvent(self, event: QGraphicsSceneContextMenuEvent):
menu = QMenu()
if len(self.bezierEdges):
text = self._tr("BezierNode","BezierNode","解除组合")
lockOnNodeAction = QAction(text)
lockOnNodeAction.triggered.connect(self.do_lockOnNodes)
menu.addAction(lockOnNodeAction)
menu.exec_(QCursor.pos())
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 slotHeaderMenu(self, pt):
menu = QMenu()
menu.addAction("This")
menu.addAction("is")
menu.addAction("just")
menu.addAction("a")
menu.addAction("test")
menu.exec_(pt)
def context_menu(self):
# Menu con click derecho
if self.ui.tabla_db.selectedIndexes() and self.modo_boton_editar_guardar == "guardar":
menu = QMenu()
borrar_data = menu.addAction("Borrar linea de la base de datos")
borrar_data.triggered.connect(lambda: self.borrar_linea(self.ui.tabla_db.currentIndex().row()))
cursor = QCursor()
menu.exec_(cursor.pos())
def show_rightclick_menu(self):
"""
:type self: SteamAccountSwitcherGui
"""
right_menu = QMenu()
selected = self.accounts_list.currentItem()
if not self.accounts_list.selectedItems():
add_account_action = QAction(_("Add account"), self)
add_account_action.triggered.connect(
lambda: self.account_dialog(True))
right_menu.addAction(add_account_action)
right_menu.exec_(QCursor.pos())
return
login_name = selected.data(5)
account = self.switcher.settings["users"].get(login_name, {})
login_action = QAction(_("Login"), self)
edit_action = QAction(_("Edit"), self)
delete_action = QAction(_("Delete"), self)
open_profile_action = QAction(_("Steam profile"), self)
steampage_menu = QMenu(_("Steam profile"), self)
edit_action.setIcon(QIcon.fromTheme("document-edit"))
delete_action.setIcon(QIcon.fromTheme("edit-delete"))
open_profile_action.setIcon(QIcon.fromTheme("internet-web-browser"))
right_menu.addActions([login_action, edit_action, delete_action])
right_menu.addSeparator()
right_menu.addAction(open_profile_action)
right_menu.addMenu(steampage_menu)
login_action.triggered.connect(lambda: self.steam_login(login_name))
edit_action.triggered.connect(lambda: self.account_dialog())
delete_action.triggered.connect(
lambda: self.remove_account(login_name))
open_profile_action.triggered.connect(
lambda: self.open_steam_profile(account))
steampage_menu.triggered.connect(
lambda: self.open_steam_profile(account))
steampage_menu_actions = QActionGroup(steampage_menu)
steampage_menu_inventory = QAction(_('Inventory'),
steampage_menu_actions,
checkable=True,
data="nothing")
open_profile_action.setDisabled(True)
if account.get("steam_user", {}).get("profileurl"):
open_profile_action.setEnabled(True)
steampage_menu.addActions([steampage_menu_inventory])
if self.accounts_list.selectedItems():
right_menu.exec_(QCursor.pos())
def mousePressEvent(self, event: PySide2.QtGui.QMouseEvent) -> None:
super().mousePressEvent(event)
if event.button() == Qt.RightButton:
menu = QMenu()
menu.addAction("Delete", self.delete_layer)
menu.addAction("Edit Layer", self.edit_layer)
if isinstance(self._layer, AnnotationLayer):
menu.addAction("Export .GeoJSON", self.export_path_json)
menu.exec_(event.globalPos())
def __open_menu(self, point):
""" Initializes and shows context menu """
menu = QMenu()
selected_item = self.itemAt(point)
if selected_item:
edit_question = QAction('Редактировать список стоп-слов', menu)
edit_question.triggered.connect(self.__open_stop_word_edit_dialog)
menu.addAction(edit_question)
menu.exec_(self.mapToGlobal(point))
def on_context_menu(self, point):
"""Called when the mouse is right clicked on the remote control."""
menu = QMenu(self)
menu.addAction(self.current_channel)
menu.addSeparator()
menu.addAction(self.select_tivo)
menu.addAction(self.input_text)
menu.addAction(self.change_channel)
menu.exec_(self.mapToGlobal(point))
def right_context_menu(self, pos):
'''
this is the right context menu for listwidget item which you selected
it will call the function below
'''
pop_menu = QMenu()
if self.tableWidgetTimelog.itemAt(pos):
self.show_right_context_menu(pop_menu)
pop_menu.exec_(QCursor.pos())
class TextInput():
def __init__(self, suggestion='', input_valid_callback = None):
self.input_valid_callback = input_valid_callback
self.menu = QMenu()
self.lb = QWidgetAction(None)
self.widget = QWidget(None)
self.layout = QHBoxLayout()
self.button = QPushButton()
self.button.setText("Ok")
self.le = QLineEdit()
self.layout.addWidget(self.le)
self.layout.addWidget(self.button)
self.widget.setLayout(self.layout)
self.button.pressed.connect(self.done)
self.le.textEdited.connect(self.check_input)
self.eventFilter = EnterKeyPressFilter()
self.eventFilter.callback = self.done
self.le.installEventFilter(self.eventFilter)
self.lb.setDefaultWidget(self.widget)
self.menu.addAction(self.lb)
self.le.setText(suggestion)
self.le.setFocus()
self.le.selectAll()
self.result = None
def show(self, pos):
self.menu.exec_(pos)
return self.result
def done(self):
self.result = self.le.text()
self.menu.close()
def check_input(self):
if self.input_valid_callback is not None:
result = self.input_valid_callback(self.le.text())
if result:
self.le.setStyleSheet('')
else:
self.le.setStyleSheet('background: pink')
return None
def _watcher_context_menu(self, pos):
menu = QMenu()
editAction = QAction("Edit", self)
deleteAction = QAction("Delete", self)
if self.watcherlist.itemAt(pos):
menu.addAction(editAction)
menu.addAction(deleteAction)
editAction.triggered.connect(self.edit_watcher)
deleteAction.triggered.connect(self.delete_watcher)
menu.exec_(self.watcherlist.mapToGlobal(pos))
def titleContextMenu(self, event):
menu = QMenu(self)
editAction = QAction('Edit Name')
editAction.triggered.connect(self.promptEditTitle)
removeAction = QAction('Remove Category')
removeAction.triggered.connect(self.removeCategory)
menu.addAction(editAction)
menu.addAction(removeAction)
menu.exec_(QCursor.pos())
def contextMenuEvent(self, event):
menu = QMenu()
actionGroup = QAction('Group', None)
menu.addAction(actionGroup)
actionGroup.triggered.connect(lambda: nodeGroup.groupFromList(self.scene().selectedItems(), grid=self.grid, position=self.scenePos(), parent=self.parentItem()))
actionGroup.setEnabled(len(self.scene().selectedItems()) > 1)
actionReset = QAction('Reset', None)
menu.addAction(actionReset)
actionReset.triggered.connect(lambda: activeNode.resetNodes(self.scene().selectedItems()))
menu.exec_(event.screenPos())
def _create_menu(self, event: QMouseEvent):
context_menu = QMenu(self)
context_menu.addAction("Toggle dark mode", self.set_dark_mode)
context_menu.addAction("Toggle high contrast", self.set_high_contrast)
context_menu.addAction("Generate report", self.save_report)
context_menu.addAction("Send email to...", self.enter_address)
if sys.platform == "win32":
context_menu.addAction("Create shortcut", self.create_shortcut)
context_menu.addAction("Quit Report", self.close)
context_menu.exec_(self.mapToGlobal(event.pos()))
def createHeaderMenus(self):
for headInfo in self.headers:
x = headInfo['x']
x = x - self.position
if self.currPosX > x and self.currPosX < x+self.w and self.currPosY > self.t and self.currPosY < self.h+self.t:
if 0 == self.headers.index(headInfo):
break
self.selectedHeader = headInfo
menu = QMenu()
if headInfo['flagCluster']:
menu.addAction(self.scatterAct)
else:
menu.addAction(self.deleteAct)
menu.addAction(self.groupAct)
menu.exec_(QtGui.QCursor.pos())
def contextMenuEvent(self, event):
i=self.indexAt(event.pos())
#print(self.indexAt(event.pos()))
menu = QMenu(self)
deleteAction = menu.addAction("删除")
pasteAction = menu.addAction("粘贴")
action = menu.exec_(self.mapToGlobal(event.pos()))
if action == deleteAction:
p=self.parent()
while p!=None:
oldp=p
p=p.parent()
oldp.treat_delete(self.model().filePath(i))
elif action == pasteAction:
p=self.parent()
while p!=None:
oldp=p
p=p.parent()
oldp.treat_paste(self.model().filePath(i))
def context_menu_event(self, event):
state = self.state()
context_menu = QMenu()
launch_action = context_menu.addAction("Launch")
launch_action.setEnabled(state == QWebEngineDownloadItem.DownloadCompleted)
show_in_folder_action = context_menu.addAction("Show in Folder")
show_in_folder_action.setEnabled(state == QWebEngineDownloadItem.DownloadCompleted)
cancel_action = context_menu.addAction("Cancel")
cancel_action.setEnabled(state == QWebEngineDownloadItem.DownloadInProgress)
remove_action = context_menu.addAction("Remove")
remove_action.setEnabled(state != QWebEngineDownloadItem.DownloadInProgress)
chosen_action = context_menu.exec_(event.globalPos())
if chosen_action == launch_action:
self._launch()
elif chosen_action == show_in_folder_action:
DownloadWidget.open_file(QFileInfo(self._download_item.path()).absolutePath())
elif chosen_action == cancel_action:
self._download_item.cancel()
elif chosen_action == remove_action:
self.remove_requested.emit()
