def _deleteWidget_(self, widget):
"""
QT Slot to delete a widget from the layout.
Parameter :
- widget : The pysumo widget to delete.
"""
self.widgets.remove(widget.wrappedWidget)
widget.deleteLater()
QMenu = None
widgetType = type(widget.wrappedWidget)
if widgetType == TextEditor:
QMenu = self.menuTextEditorWidgets
elif widgetType == DocumentationWidget:
QMenu = self.menuDocumentationWidgets
elif widgetType == HierarchyWidget:
QMenu = self.menuHierarchyWidgets
elif widgetType == GraphWidget:
QMenu = self.menuGraphWidgets
if QMenu != None and len(QMenu.actions()) == 1:
QMenu.setEnabled(False)
if len(self.menuDelete.actions()) == 1:
self.menuDelete.setEnabled(False)
def tag_context_menu(self, pos):
index = self.ui.tagsList.currentIndex()
item = self.tagsModel.itemFromIndex(index)
if hasattr(item, 'tag'):
menu = QMenu(self.ui.tagsList)
menu.addAction(QIcon.fromTheme('gtk-delete'), self.tr('Remove'), self.remove_tag)
menu.exec_(self.ui.tagsList.mapToGlobal(pos))
def on_show_debug_menu(self):
self.debug_menu.clear()
if self.is_master_cmd or self.power_user:
power_user_mode = QAction('Power User Mode', self)
power_user_mode.setCheckable(True)
power_user_mode.setChecked(MTTSettings.value('powerUser'))
power_user_mode.triggered.connect(self.__on_toggle_power_user)
self.debug_menu.addAction(power_user_mode)
self.is_master_cmd = False
self.debug_menu.addSeparator()
open_pref_folder_action = QAction('Open Preferences Folder', self)
open_pref_folder_action.setStatusTip('Open MTT preference folder')
open_pref_folder_action.triggered.connect(self.on_open_preference_folder)
self.debug_menu.addAction(open_pref_folder_action)
self.debug_menu.addSeparator()
database_dump_csv = QAction('Dump Database as CSV', self)
database_dump_csv.triggered.connect(self.view.model.database_dump_csv)
self.debug_menu.addAction(database_dump_csv)
database_dump_sql = QAction('Dump Database as SQL', self)
database_dump_sql.triggered.connect(self.view.model.database_dump_sql)
self.debug_menu.addAction(database_dump_sql)
self.debug_menu.addSeparator()
support_info = QMenu(self)
support_info.setTitle('Supported Node Type')
support_info.aboutToShow.connect(self.on_show_supported_type)
self.debug_menu.addMenu(support_info)
def __init__(self, parent=None):
"""Initialize Widget."""
super().__init__(parent)
self.setLayout(QVBoxLayout())
self.imglabel = QLabel()
self.imglabel.setBackgroundRole(QPalette.Base)
self.imglabel.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.imglabel.setScaledContents(True) # Resize pixmap along with label
self.imglabel.setAlignment(Qt.AlignCenter)
self.imglabel.setText("(No image yet)")
self.namelabel = QLabel()
self.scrollarea = QScrollArea()
self.scrollarea.setWidget(self.imglabel)
self.scrollarea.setWidgetResizable(False)
self.scrollarea.setAlignment(Qt.AlignCenter)
self.layout().addWidget(self.scrollarea)
self.layout().addWidget(self.namelabel)
self.scale_factor = 1.0
self._initial_size = QSize(0, 0)
self._img_path = ""
self.setContextMenuPolicy(Qt.CustomContextMenu)
# pylint: disable=no-member
self.customContextMenuRequested.connect(self.show_context_menu)
self.menu = QMenu()
self.add_actions_to_menu(self.menu)
def popup_menu(self, position):
selected_row = self.view.rowAt(position.y())
if selected_row >= 0 and self._used_categories and len(
self._used_categories) > 1:
category_menu = QMenu(_("Categories"))
selected_doc = self.model.object_at(selected_row)
category_actions = []
for category in self._used_categories:
a = QAction(category.full_name, category_menu)
a.setData(category)
a.setEnabled(selected_doc.document_category_id !=
category.document_category_id)
category_menu.addAction(a)
category_actions.append(a)
action = category_menu.exec_(QCursor.pos())
if action:
new_category = action.data()
if selected_doc.document_category_id != new_category.document_category_id:
selected_doc.document_category_id = new_category.document_category_id
self.model.signal_object_change(selected_doc)
def showContextMenu(self, point):
'Show the Columns context menu'
if self.model() is None:
return
# If we are viewing a proxy model, skip to the source model
mdl = self.model()
while isinstance(mdl, QAbstractProxyModel):
mdl = mdl.sourceModel()
if mdl is None or not hasattr(mdl, 'columns'):
return
# Generate and show the Menu
m = QMenu()
for i in range(len(mdl.columns)):
c = mdl.columns[i]
if c.internal:
continue
a = QAction(mdl.headerData(i, Qt.Horizontal, Qt.DisplayRole), m)
a.setCheckable(True)
a.setChecked(not self.isColumnHidden(i))
a.triggered.connect(partial(self.showHideColumn, c=i, s=self.isColumnHidden(i)))
m.addAction(a)
m.exec_(self.header().mapToGlobal(point))
def _create_instance_menu(self):
self.instance_menu = QMenu(self)
self.instance_menu.setTitle('Prompt Instance Delay')
self.instance_menu.aboutToShow.connect(
self.on_show_prompt_instance_delay_menu)
return self.instance_menu
def on_show_debug_menu(self):
self.debug_menu.clear()
if self.is_master_cmd or self.power_user:
power_user_mode = QAction('Power User Mode', self)
power_user_mode.setCheckable(True)
power_user_mode.setChecked(MTTSettings.value('powerUser'))
power_user_mode.triggered.connect(self.__on_toggle_power_user)
self.debug_menu.addAction(power_user_mode)
self.is_master_cmd = False
self.debug_menu.addSeparator()
open_pref_folder_action = QAction('Open Preferences Folder', self)
open_pref_folder_action.setStatusTip('Open MTT preference folder')
open_pref_folder_action.triggered.connect(
self.on_open_preference_folder)
self.debug_menu.addAction(open_pref_folder_action)
self.debug_menu.addSeparator()
database_dump_csv = QAction('Dump Database as CSV', self)
database_dump_csv.triggered.connect(self.view.model.database_dump_csv)
self.debug_menu.addAction(database_dump_csv)
database_dump_sql = QAction('Dump Database as SQL', self)
database_dump_sql.triggered.connect(self.view.model.database_dump_sql)
self.debug_menu.addAction(database_dump_sql)
self.debug_menu.addSeparator()
support_info = QMenu(self)
support_info.setTitle('Supported Node Type')
support_info.aboutToShow.connect(self.on_show_supported_type)
self.debug_menu.addMenu(support_info)
def click(self, res, event):
"""Open resource"""
button = event.button()
if button == Qt.LeftButton:
subprocess.Popen(['xdg-open', res.file_path])
elif button == Qt.RightButton:
menu = QMenu(self.parent)
menu.addAction(
self.app.translate('ResourceEdit', 'Put to Content'),
Slot()(partial(
self.to_content,
res=res,
)),
)
if not self.parent.note_edit.in_content(res):
menu.addAction(
self.app.translate('ResourceEdit', 'Remove Resource'),
Slot()(partial(
self.remove,
res=res,
)))
menu.addAction(self.app.translate('ResourceEdit', 'Save As'),
Slot()(partial(
self.save,
res=res,
)))
menu.exec_(event.globalPos())
def createVersionEveryWhereMenuForView(self, view):
versionEverywhereMenu = QMenu(self.actionTitle)
self._versionActions = []
# We look to the activeView for a selection of Clips
clips = self.clipSelectionFromView(view)
# And bail if nothing is found
if len(clips)==0:
return versionEverywhereMenu
# Now, if we have just one Clip selected, we'll form a special menu, which lists all versions
if len(clips)==1:
# Get a reversed list of Versions, so that bigger ones appear at top
versions = list(reversed(clips[0].binItem().items()))
for version in versions:
self._versionActions+=[self.makeVersionActionForSingleClip(version)]
elif len(clips)>1:
# We will add Max/Min/Prev/Next options, which can be called on a TrackItem, without the need for a Version object
self._versionActions+=[self.makeAction(self.eMaxVersion,self.setTrackItemVersionForClipSelection, icon=None)]
self._versionActions+=[self.makeAction(self.eMinVersion,self.setTrackItemVersionForClipSelection, icon=None)]
self._versionActions+=[self.makeAction(self.eNextVersion,self.setTrackItemVersionForClipSelection, icon=None)]
self._versionActions+=[self.makeAction(self.ePreviousVersion,self.setTrackItemVersionForClipSelection, icon=None)]
for act in self._versionActions:
versionEverywhereMenu.addAction(act)
return versionEverywhereMenu
def init_notebooks(self):
frame = QFrame()
layout = QVBoxLayout()
frame.setLayout(layout)
self.ui.scrollArea.setWidget(frame)
for notebook_struct in self.app.provider.list_notebooks():
notebook = Notebook.from_tuple(notebook_struct)
count = self.app.provider.get_notebook_notes_count(notebook.id)
widget = QWidget()
menu = QMenu(self)
menu.addAction(self.tr('Change Name'), Slot()(partial(
self.change_notebook, notebook=notebook,
)))
action = menu.addAction(self.tr('Remove Notebook'), Slot()(partial(
self.remove_notebook, notebook=notebook,
)))
action.setEnabled(False)
widget.ui = Ui_Notebook()
widget.ui.setupUi(widget)
widget.ui.name.setText(notebook.name)
widget.ui.content.setText(self.tr('Containts %d notes') % count)
widget.ui.actionBtn.setIcon(QIcon.fromTheme('gtk-properties'))
widget.setFixedHeight(50)
layout.addWidget(widget)
widget.ui.actionBtn.clicked.connect(Slot()(partial(
self.show_notebook_menu,
menu=menu, widget=widget,
)))
def __init__(self,prozor):
QMenuBar.__init__(self)
self.prozor=prozor
menuBarActions.menuBarActions.mBarActions(self)
#File
self.fileMenu = QMenu()
self.fileMenu.setTitle("File")
self.fileMenu.addAction(self.newFileAction)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.openFileAction)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.saveAction)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.saveAsAction)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.exitProgramAction)
self.addMenu(self.fileMenu)
#Edit
self.editMenu=QMenu()
self.editMenu.setTitle("Edit")
self.editMenu.addAction(self.undoAction)
self.fileMenu.addSeparator()
self.editMenu.addAction(self.redoAction)
self.fileMenu.addSeparator()
self.editMenu.addAction(self.cutAction)
self.fileMenu.addSeparator()
self.editMenu.addAction(self.copyAction)
self.fileMenu.addSeparator()
self.editMenu.addAction(self.pasteAction)
self.fileMenu.addSeparator()
self.addMenu(self.editMenu)
self.addAction(self.optionsAction)
def showContextMenu(self, pos):
"""
Shows a context menu to add a node in the graph widget
"""
gpos = self.graphicsView.mapToGlobal(pos)
menu = QMenu()
actionAddNode = menu.addAction("Add Node")
QAction = menu.exec_(gpos)
if (actionAddNode == QAction):
(text,
ok) = QInputDialog.getText(self.graphicsView, "Insert Node Name",
"Please insert a name for the node")
if ok:
if text not in self.nodesToQNodes:
#User clicked on ok. Otherwise do nothing
self.gv.add_node(text)
node = self.gv.get_node(text)
qnode = self.createQtNode(node, 0, 0,
QColor(204, 255, 255))
self.graphicsView.scene().addItem(qnode)
qnode.setPos(self.graphicsView.mapToScene(gpos))
qnode.setPos(qnode.x(), qnode.y() - 200)
self.nodesToQNodes[node] = qnode
else:
msg = QMessageBox()
msg.setText("The node already exists.")
msg.exec_()
self.searchNode(text)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.current_profileid = ""
self.setupUi(self)
self.logger = get_logger('desuratools', 'desuratools.log')
self.logger.info('Logger Created')
boldfont = QApplication.font()
boldfont.setBold(True)
self.addToSteam_action = self.action_factory("Add to Steam", self.add_to_steam)
self.addToSteam_action.setFont(boldfont)
self.installGame_action = self.action_factory("Install", self.install_game)
self.installGame_action.setFont(boldfont)
self.desuraPage_action = self.action_factory("View Profile", self.open_desura_page)
self.uninstallGame_action = self.action_factory("Uninstall", self.uninstall_game)
self.verifyGame_action = self.action_factory("Verify", self.verify_game)
self.ownedGames_menu = QMenu(self)
self.ownedGames_menu.addActions([
self.installGame_action,
self.desuraPage_action
])
self.installedGames_menu = QMenu(self)
self.installedGames_menu.addActions([
self.addToSteam_action,
self.desuraPage_action,
self.uninstallGame_action,
self.verifyGame_action
])
self.selectAllButton.clicked.connect(self.select_all_games)
self.desuraAccountName_verify.clicked.connect(self.populate_owned_games)
self.installButton.clicked.connect(self.process_install_button)
self.generateDesuraReport_action.activated.connect(self.generate_report)
self.tabWidget.currentChanged.connect(self.swap_tabs)
self.ownedGames_list.itemSelectionChanged.connect(self.update_gameinfo)
self.installedGames_list.itemSelectionChanged.connect(self.update_gameinfo)
self.refreshButton.clicked.connect(self.refresh_list)
self.refreshLists_action.activated.connect(self.refresh_all)
self.installedGames_list.customContextMenuRequested.connect(self.show_game_context)
self.installedGames_list.doubleClicked.connect(self.add_to_steam)
self.installedGames_list.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.ownedGames_list.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.steamID_input.addItems(steamutils.get_customurls_on_machine())
self.ownedGames_list.addItem("Verify your Desura username to see your owned games")
QApplication.processEvents()
self.loading_dialog = ProgressBarDialog()
self.loading_dialog.show()
QApplication.processEvents()
self.populate_installed_games()
self.load_data()
self.loading_dialog.close()
self.raise_()
def popup(self,pos):
menu = QMenu()
saveRepAction = QAction(self)
saveRepAction.setText('Save representation...')
saveRepAction.triggered.connect(lambda: self.saveRep(self.indexAt(pos)))
menu.addAction(saveRepAction)
action = menu.exec_(self.mapToGlobal(pos))
def __init__(self, app, *args, **kwargs):
QSystemTrayIcon.__init__(self, *args, **kwargs)
self.app = app
self.menu = QMenu()
self.setContextMenu(self.menu)
self.menu.aboutToShow.connect(self.update)
self.opened_notes = {}
self.activated.connect(self._activated)
def __init__(self, *args, **kwargs):
QSystemTrayIcon.__init__(self, *args, **kwargs)
self.app = QApplication.instance()
self.menu = QMenu()
self.setContextMenu(self.menu)
self.menu.aboutToShow.connect(self.update)
self.opened_notes = {}
self.activated.connect(self._activated)
self.settings = QSettings('everpad', 'everpad-pad')
def _setupContextMenu(self):
from visualscrape.lib.data import ActionStore
context_menu = QMenu(self)
export_action = NamedAction(self.tr("Export ..."), self, name="export")
export_action.triggered.connect(self._requestTabExport)
context_menu.addAction(export_action)
self.setTabBar(ContextMenuTabBar(context_menu))
action_store = ActionStore.get_instance()
action_store.register_action(export_action)
def sort_menu(self):
sort_by=QMenu("Sort By")
sort_by.setIcon( QIcon(appicon("default_menu")) )
sorting=["Year","Title","Oldest","Newest","My Rating","IMDb Rating","ASC","DESC"]
for i in sorting:
k=SortbyAction(i,self)
k.triggered.connect(self.click_event)
sort_by.addAction(k)
return sort_by
def mousePressEvent(self, mouse_event):
if mouse_event.button() == Qt.RightButton:
if self._spec_index is None:
print("spec_index is None")
print(self)
print(self._running_providers)
return
pos = mouse_event.pos()
items = [
item for item in self.items(pos)
if isinstance(item, NodeItem) and item._label.text()
]
if len(items) != 1:
print("wrong number of things",
[x._label.text() for x in items])
return
name = items[0]._label.text().rstrip('(default)').strip()
if name not in self._spec_index.provider_names:
print(name, "Not in list of providers")
return
provider = self._spec_index.providers[name]
def start_trigger():
# TODO: replace 'capability_server' with user provided server name
service_name = '/{0}/start_capability'.format(
'capability_server')
rospy.wait_for_service(service_name)
start_capability = rospy.ServiceProxy(service_name,
StartCapability)
start_capability(provider.implements, name)
def stop_trigger():
# TODO: replace 'capability_server' with user provided server name
service_name = '/{0}/stop_capability'.format(
'capability_server')
rospy.wait_for_service(service_name)
stop_capability = rospy.ServiceProxy(service_name,
StopCapability)
stop_capability(provider.implements)
if name not in self._running_providers:
trigger = start_trigger
msg = "start => "
else:
trigger = stop_trigger
msg = "stop => "
menu = QMenu()
action = menu.addAction(msg + name)
action.triggered.connect(trigger)
pos = mouse_event.globalPos()
pos = QPoint(pos.x(), pos.y())
menu.exec_(pos)
else:
InteractiveGraphicsView.mousePressEvent(self, mouse_event)
def __LobbyListMenu( self, position ):
lobby_menu = QMenu()
rm_from_lobby = QAction( self )
rm_from_lobby.setText( "Remove player from lobby" )
rm_from_lobby.triggered.connect( self._RemoveFromLobbyListAction )
lobby_menu.addAction( rm_from_lobby )
lobby_menu.exec_( self.window.lobby_lst.viewport().mapToGlobal( position ) )
def testMenu(self):
self._actionDestroyed = False
w = QWidget()
menu = QMenu(w)
act = menu.addAction("MENU")
_ref = weakref.ref(act, self.actionDestroyed)
act = None
self.assertFalse(self._actionDestroyed)
menu.clear()
self.assertTrue(self._actionDestroyed)
def testMenu(self):
self._actionDestroyed = False
w = QWidget()
menu = QMenu(w)
act = menu.addAction("MENU")
_ref = weakref.ref(act, self.actionDestroyed)
act = None
self.assertFalse(self._actionDestroyed)
menu.clear()
self.assertTrue(self._actionDestroyed)
def _setupContextMenu(self):
from visualscrape.lib.data import ActionStore
self._context_menu = QMenu(self)
# get the export action from the action store
action_store = ActionStore.get_instance()
for action in action_store:
if action.get_name() == "export":
export_action = action
break
self._context_menu.addAction(export_action)
def click(self, res, event):
"""Open resource"""
button = event.button()
if button == Qt.LeftButton:
subprocess.Popen(['xdg-open', res.file_path])
elif button == Qt.RightButton:
menu = QMenu(self.parent)
if res.mime.find('image') == 0:
menu.addAction(
self.parent.tr('Put to Content'), Slot()(partial(
self.to_content, res=res,
)),
)
if not self.parent.note_edit.in_content(res):
menu.addAction(
self.parent.tr('Remove Resource'), Slot()(partial(
self.remove, res=res,
))
)
menu.addAction(
self.parent.tr('Save As'), Slot()(partial(
self.save, res=res,
))
)
menu.exec_(event.globalPos())
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
# activate the window and use the full screen
self.setWindowState(Qt.WindowFullScreen | Qt.WindowActive)
# empty the mouse cursor
self.setCursor(Qt.BlankCursor)
# add a menu to close the window
appmenu = QMenu('&Application', self)
quit = QAction('&Quit', self)
appmenu.addAction(quit)
self.menuBar().addMenu(appmenu)
quit.triggered.connect(QApplication.instance().quit)
def __init__(self, parent=None):
self.color = QColor(0, 0, 0)
super().__init__(parent)
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
dial = QColorDial(self)
dial.sliderMoved.connect(self.set_color)
action = QWidgetAction(self)
action.setDefaultWidget(dial)
self.menu = QMenu()
self.menu.addAction(action)
def __init__(self, parent=None):
QMenu.__init__(self, "&Signals")
self.parent = parent
self.addSignalAction = self.addAction(self.trUtf8("&Add Signal"))
self.addSignalAction.triggered.connect(self.addSignal)
self.addSignalAction.setEnabled(False)
self.applyOperationAction = self.addAction(self.trUtf8("&Apply Operation"))
self.applyOperationAction.triggered.connect(self.applyOperation)
self.applyOperationAction.setEnabled(False)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
# activate the window and use the full screen
self.setWindowState(Qt.WindowFullScreen | Qt.WindowActive)
# empty the mouse cursor
self.setCursor(Qt.BlankCursor)
# add a menu to close the window
appmenu = QMenu('&Application', self)
quit = QAction('&Quit', self)
appmenu.addAction(quit)
self.menuBar().addMenu(appmenu)
quit.triggered.connect(QApplication.instance().quit)
def __init__(self):
self._menu = QMenu("Clean Project")
self._removeUnusedAction = createMenuAction("Remove Unused Clips",
self.removeUnusedClips)
self._removeOfflineMediaAction = createMenuAction(
"Remove Offline Media", self.removeOfflineClips)
self._removeEmptyBinsAction = createMenuAction(
"Remove Empty Bins", self.removeEmptyBinsAction)
self._menu.addAction(self._removeUnusedAction)
self._menu.addAction(self._removeOfflineMediaAction)
self._menu.addAction(self._removeEmptyBinsAction)
hiero.core.events.registerInterest("kShowContextMenu/kBin",
self.eventHandler)
def __init__(self, p_def):
"""
:param p_def: [{NAME:..., STR:...}, ...]
:return:
"""
QMenu.__init__(self)
for _def in p_def:
_act = QAction(_def["NAME"], self)
_act.triggered.connect(partial(self.menu_emit, _def["STR"]))
self.addAction(_act)
def __init__( self, parent ):
QMenu.__init__( self, parent )
# add actions and a separator
hello = self.addAction("Print 'Hello!'")
self.addSeparator()
world = self.addAction("Print 'World!'")
# connect to the individual action's signal
hello.triggered.connect( self.hello )
world.triggered.connect( self.world )
# connect to the menu level signal
self.triggered.connect( self.menuTrigger )
def __menu(self, pos):
u"""Slot d'apparition du menu contextuel"""
menu = QMenu()
menu.addAction("Supprimer", self, SLOT("supprimer()"),
QKeySequence.Delete)
menu.addAction("Nouveau", self, SLOT("nouveau()"), QKeySequence.New)
menu.exec_(self._ui.tv.mapToGlobal(pos))
def note_context_menu(self, pos):
menu = QMenu(self.ui.notesList)
menu.addAction(QIcon.fromTheme('gtk-edit'), self.tr('Edit'),
self.edit_note)
menu.addAction(QIcon.fromTheme('gtk-delete'), self.tr('Remove'),
self.remove_note)
menu.exec_(self.ui.notesList.mapToGlobal(pos))
def send_to_popup(self):
drive_option=QMenu(self.parent())
opts=config.SEND_TO[0:(len(config.SEND_TO)-1)]
for cnf in opts:
k=QAction(QIcon(appicon("explore")),cnf,self )
k.triggered.connect(self.click_event)
drive_option.addAction(k)
drive_option.exec_(QtGui.QCursor.pos())
def __init__(self):
QMenu.__init__(self, "Set Status", None)
global gStatusTags
# ant: Could use hiero.core.defaultFrameRates() here but messes up with string matching because we seem to mix decimal points
self.statuses = gStatusTags
self._statusActions = self.createStatusMenuActions()
# Add the Actions to the Menu.
for act in self.menuActions:
self.addAction(act)
hiero.core.events.registerInterest("kShowContextMenu/kTimeline", self.eventHandler)
hiero.core.events.registerInterest("kShowContextMenu/kSpreadsheet", self.eventHandler)
def setup_ui(self):
""" Setup the UI for the window.
"""
central_widget = QWidget()
layout = QVBoxLayout()
layout.addWidget(self.clock_view)
layout.addWidget(self.message_view)
central_widget.setLayout(layout)
self.setCentralWidget(central_widget)
menubar = self.menuBar()
file_menu = QMenu('File')
preferences_action = QAction('Preferences', file_menu)
preferences_action.triggered.connect(self.on_preferences_triggered)
quit_action = QAction('Quit', file_menu)
quit_action.triggered.connect(self.on_quit_triggered)
file_menu.addAction(preferences_action)
file_menu.addAction(quit_action)
menubar.addMenu(file_menu)
view_menu = QMenu('View')
fullscreen_action = QAction('Fullscreen', view_menu)
fullscreen_action.setCheckable(True)
fullscreen_action.setChecked(Config.get('FULLSCREEN', True))
fullscreen_action.setShortcut('Ctrl+Meta+F')
fullscreen_action.toggled.connect(self.on_fullscreen_changed)
view_menu.addAction(fullscreen_action)
menubar.addMenu(view_menu)
def __init__(self, repo, selected_items, parent=None):
super(CommitDialog, self).__init__(parent=parent)
self.repo = repo
self.dialog_buttons.button(QDialogButtonBox.Ok).setEnabled(False)
self.selected_items = selected_items
if len(selected_items) == 1 and isinstance(selected_items[0],
WorkspaceDirectory):
self.root_dir = selected_items[0]
else:
self.root_dir = None
fixed_font = QFont('Courier', self.message_text.font().pointSize())
fixed_font.setStyleHint(QFont.Monospace)
self.message_text.setFont(fixed_font)
self.text_pos_label.setFont(fixed_font)
with busy_cursor():
self.staged_changes_model = StagedChangesModel(repo, self.root_dir,
parent=self)
self.local_changes_model = LocalChangesModel(repo.workspace,
parent=self)
self.local_changes_model.file_source = lambda: tuple(deep_item
for selected_item in selected_items
for deep_item in deep_file_list(selected_item)
if exclude_unmodified(deep_item) and exclude_ignored(deep_item))
if self.root_dir:
self.staged_changes_button.setChecked(True)
self.show_staged_changes()
else:
self.local_changes_button.setChecked(True)
self.show_local_changes()
if self.repo.head_ref:
(self.last_commit,) = self.repo.log(max_commits=1)
else:
self.last_commit = None
self.action_reuse_last_msg.setEnabled(False)
self.action_reuse_log_msg.setEnabled(False)
self.amend_checkbox.setEnabled(False)
self.staged_changes_button.clicked.connect(self.show_staged_changes)
self.local_changes_button.clicked.connect(self.show_local_changes)
self.local_changes_model.dataChanged.connect(self.local_change_toggled)
self.message_text.cursorPositionChanged.connect(self.text_pos_changed)
self.message_text.textChanged.connect(self.message_text_changed)
reuse_menu = QMenu()
reuse_menu.addAction(self.action_reuse_last_msg)
reuse_menu.addAction(self.action_reuse_log_msg)
self.reuse_msg_button.setDefaultAction(self.action_reuse_last_msg)
self.reuse_msg_button.setMenu(reuse_menu)
self.action_reuse_last_msg.triggered.connect(self.reuse_last_message)
self.action_reuse_log_msg.triggered.connect(self.select_old_message)
self.amend_checkbox.toggled.connect(self.amend_toggled)
def __init__(self, parent=None):
icon = self.loadIcon()
QSystemTrayIcon.__init__(self, icon, parent)
menu = QMenu(parent)
VBoxMenu.build(menu)
menu.addSeparator()
menu.addAction("Exit", lambda: sys.exit(0))
self.connect(menu, SIGNAL("aboutToShow()"), VBoxMenu.check_state)
self.setContextMenu(menu)
self.setToolTip("VBoxTrayIco")
traySignal = "activated(QSystemTrayIcon::ActivationReason)"
QObject.connect(self, SIGNAL(traySignal), self.showMenu)
def __init__(self, app, hub, debug=False):
BaseWebUI.__init__(self, "index.html", app, hub, debug)
self.html = index.html
self.agent = '%s v%s' % (USER_AGENT, '.'.join(str(v) for v in VERSION))
log("Starting [%s]..." % self.agent, LEVEL_INFO)
# Setup the system tray icon
if sys.platform == 'darwin':
tray_icon = 'evominer_16x16_mac.png'
elif sys.platform == "win32":
tray_icon = 'evominer_16x16.png'
else:
tray_icon = 'evominer_32x32_ubuntu.png'
self.trayIcon = QSystemTrayIcon(self._getQIcon(tray_icon))
self.trayIcon.setToolTip(tray_icon_tooltip)
# Setup the tray icon context menu
self.trayMenu = QMenu()
self.showAppAction = QAction('&Show %s' % APP_NAME, self)
f = self.showAppAction.font()
f.setBold(True)
self.showAppAction.setFont(f)
self.trayMenu.addAction(self.showAppAction)
self.aboutAction = QAction('&About...', self)
self.trayMenu.addAction(self.aboutAction)
self.trayMenu.addSeparator()
self.exitAction = QAction('&Exit', self)
self.trayMenu.addAction(self.exitAction)
# Add menu to tray icon
self.trayIcon.setContextMenu(self.trayMenu)
# connect signals
self.trayIcon.activated.connect(self._handleTrayIconActivate)
self.exitAction.triggered.connect(self.handleExitAction)
self.aboutAction.triggered.connect(self.handleAboutAction)
self.showAppAction.triggered.connect(self._handleShowAppAction)
self.app.aboutToQuit.connect(self._handleAboutToQuit)
# Setup notification support
self.system_tray_running_notified = False
self.notifier = Notify(APP_NAME)
self.trayIcon.show()
def mousePressEvent(self, mouse_event):
if mouse_event.button() == Qt.RightButton:
if self._spec_index is None:
print("spec_index is None")
print(self)
print(self._running_providers)
return
pos = mouse_event.pos()
items = [item for item in self.items(pos) if isinstance(item, NodeItem) and item._label.text()]
if len(items) != 1:
print("wrong number of things", [x._label.text() for x in items])
return
name = items[0]._label.text().rstrip('(default)').strip()
if name not in self._spec_index.provider_names:
print(name, "Not in list of providers")
return
provider = self._spec_index.providers[name]
def start_trigger():
# TODO: replace 'capability_server' with user provided server name
service_name = '/{0}/start_capability'.format('capability_server')
rospy.wait_for_service(service_name)
start_capability = rospy.ServiceProxy(service_name, StartCapability)
start_capability(provider.implements, name)
def stop_trigger():
# TODO: replace 'capability_server' with user provided server name
service_name = '/{0}/stop_capability'.format('capability_server')
rospy.wait_for_service(service_name)
stop_capability = rospy.ServiceProxy(service_name, StopCapability)
stop_capability(provider.implements)
if name not in self._running_providers:
trigger = start_trigger
msg = "start => "
else:
trigger = stop_trigger
msg = "stop => "
menu = QMenu()
action = menu.addAction(msg + name)
action.triggered.connect(trigger)
pos = mouse_event.globalPos()
pos = QPoint(pos.x(), pos.y())
menu.exec_(pos)
else:
InteractiveGraphicsView.mousePressEvent(self, mouse_event)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
layout = QVBoxLayout(self)
horiz_layout = QHBoxLayout()
self.conditional_legend_widget = EdgeWidget(self, True)
self.conditional_legend_widget.setMinimumHeight(15)
horiz_layout.addWidget(self.conditional_legend_widget)
self.conditional_legend_label = QLabel("Conditional transition", self)
horiz_layout.addWidget(self.conditional_legend_label)
self.unconditional_legend_widget = EdgeWidget(self, False)
self.unconditional_legend_widget.setMinimumHeight(15)
horiz_layout.addWidget(self.unconditional_legend_widget)
self.unconditional_legend_label = QLabel("Non-conditional transition",
self)
horiz_layout.addWidget(self.unconditional_legend_label)
layout.addLayout(horiz_layout)
self.splitter = QSplitter(self)
layout.addWidget(self.splitter)
self.view = ClassyView(self.splitter)
# layout.addWidget(self.view)
self.scene = ClassyScene(self)
self.view.setScene(self.scene)
self._menu_bar = QMenuBar(self)
self._menu = QMenu("&File")
self._menu_bar.addMenu(self._menu)
layout.setMenuBar(self._menu_bar)
self.open_action = QAction("O&pen", self)
self.exit_action = QAction("E&xit", self)
self._menu.addAction(self.open_action)
self._menu.addAction(self.exit_action)
self.connect(self.open_action, SIGNAL("triggered()"), self.open_file)
self.connect(self.exit_action, SIGNAL("triggered()"), self.close)
self.settings = QSettings("CD Projekt RED", "TweakDB")
self.log_window = QPlainTextEdit(self.splitter)
self.splitter.setOrientation(Qt.Vertical)
self.setWindowTitle("Classy nodes")
class HierarchyTreeView(QTreeView):
def __init__(self):
super(HierarchyTreeView, self).__init__()
#ukljucuje kontekstni meni
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.openMenu)
def openMenu(self, position):
self.contextMenu = QMenu()
newMenu = QMenu("New")
self.contextMenu.addMenu(newMenu)
actionNewProj = QAction("NewProject", None)
actionNewProj.triggered.connect(self.addNode)
actionRename = QAction("Rename", None)
actionRename.triggered.connect(self.renameNode)
actionRemProj = QAction("Delete", None)
actionRemProj.triggered.connect(self.removeNode)
newMenu.addAction(actionNewProj)
self.contextMenu.addAction(actionRename)
self.contextMenu.addAction(actionRemProj)
#prikaz kontekstnog menija
self.contextMenu.exec_(self.viewport().mapToGlobal(position))
def addNode(self):
model = self.model()
node = Node("NoviCvor")
if not self.currentIndex().isValid():
model.insertRow(model.rowCount(self.currentIndex()), node)
else:
model.insertRow(model.rowCount(self.currentIndex()), node, self.currentIndex())
self.expand(self.currentIndex())
def removeNode(self):
model = self.model()
model.removeRow(self.currentIndex().internalPointer().getIndex(), self.currentIndex().parent())
def renameNode(self):
self.currentIndex().internalPointer().setName("NOVO")
def mousePressEvent(self, event):
if(self.selectionMode() == QAbstractItemView.SingleSelection):
self.clearSelection()
self.setCurrentIndex(QModelIndex())
super(HierarchyTreeView, self).mousePressEvent(event)
def _create_instance_menu(self):
self.instance_menu = QMenu(self)
self.instance_menu.setTitle('Prompt Instance Delay')
self.instance_menu.aboutToShow.connect(
self.on_show_prompt_instance_delay_menu)
return self.instance_menu
def create_size_menu(self):
""" Create the toolbar's buttons size menu
"""
menu = QMenu(self)
group = QActionGroup(self)
sizes = (_("Tiny"), 16), (_("Small"), 32), (_("Medium"),
48), (_("Big"), 64)
for name, size in sizes:
action = QAction(name, menu)
action.setCheckable(True)
if size == self.base.toolbar_size:
action.setChecked(True)
action.triggered.connect(partial(self.set_btn_size, size))
group.addAction(action)
menu.addAction(action)
return menu
def __init__(self, app, *args, **kwargs):
QSystemTrayIcon.__init__(self, *args, **kwargs)
self.app = app
self.menu = QMenu()
self.setContextMenu(self.menu)
self.menu.aboutToShow.connect(self.update)
self.opened_notes = {}
def __init__(self):
QMenu.__init__(self, "Set Status", None)
global gStatusTags
# ant: Could use hiero.core.defaultFrameRates() here but messes up with string matching because we seem to mix decimal points
self.statuses = gStatusTags
self._statusActions = self.createStatusMenuActions()
# Add the Actions to the Menu.
for act in self.menuActions:
self.addAction(act)
hiero.core.events.registerInterest("kShowContextMenu/kTimeline",
self.eventHandler)
hiero.core.events.registerInterest("kShowContextMenu/kSpreadsheet",
self.eventHandler)
def create_menus(self):
self.toolbar = self.addToolBar("Edit")
self.toolbar.addAction(self.open_action)
self.toolbar.addAction(self.save_action)
for action in [a for a in self.plugin_actions if a.icon()]:
self.toolbar.addAction(action)
self.toolbar.addAction(self.zoom_in_action)
self.toolbar.addAction(self.zoom_out_action)
self.toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.fileMenu = QMenu("&File", self)
self.fileMenu.addAction(self.open_action)
self.fileMenu.addAction(self.save_action)
self.fileMenu.addAction(self.save_crops_action)
self.fileMenu.addAction(self.export_csv_action)
self.fileMenu.addAction(self.close_action)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.exit_action)
self.editMenu = QMenu("&Edit", self)
self.editMenu.addAction(self.select_all_action)
self.editMenu.addAction(self.select_none_action)
self.editMenu.addAction(self.delete_action)
self.editMenu.addSeparator()
self.editMenu.addAction(self.next_box_action)
self.editMenu.addAction(self.previous_box_action)
self.editMenu.addSeparator()
self.editMenu.addAction(self.rotate_clockwise_action)
self.editMenu.addAction(self.rotate_counter_clockwise_action)
self.editMenu.addSeparator()
for action in self.plugin_actions:
self.editMenu.addAction(action)
self.viewMenu = QMenu("&View", self)
self.viewMenu.addAction(self.boxes_view_action)
self.viewMenu.addAction(self.metadata_view_action)
self.viewMenu.addSeparator()
self.viewMenu.addAction(self.full_screen_action)
self.viewMenu.addSeparator()
self.viewMenu.addAction(self.zoom_in_action)
self.viewMenu.addAction(self.zoom_out_action)
self.viewMenu.addAction(self.toogle_zoom_action)
self.viewMenu.addAction(self.zoom_home_action)
self.viewMenu.addAction(self.toggle_plugin_image_action)
self.viewMenu.addSeparator()
self.viewMenu.addAction(self.show_specimen_grid_action)
self.viewMenu.addAction(self.show_specimen_expanded_action)
self.helpMenu = QMenu("&Help", self)
self.helpMenu.addAction(self.help_action)
self.helpMenu.addAction(self.about_action)
self.menuBar().addMenu(self.fileMenu)
self.menuBar().addMenu(self.editMenu)
self.menuBar().addMenu(self.viewMenu)
self.menuBar().addMenu(self.helpMenu)
def __init__(self, *args, **kwargs):
QSystemTrayIcon.__init__(self, *args, **kwargs)
self.app = QApplication.instance()
self.menu = QMenu()
self.setContextMenu(self.menu)
self.menu.aboutToShow.connect(self.update)
self.opened_notes = {}
self.activated.connect(self._activated)
def __init__(self, parent=None):
QMenu.__init__(self, "&Files")
self.parent = parent
newProjectAction = self.addAction(self.trUtf8("&New Project"))
newProjectAction.triggered.connect(self.createNewProject)
openProjectAction = self.addAction(self.trUtf8("&Open Project"))
openProjectAction.triggered.connect(self.openProject)
self.saveProjectAction = self.addAction(self.trUtf8("&Save Project"))
self.saveProjectAction.triggered.connect(self.saveProject)
self.saveProjectAction.setEnabled(False)
quitAction = self.addAction(self.trUtf8("&Quit Program"))
quitAction.triggered.connect(self.parent.close)
def notebook_context_menu(self, pos):
index = self.ui.notebooksList.currentIndex()
item = self.notebooksModel.itemFromIndex(index)
if hasattr(item, 'notebook'):
menu = QMenu(self.ui.notebooksList)
menu.addAction(QIcon.fromTheme('gtk-edit'), self.tr('Rename'),
self.rename_notebook)
menu.addAction(QIcon.fromTheme('gtk-delete'), self.tr('Remove'),
self.remove_notebook)
menu.exec_(self.ui.notebooksList.mapToGlobal(pos))
def qmenu(self):
if self._qmenu is not None:
return self._qmenu
if self.parent is not None:
menu = QMenu(self.caption, self.parent)
else:
menu = QMenu(self.caption)
for entry in self.entries:
if isinstance(entry, MenuEntry):
action = menu.addAction(entry.caption, entry.action) # type: QAction
if entry.shortcut is not None:
action.setShortcut(entry.shortcut)
if entry.checkable:
action.setCheckable(True)
action.setChecked(entry.checked_initially)
entry.qaction = action
elif isinstance(entry, MenuSeparator):
menu.addSeparator()
else:
raise Exception('Unsupported type %s' % type(entry))
self._qmenu = menu
return menu
def _tree_customContextMenuRequesssted(self, pos):
idx = self.tv.indexAt(pos)
if not idx.isValid():
return
addr = idx.data(role=self.ADDR_ROLE)
if not addr:
return
name_idx = idx.sibling(idx.row(), 1)
old_name = name_idx.data()
menu = QMenu()
rename_action = menu.addAction('Rename `%s`...' % old_name)
rename_action.setShortcut('n')
action = menu.exec_(self.tv.mapToGlobal(pos))
if action == rename_action:
return self._rename_ea_requested(addr, name_idx)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self._dateEdit = QDateEdit()
self._dateEdit.setDisplayFormat("dd/MM/yyyy")
self._bttn = QPushButton("")
self._bttn.setObjectName("MenuBttn")
menu = QMenu(self._bttn)
cal = QCalendarWidget()
action = QWidgetAction(self._bttn)
action.setDefaultWidget(cal)
menu.addAction(action)
self._bttn.setMenu(menu)
cal.clicked[QtCore.QDate].connect(self._dateEdit.setDate)
self.setupUI()
def __init__(self):
self._menu = QMenu("Clean Project")
self._removeUnusedAction = createMenuAction("Remove Unused Clips", self.removeUnusedClips)
self._removeOfflineMediaAction = createMenuAction("Remove Offline Media", self.removeOfflineClips)
self._removeEmptyBinsAction = createMenuAction("Remove Empty Bins", self.removeEmptyBinsAction)
self._menu.addAction(self._removeUnusedAction)
self._menu.addAction(self._removeOfflineMediaAction)
self._menu.addAction(self._removeEmptyBinsAction)
hiero.core.events.registerInterest("kShowContextMenu/kBin", self.eventHandler)
def contextMenuEvent(self, event):
"""
Handles the ``contextMenuEvent`` event for :class:`CmdPromptInput`.
:param `event`: a `QContextMenuEvent` event to be processed.
"""
menu = QMenu(self)
menu.addSeparator()
# TODO: Extra stuff
menu.addAction(QAction("TODO: Add Extra stuff", self))
menu.exec_(event.globalPos())
def notebook_context_menu(self, pos):
index = self.ui.notebooksList.currentIndex()
item = self.notebooksModel.itemFromIndex(index)
if hasattr(item, 'notebook'):
menu = QMenu(self.ui.notebooksList)
menu.addAction(QIcon.fromTheme('gtk-edit'), self.tr('Rename'), self.rename_notebook)
menu.addAction(QIcon.fromTheme('gtk-delete'), self.tr('Remove'), self.remove_notebook)
menu.exec_(self.ui.notebooksList.mapToGlobal(pos))
