def mainmenu(parent):
main_menu = parent.menuBar()
# --------------- MENU BAR --------------------------
# run suite2p from scratch
openFile = QtGui.QAction("&Load single movie file", parent)
openFile.setShortcut("Ctrl+L")
openFile.triggered.connect(lambda: io.open_file(parent))
parent.addAction(openFile)
openFolder = QtGui.QAction("Open &Folder of movies", parent)
openFolder.setShortcut("Ctrl+F")
openFolder.triggered.connect(lambda: io.open_folder(parent))
parent.addAction(openFolder)
# load processed data
loadProc = QtGui.QAction("Load &Processed data", parent)
loadProc.setShortcut("Ctrl+P")
loadProc.triggered.connect(lambda: io.open_proc(parent))
parent.addAction(loadProc)
# make mainmenu!
main_menu = parent.menuBar()
file_menu = main_menu.addMenu("&File")
file_menu.addAction(openFile)
file_menu.addAction(openFolder)
file_menu.addAction(loadProc)
def _build_menu(self):
self.menu = QtGui.QMenu()
self.zeroAction = QtGui.QAction("Set reference to current", self._dock)
self.saveAction = QtGui.QAction("Save Settings", self._dock)
self.menu.addAction(self.zeroAction)
self.menu.addAction(self.saveAction)
def editmenu(parent):
main_menu = parent.menuBar()
edit_menu = main_menu.addMenu("&Edit")
parent.undo = QtGui.QAction('Undo previous mask/trace', parent)
parent.undo.setShortcut("Ctrl+Z")
parent.undo.triggered.connect(parent.undo_action)
parent.undo.setEnabled(False)
edit_menu.addAction(parent.undo)
parent.redo = QtGui.QAction('Undo remove mask', parent)
parent.redo.setShortcut("Ctrl+Y")
parent.redo.triggered.connect(parent.undo_remove_action)
parent.redo.setEnabled(False)
edit_menu.addAction(parent.redo)
parent.ClearButton = QtGui.QAction('Clear all masks', parent)
parent.ClearButton.setShortcut("Ctrl+0")
parent.ClearButton.triggered.connect(parent.clear_all)
parent.ClearButton.setEnabled(False)
edit_menu.addAction(parent.ClearButton)
parent.remcell = QtGui.QAction('Remove selected cell (Ctrl+CLICK)', parent)
parent.remcell.setShortcut("Ctrl+Click")
parent.remcell.triggered.connect(parent.remove_action)
parent.remcell.setEnabled(False)
edit_menu.addAction(parent.remcell)
def __init__(self):
super(ApplicationWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.window = QtWidgets.QMainWindow()
self.x1 = []
self.y1 = []
self.x2 = []
self.y2 = []
self.x3 = []
self.y3 = []
self.x4 = []
self.y4 = []
self.x5 = []
self.y5 = []
self.signal1 = []
# self.signal2=[]
# self.signal3=[]
# self.signal4=[]
# self.signal5=[]
self.initGui()
#=====================THE MENUBAR================================
#================================================================
ExitAction = QtGui.QAction("&Exit", self)
ExitAction.setShortcut("Ctrl+Q")
ExitAction.setStatusTip('Leave the App')
ExitAction.triggered.connect(self.close_application)
openAction = QtGui.QAction("&New File", self)
openAction.setShortcut("Ctrl+N")
openAction.setStatusTip('Open a new file')
openAction.triggered.connect(self.openFileNameDialog)
openActions = QtGui.QAction("&Multiple Files", self)
openActions.setShortcut("Ctrl+M")
openActions.setStatusTip('Open multiple files')
openActions.triggered.connect(self.openFileNamesDialog)
mainMenu = self.menuBar()
fileMenu = mainMenu.addMenu('&File')
fileMenu.addAction(openAction)
fileMenu.addAction(openActions)
fileMenu.addAction(ExitAction)
editMenu = mainMenu.addMenu('&Edit')
editMenu.addAction(ExitAction)
viewMenu = mainMenu.addMenu('&View')
viewMenu.addAction(ExitAction)
toolsMenu = mainMenu.addMenu('&Tools')
toolsMenu.addAction(ExitAction)
helpMenu = mainMenu.addMenu('&Help')
helpMenu.addAction(ExitAction)
def setupUi(self):
self.ui_menubar = QtWidgets.QMenuBar()
#
# file menu actions:
# add file menu and file menu actions
self.languageHash = self.parent.controller.languageSupport.languageHash
self.exit_action = QtGui.QAction(
QtGui.QIcon('exit.png'), self.languageHash.__getitem__("lbl.Exit"),
self)
self.export_action = QtGui.QAction(
QtGui.QIcon('save.png'),
self.languageHash.__getitem__("lbl.ExportResultsToPDF"), self)
self.open_action = QtGui.QAction(
QtGui.QIcon('open.png'),
self.languageHash.__getitem__("lbl.OpenModel"), self)
self.file_menu = self.ui_menubar.addMenu(
self.languageHash.__getitem__("lbl.File"))
self.file_menu.addAction(self.open_action)
self.file_menu.addAction(self.export_action)
self.file_menu.addAction(self.exit_action)
# language menu
self.language_menu = self.ui_menubar.addMenu(
self.languageHash.__getitem__("lbl.Languages"))
self.changeLanguageModel = QtWidgets.QMenu(
self.languageHash.__getitem__("lbl.ChangeModelLanguage"),
parent=self)
self.changeLanguageSystem = QtWidgets.QMenu(
self.languageHash.__getitem__("lbl.ChangeSystemLanguage"),
parent=self)
self.language_menu.addMenu(self.changeLanguageModel)
self.changeLanguageModel.setEnabled(False)
self.language_menu.addMenu(self.changeLanguageSystem)
self.changeLanguageModel.setLayoutDirection(QtCore.Qt.LeftToRight)
self.changeLanguageSystem.setLayoutDirection(QtCore.Qt.LeftToRight)
# load system languages
self.systemLanguageActions = {}
d = self.parent.controller.languageSupport.obtainPossibleLanguages()
self.systemPossibleLanguages = d
x = 0
for lang in d:
# a sub-menu
action = QtGui.QAction(QtGui.QIcon('changeSystemLanguage.png'),
lang, self)
self.changeLanguageSystem.addAction(action)
# keep reference
action.triggered.connect(
lambda checked, lang=lang: self.changeSystemLanguage(lang))
x += 1
def _initActions(self):
self._runAction = QtGui.QAction(self.tr('Run'), self)
self._runAction.setShortcut(self.tr('F5'))
self._runAction.setToolTip('Run simulation (F5)')
self.connect(self._runAction, QtCore.SIGNAL('triggered()'), self._runSlot)
self._resetToDefaultsAction = QtGui.QAction(self.tr('Restore defaults'), self)
self._resetToDefaultsAction.setToolTip('Reset all settings to their default values')
self.connect(self._resetToDefaultsAction, QtCore.SIGNAL('triggered()'), self._useDefaults)
self._showLegendAction = QtGui.QAction(self.tr('Display legend'), self)
self._showLegendAction.setCheckable(True)
self.connect(self._showLegendAction, QtCore.SIGNAL('toggled(bool)'), self._showLegend)
self._showStatePlotAction = QtGui.QAction(self.tr('State plot'), self)
self._showStatePlotAction.setCheckable(True)
self._showStatePlotAction.setChecked(False)
self.connect(self._showStatePlotAction, QtCore.SIGNAL('toggled(bool)'), self._statePlotWidget.setVisible)
self._autoscaleAction = QtGui.QAction(self.tr('Auto-scale plots'), self)
self._autoscaleAction.setCheckable(True)
self._autoscaleAction.setChecked(False)
self.connect(self._autoscaleAction, QtCore.SIGNAL('toggled(bool)'), self._autoscale)
self._overlayAction = QtGui.QAction('Overlay plots', self)
self._overlayAction.setCheckable(True)
self._overlayAction.setChecked(False)
self._dockAction = QtGui.QAction('Undock all', self)
self._dockAction.setCheckable(True)
self._dockAction.setChecked(False)
self.connect(self._dockAction, QtCore.SIGNAL('toggled(bool)'), self._toggleDocking)
self._restoreDocksAction = QtGui.QAction('Show all', self)
self.connect(self._restoreDocksAction, QtCore.SIGNAL('triggered()'), self._restoreDocks)
self._quitAction = QtGui.QAction(self.tr('&Quit'), self)
self._quitAction.setShortcut(self.tr('Ctrl+Q'))
self.connect(self._quitAction, QtCore.SIGNAL('triggered()'), QtGui.qApp.closeAllWindows)
def create_actions(self):
self.open_act = QtGui.QAction("&Open...", self, shortcut="Ctrl+O", triggered=self.open)
for kind in QtGui.QImageWriter.supportedImageFormats():
kind = str(kind)
text = kind.upper() + "..."
action = QtGui.QAction(text, self, triggered=self.save)
action.setData(kind)
self.save_as_acts.append(action)
self.print_act = QtGui.QAction("&Print...", self, triggered=self.scribble_area.print_)
self.exit_act = QtGui.QAction("E&xit", self, shortcut="Ctrl+Q", triggered=self.close)
self.pen_color_act = QtGui.QAction("&Pen Color...", self, triggered=self.pen_color)
self.pen_width_act = QtGui.QAction("Pen &Width", self, triggered=self.pen_width)
self.clear_screen_act = QtGui.QAction("&Clear Screen", self, shortcut="Ctrl-L", triggered=self.scribble_area.clear_image)
self.about_act = QtGui.QAction("&About", self, triggered=self.about)
self.about_qt_act = QtGui.QAction("About &Qt", self, triggered=QtGui.QApplication.instance().aboutQt)
def initUI(self):
self.setWindowTitle(PROJECTMETA.__label__)
#self.center() # center window position
# create dummy widget (it will be selected if our node doesnot has ctrlWidget)
self._dummyWidget = QtWidgets.QWidget(self)
# init FlowChart
self.initFlowchart()
# connect on select QTreeWidgetItem > se text in QLineEdit
self.treeWidget.itemActivated.connect(
self.on_nodeLibTreeWidget_itemActivated)
# init dock widgets
css = "color: white; font-size: 12pt; font-weight: bold; background: rgb(102, 102, 204); qproperty-alignment: 'AlignVCenter | AlignHCenter';"
label_1 = QtWidgets.QLabel("Node Library")
label_1.setStyleSheet(css)
self.dockWidget.setTitleBarWidget(label_1)
label_2 = QtWidgets.QLabel("Node Controls")
label_2.setStyleSheet(css)
self.dockWidget_2.setTitleBarWidget(label_2)
#init node selector tab, set autocompletion etc
#self._nodeNameCompleter = QtWidgets.QCompleter(self)
self._nodeNameCompleter = CustomQCompleter(self)
self._nodeNameCompleter.setModel(self.uiData.nodeNamesModel())
self._nodeNameCompleter.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.lineEdit_nodeSelect.setCompleter(self._nodeNameCompleter)
# set tree view of node library
fill_widget(self.treeWidget, self.uiData.nodeNamesTree())
# create EMPTY Open Recent Actions
self.recentFileActs = []
for i in xrange(GlobalOptions.n_recent_files):
action = QtGui.QAction(self,
visible=False,
triggered=self.openRecentFile)
self.menuOpen_Recent.addAction(action)
self.recentFileActs.append(action)
self.menuOpen_Recent.addSeparator()
self.actionClearRecent = QtGui.QAction(
'Clear', self, visible=True, triggered=self.on_actionClearRecent)
self.menuOpen_Recent.addAction(self.actionClearRecent)
# create a tool bar menu button to open recent files and connect it to proper QMenu
for widget in self.actionLoad_fc.associatedWidgets():
# loop over assosiated widgets and search for QToolButton, assuming that only one is connected.
if isinstance(widget, QtWidgets.QToolButton):
widget.setMenu(self.menuOpen_Recent)
widget.setPopupMode(QtWidgets.QToolButton.MenuButtonPopup)
# now populate recent files QMenu
self.uiData.updateRecentFileActions()
def rightMenuShow(self):
rightMenu = QtGui.QMenu(self.listView1)
removeAction = QtGui.QAction(
u"删除", self, triggered=self.close
) # triggered 为右键菜单点击后的激活事件。这里slef.close调用的是系统自带的关闭事件。
rightMenu.addAction(removeAction)
addAction = QtGui.QAction(u"添加", self,
triggered=self.addItem) # 也可以指定自定义对象事件
rightMenu.addAction(addAction)
rightMenu.exec_(QtGui.QCursor.pos())
def __init__(self):
super(Ui_MainWindow, self).__init__()
# This sets up the main window
self.resize(600, 300)
self.setWindowTitle("Air-Fuel Ratio Analyzer")
#self.setWindowIcon(QtGui.QIcon('/home/malfoy/Desktop/AFR/AFR.png'))
# Center the window in the middle of the screen
frame = self.frameGeometry()
centerPoint = QtGui.QDesktopWidget().availableGeometry().center()
frame.moveCenter(centerPoint)
self.move(frame.topLeft())
# Setup the menu
openFile = QtGui.QAction("&Open File", self)
openFile.setShortcut("Ctrl+O")
openFile.setStatusTip('Open file.')
openFile.triggered.connect(self.file_open)
quitApplication = QtGui.QAction("&Quit", self)
quitApplication.setShortcut("Ctrl+Q")
quitApplication.setStatusTip('Quit the application.')
quitApplication.triggered.connect(self.close_application)
self.clearData = QtGui.QAction("&Clear Data", self)
self.clearData.setShortcut("Ctrl+L")
self.clearData.setStatusTip('Clear the loaded data.')
self.clearData.setEnabled(False)
self.clearData.triggered.connect(self.data_clear)
self.infoData = QtGui.QAction("&Information", self)
self.infoData.setShortcut("Ctrl+I")
self.infoData.setStatusTip('Information about the current dataset.')
self.infoData.setEnabled(False)
self.infoData.triggered.connect(self.data_info)
self.statusBar = QtGui.QStatusBar(self)
self.statusBar.setStyleSheet(
"background-color: rgb(60, 60, 60); color: rgb(184, 181, 178);")
self.setStatusBar(self.statusBar)
# Create the menuBar
mainMenu = self.menuBar()
# Add the fileMenu to the menuBar
fileMenu = mainMenu.addMenu('&File')
fileMenu.addAction(openFile)
fileMenu.addAction(self.clearData)
fileMenu.addAction(quitApplication)
# Add the dataMenu to the menuBar
dataMenu = mainMenu.addMenu('&Data')
dataMenu.addAction(self.infoData)
# run the setupUi method
self.setupUi()
def mergebar(parent):
# merge menuBar
main_menu = parent.menuBar()
merge_menu = main_menu.addMenu("&Merge ROIs")
parent.sugMerge = QtGui.QAction("Auto-suggest merges", parent)
parent.sugMerge.triggered.connect(lambda: suggest_merge(parent))
parent.sugMerge.setEnabled(False)
parent.saveMerge = QtGui.QAction("&Append merges to npy files", parent)
parent.saveMerge.triggered.connect(lambda: io.save_merge(parent))
parent.saveMerge.setEnabled(False)
merge_menu.addAction(parent.sugMerge)
merge_menu.addAction(parent.saveMerge)
def add_menu_bar(self, menu, group, items, callback=None, default=None):
for item in items:
if item == default:
_item = QtGui.QAction(item, self, checkable=True, checked=True)
else:
_item = QtGui.QAction(item, self, checkable=True, checked=False)
if callback:
_item.triggered.connect(callback)
menu.addAction(_item)
group.addAction(_item)
return menu, group
def visualizations(parent):
# visualizations menuBar
main_menu = parent.menuBar()
vis_menu = main_menu.addMenu("&Visualizations")
parent.visualizations = QtGui.QAction("&Visualize selected cells", parent)
parent.visualizations.triggered.connect(lambda: vis_window(parent))
parent.visualizations.setEnabled(False)
vis_menu.addAction(parent.visualizations)
parent.visualizations.setShortcut("Ctrl+V")
parent.custommask = QtGui.QAction("Load custom hue for ROIs (*.npy)",
parent)
parent.custommask.triggered.connect(lambda: io.load_custom_mask(parent))
parent.custommask.setEnabled(False)
vis_menu.addAction(parent.custommask)
def registration(parent):
# registration menuBar
main_menu = parent.menuBar()
reg_menu = main_menu.addMenu("&Registration")
parent.reg = QtGui.QAction("View registered &binary", parent)
parent.reg.triggered.connect(lambda: reg_window(parent))
parent.reg.setShortcut("Ctrl+B")
parent.reg.setEnabled(True)
parent.regPC = QtGui.QAction("View registration &Metrics", parent)
parent.regPC.triggered.connect(lambda: regPC_window(parent))
parent.regPC.setShortcut("Ctrl+M")
parent.regPC.setEnabled(True)
reg_menu.addAction(parent.reg)
reg_menu.addAction(parent.regPC)
def initUI(self):
#General stuff
self.setGeometry(200, 200, 100, 100)#the latter two numbers ensure the smallest possible window size on startup
self.setWindowTitle('Pantheon')
#Status Bar
self.status_msg = QtWidgets.QLabel("Ready")
self.statusBar().addWidget(self.status_msg, 1)
self.progress_bar = QtWidgets.QProgressBar()
self.progress_bar.setRange(0, 100)
self.progress_bar.setValue(0)
self.statusBar().addWidget(self.progress_bar, 1)
self.progress_bar.hide()
#createUI
self.main_widget = PantheonCentralWidget(self)
self.setCentralWidget(self.main_widget)
#Menu Bar
action_exit = QtGui.QAction(QtGui.QIcon("exit.png"), '&Exit', self)
action_exit.setShortcut('Ctrl+Q')
action_exit.setStatusTip('Exit application')
action_exit.triggered.connect(self.close)
action_save = QtGui.QAction(QtGui.QIcon("save.png"), '&Save', self)
action_save.setShortcut('Ctrl+S')
action_save.setStatusTip('Save object list')
action_save.triggered.connect(self.main_widget.save)
action_load = QtGui.QAction(QtGui.QIcon("load.png"), '&Load', self)
action_load.setShortcut('Ctrl+L')
action_load.setStatusTip('Load object list')
action_load.triggered.connect(self.main_widget.load)
action_about = QtGui.QAction(QtGui.QIcon("about.png"), '&About', self)
action_about.setShortcut('Ctrl+A')
action_about.setStatusTip('Display licenses')
action_about.triggered.connect(self.openAboutDialog)
menu_bar = self.menuBar()
menu_file = menu_bar.addMenu('&File')
menu_file.addAction(action_save)
menu_file.addAction(action_load)
menu_file.addAction(action_exit)
menu_about = menu_bar.addMenu('&Help')
menu_about.addAction(action_about)
self.show()
def _setup_actions(self):
""" Creates the main window actions.
"""
# Show/hide callable objects
self.toggle_callable_action = \
QtGui.QAction("Show routine attributes", self, checkable=True,
statusTip = "Shows/hides attributes that are routings (functions, methods, etc)")
self.toggle_callable_action.toggled.connect(self.toggle_callables)
# Show/hide special attributes
self.toggle_special_attribute_action = \
QtGui.QAction("Show __special__ attributes", self, checkable=True,
statusTip = "Shows or hides __special__ attributes")
self.toggle_special_attribute_action.toggled.connect(
self.toggle_special_attributes)
def home(self):
btn = QtGui.QPushButton("Quit", self)
btn.clicked.connect(self.close_application)
btn.resize(btn.minimumSizeHint())
btn.move(0, 100)
extractAction = QtGui.QAction(QtGui.QIcon('todachoppa.png'),
'Flee the Scene', self)
extractAction.triggered.connect(self.close_application)
self.toolBar = self.addToolBar("Extraction")
self.toolBar.addAction(extractAction)
checkBox = QtGui.QCheckBox('Shrink Window', self)
checkBox.move(100, 25)
checkBox.stateChanged.connect(self.enlarge_window)
self.progress = QtGui.QProgressBar(self)
self.progress.setGeometry(200, 80, 250, 20)
self.btn = QtGui.QPushButton("Download", self)
self.btn.move(200, 120)
self.btn.clicked.connect(self.download)
self.show()
def __init__(self, name, tab, menu, DockObj, param, pos, related_dock=None,
size=(1, 1), hide_title=False, scroll=False):
self.name = name
self.DockObj = DockObj
self.param = param
self.tab = tab
self.pos = pos
self.related_dock = related_dock
self.size = size
self.hide_title = hide_title
self.scroll = scroll
self.first_time = True
self.dock = self.init_dock()
self.dock_obj = DockObj(*param)
if name == 'EEG':
x = self.dock_obj.regions
self.state = 'checked'
self.check_actn = QtGui.QAction(name, tab, checkable=True)
self.check_actn.setChecked(True)
self.check_actn.triggered.connect(self.open_close_dock)
self.check_actn.setStatusTip(f'Check {name} to open this dock...')
menu.addAction(self.check_actn)
def __init__(self, lasagna):
super(loaderClass, self).__init__(lasagna)
self.lasagna = lasagna
self.objectName = 'lines_reader'
self.kind = 'lines'
#Construct the QActions and other stuff required to integrate the load dialog into the menu
self.loadAction = QtGui.QAction(
self.lasagna) #Instantiate the menu action
#Add an icon to the action
iconLoadOverlay = QtGui.QIcon()
iconLoadOverlay.addPixmap(
QtGui.QPixmap(":/actions/icons/lines_64.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.loadAction.setIcon(iconLoadOverlay)
#Insert the action into the menu
self.loadAction.setObjectName("linesRead")
self.lasagna.menuLoad_ingredient.addAction(self.loadAction)
self.loadAction.setText("Lines read")
self.loadAction.triggered.connect(
self.showLoadDialog) #Link the action to the slot
def __init__(self, *args, **kargs):
self.ma = 0
super(PlotCurveItem, self).__init__(*args, **kargs)
self.avg = None
self.menu = QtGui.QMenu()
self.do_ma = False
self.colorAction = ColorAction(self.menu)
self.colorAction.colorSelected.connect(self.handleColorSelected)
self.menu.addAction(self.colorAction)
self.menu.addSeparator()
fontColor = QtGui.QAction('Custom color', self)
self.menu.addAction(fontColor)
fontColor.triggered.connect(self.custom_color)
self.sub_menu = QMenu("Moving average")
a = QWidgetAction(self)
self.spin = QSpinBox()
self.spin.setSingleStep(10)
self.spin.setMaximum(1000)
self.spin.valueChanged.connect(self.moving_average)
a.setDefaultWidget(self.spin)
self.sub_menu.addAction(a)
self.menu.addMenu(self.sub_menu)
self.yData_ma = []
self.yData_unaltered = []
def qaction(qttr, menu, text, func):
act = QtGui.QAction(qttr.tr(text), menu)
act.triggered.connect(func)
#newAct->setShortcuts(QKeySequence::New)
#newAct->setStatusTip(tr("Create a new file"))
menu.addAction(act)
return act
def __init__(self, controller, job):
super().__init__()
self.controller = controller
self.job = job
self.setFlag(QtWidgets.QGraphicsItem.ItemIsSelectable)
self.cut_colors = [QtGui.QColor(255, 255, 255),
QtGui.QColor(250, 170, 0),
QtGui.QColor( 5, 220, 10),
QtGui.QColor(255, 0, 0),
QtGui.QColor(100, 100, 100)]
self.cut_paths = [QtGui.QPainterPath()] * len(self.cut_colors)
self.pen_base = QtGui.QPen(QtGui.QBrush(), 0,
Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
self.select_brush = QtGui.QBrush(QtGui.QColor(4, 200, 255, 200))
self.unselect_brush = QtGui.QBrush(QtGui.QColor(4, 150, 255, 150))
self.job.shape_update.connect(self.on_job_shape_update)
self.on_job_shape_update()
self.menu = QtGui.QMenu()
self.action = QtGui.QAction('Job settings')
self.action.triggered.connect(self.on_job_settings)
self.menu.addAction(self.action)
self.params_dialog = JobParamDialog(self.job)
def __init__(self, parent=None):
super(StandAlone, self).__init__(parent)
# scroll area widget contents - layout
self.pump = PumpControl(com_port=4,
pump_ID=30,
simulate=False,
verbose=False)
# central widget
self.centralWidget = QtGui.QWidget()
self.mainLayout = QtGui.QVBoxLayout(self.centralWidget)
self.mainLayout.addWidget(self.pump.mainWidget)
# set central widget
self.setCentralWidget(self.centralWidget)
# set window title
self.setWindowTitle("Pump Control")
# set window geometry
self.setGeometry(50, 50, 500, 300)
# Create file menu
menubar = self.menuBar()
file_menu = menubar.addMenu("File")
exit_action = QtGui.QAction("Exit", self)
exit_action.setShortcut("Ctrl+Q")
exit_action.triggered.connect(self.closeEvent)
file_menu.addAction(exit_action)
def __init__(self, parent=None):
super(StandAlone, self).__init__(parent)
# scroll area widget contents - layout
print('calling ValveCommands')
self.valve_chain_commands = ValveCommands(verbose=True)
# main layout
# add all main to the main vLayout
# central widget
self.centralWidget = QtGui.QWidget()
self.mainLayout = QtGui.QVBoxLayout(self.centralWidget)
self.mainLayout.addWidget(self.valve_chain_commands.mainWidget)
# set central widget
self.setCentralWidget(self.centralWidget)
# set window title
self.setWindowTitle("Valve Chain Commands")
# set window geometry
self.setGeometry(50, 50, 500, 400)
# Create file menu
menubar = self.menuBar()
file_menu = menubar.addMenu("File")
exit_action = QtGui.QAction("Exit", self)
exit_action.setShortcut("Ctrl+Q")
exit_action.triggered.connect(self.closeEvent)
file_menu.addAction(exit_action)
file_menu.addAction(self.valve_chain_commands.load_commands_action)
def helpmenu(parent):
main_menu = parent.menuBar()
help_menu = main_menu.addMenu("&Help")
openHelp = QtGui.QAction("&Help window", parent)
openHelp.setShortcut("Ctrl+H")
openHelp.triggered.connect(parent.help_window)
help_menu.addAction(openHelp)
def install(self, icon=None, separator=None, **kwargs):
before = None
# 'pos' is the menu where the Action has to be installed
# if no 'pos' kwarg is provided then by default our Action will be installed in the menutool
# as it previously was
if 'pos' in kwargs:
pos = kwargs['pos']
else:
pos = self.app.ui.menutool
# 'before' is the Action in the menu stated by 'pos' kwarg, before which we want our Action to be installed
# if 'before' kwarg is not provided, by default our Action will be added in the last place.
if 'before' in kwargs:
before = (kwargs['before'])
# create the new Action
self.menuAction = QtGui.QAction(self)
# if provided, add an icon to this Action
if icon is not None:
self.menuAction.setIcon(icon)
# set the text name of the Action, which will be displayed in the menu
self.menuAction.setText(self.toolName)
# add a ToolTip to the new Action
# self.menuAction.setToolTip(self.toolTip) # currently not available
# insert the action in the position specified by 'before' and 'pos' kwargs
pos.insertAction(before, self.menuAction)
# if separator parameter is True add a Separator after the newly created Action
if separator is True:
pos.addSeparator()
self.menuAction.triggered.connect(self.run)
def onListImageFilesContextMenuRequested(self, point):
current_item = self.ui.listWidgetImageFiles.currentItem()
if current_item is None:
return
pop_menu = QtGui.QMenu()
delete_action = QtGui.QAction(u'删除', self)
pop_menu.addAction(delete_action)
delete_action.triggered.connect(self.DeletePatternItem)
modify_action = QtGui.QAction(u'修改', self)
pop_menu.addAction(modify_action)
modify_action.triggered.connect(self.ModifyPatternItem)
cancel_modify_action = QtGui.QAction(u'取消修改', self)
pop_menu.addAction(cancel_modify_action)
cancel_modify_action.triggered.connect(self.CancelModifyPatternItem)
pop_menu.exec_(QtGui.QCursor.pos())
def create_menu_start_game(self):
# ---Start game---
self.menuGame = QMenu(title='&Start game')
self.start_game = QtGui.QAction('Start platformer game...')
self.start_game.setStatusTip('Press to start the mini game...')
self.start_game.triggered.connect(self.start_the_game)
self.menuGame.addAction(self.start_game)
def create_muse_menu(self):
self.muse = QtGui.QAction(
QIcon('./img/muse.png'),
'Muse') # TODO: ALEXM Utiliser une liste déroulante plutot
self.muse.setStatusTip('Stream data from Muse headband...')
self.muse.name = 'Stream from Muse'
self.controlPanel.addAction(self.muse)
def getContextMenus(self, event=None):
if self.menu is None:
self.menu = QtGui.QMenu()
self.menu.triggered.connect(self.hide)
self.menu.setTitle("Scale Box")
# Add scale items
rbActions = (
('Expand', partial(self.expand, axis='XY')),
('Expand X', partial(self.expand, axis='X')),
('Expand Y', partial(self.expand, axis='Y')),
)
for action in rbActions:
qaction = QtGui.QAction(action[0], self.menu)
qaction.triggered.connect(action[1])
self.menu.addAction(qaction)
# Add plot items to the menu. First get a list of items in the view
items = self.getViewBox().childGroup.childItems()
# Figure out an item numbering for labelling purposes
itemNumbers = [x for x in self.parentObject().childItems() if isinstance(x, (ExtendedDataItem, PlotDataItem, ImageItem))]
itemNumbers = dict((x[1], x[0]) for x in enumerate(itemNumbers))
# Then, filter items under the box
logger.debug("Bounding rect for scale box is: %r", self.boundingRect())
items = [i for i in items if i.collidesWithItem(self)]
logger.debug("Items in the selection are: %r", items)
# And finally add context menus
self.addPlotContextMenus(items, itemNumbers, self.menu, self.boundingRect())
return self.menu
