def __init__(self, parent=None):
super(FormWidget, self).__init__(parent)
self.setupUi(self)
self.form = None
self.fieldsmodel = QgsFieldModel()
self.widgetmodel = WidgetsModel()
self.possiblewidgetsmodel = QStandardItemModel()
self.formlayersmodel = QgsLayerModel(watchregistry=True)
self.formlayers = CaptureLayerFilter()
self.formlayers.setSourceModel(self.formlayersmodel)
self.layerCombo.setModel(self.formlayers)
self.useablewidgets.setModel(self.possiblewidgetsmodel)
self.fieldList.setModel(self.fieldsmodel)
self.userwidgets.setModel(self.widgetmodel)
self.userwidgets.selectionModel().currentChanged.connect(self.load_widget)
self.widgetmodel.rowsRemoved.connect(self.setwidgetconfigvisiable)
self.widgetmodel.rowsInserted.connect(self.setwidgetconfigvisiable)
self.widgetmodel.modelReset.connect(self.setwidgetconfigvisiable)
self.addWidgetButton.pressed.connect(self.newwidget)
self.removeWidgetButton.pressed.connect(self.removewidget)
self.formfolderLabel.linkActivated.connect(self.openformfolder)
self.expressionButton.clicked.connect(self.opendefaultexpression)
self.fieldList.currentIndexChanged.connect(self.updatewidgetname)
self.fieldwarninglabel.hide()
self.formtab.currentChanged.connect(self.formtabchanged)
for item, data in readonlyvalues:
self.readonlyCombo.addItem(item, data)
self.loadwidgettypes()
self.formLabelText.textChanged.connect(self.form_name_changed)
self.layerCombo.currentIndexChanged.connect(self.layer_updated)
self.fieldList.currentIndexChanged.connect(self._save_current_widget)
self.nameText.textChanged.connect(self._save_current_widget)
self.useablewidgets.currentIndexChanged.connect(self._save_current_widget)
self.useablewidgets.currentIndexChanged.connect(self.swapwidgetconfig)
menu = QMenu("Field Actions")
action = menu.addAction("Auto add all fields")
action.triggered.connect(self.auto_add_fields)
self.addWidgetButton.setMenu(menu)
self.addWidgetButton.setPopupMode(QToolButton.MenuButtonPopup)
self.defaultLayerCombo.layerChanged.connect(self.default_layer_changed)
def __init__(self):
super(SystemTrayIcon, self).__init__()
self.setIcon(QIcon.fromTheme('tray-offline'))
menu = QMenu()
menu.addAction(QIcon.fromTheme('view-minimize'),
'Show/Hide').triggered.connect(
self.toggle_main_window_signal)
menu.addSeparator()
menu.addAction(QIcon.fromTheme('exit'),
'Quit').triggered.connect(self.quit_signal)
self.setContextMenu(menu)
self.show()
def menus(self):
"""
Overridden from Workflow base class
"""
from PyQt4.QtGui import QMenu
autocontext_menu = QMenu("Autocontext Utilities")
distribute_action = autocontext_menu.addAction("Distribute Labels...")
distribute_action.triggered.connect(
self.distribute_labels_from_current_stage)
self._autocontext_menu = autocontext_menu # Must retain here as a member or else reference disappears and the menu is deleted.
return [self._autocontext_menu]
def createTrayIcon(self):
"""create system tray icon"""
self.trayIconMenu = QMenu(self)
es = self.trayIconMenu.addAction(self.configAction)
self.trayIconMenu.addSeparator()
ea = self.trayIconMenu.addAction(self.exitAction)
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setContextMenu(self.trayIconMenu)
self.trayIcon.setIcon(QIcon('icon/tray.png'))
def initGui(self):
from PyQt4.QtCore import QObject, SIGNAL
from PyQt4.QtGui import QMenu
self.menu = QMenu()
self.menu.setTitle(self.menu.tr("&Processing", "Processing"))
# We only generate the panel & populate the menu when needed,
# to increase our chances that the framework has been loaded.
QObject.connect(self.menu, SIGNAL("aboutToShow()"), self.populateMenu)
menuBar = self._iface.mainWindow().menuBar()
menuBar.insertMenu(menuBar.actions()[-1], self.menu)
def setupPlotsMenu(self):
""" Configure the plots button menu.
@return None
"""
plotButton = self.plotButton
pop = QMenu(plotButton)
plotButton.setMenu(pop)
pop.addAction(self.actionNewPlot)
pop.addAction(self.actionClosePlot)
pop.addSeparator()
pop.addAction(self.actionSyncWithData)
def __init__(self, parent=None):
super(AccountState, self).__init__(parent)
menu = QMenu(self)
for state in (self.Available, self.Away, self.Busy, self.Invisible):
action = menu.addAction(QIcon(state.icon), state.name)
action.state = state
action.note = None
menu.addSeparator()
menu.triggered.connect(self._SH_MenuTriggered)
self.setMenu(menu)
self.state = self.Invisible
self.note = None
def on_tableServoData_customContextMenuRequested(self, pos):
item = self.tableServoData.itemAt(pos)
if not item or item.column() < 1:
return
menu = QMenu(self)
actionCopyToAllServos = menu.addAction("Copy To All Servos")
actionAddToDataPlot = menu.addAction("Plot Value")
action = menu.exec_(self.tableServoData.mapToGlobal(pos))
if action == actionCopyToAllServos:
self.handleCopyToAllServos(item)
elif action == actionAddToDataPlot:
self.handleAddToDataPlot(item)
def __init__(self, parent=None):
super(FilterSetWidget, self).__init__(parent)
self.setupUi(self)
self._filterSetActionGroup = QActionGroup(self)
self._filterSetActionGroup.addAction(self.saveFilterSetAction)
self._filterSetActionGroup.addAction(self.reloadFilterSetAction)
self._filterSetActionGroup.addAction(self.deleteFilterSetAction)
self._filterSetActionGroup.addAction(self.exportFilterSetAction)
self._filterSetMenu = QMenu(self)
self._filterSetMenu.addActions(self._filterSetActionGroup.actions())
self.filterSetTool.setMenu(self._filterSetMenu)
self.filterSetTool.setDefaultAction(self.saveFilterSetAction)
def create_prefetch_menu(self, layer_name):
def prefetch_layer(axis='z'):
layer_index = self.layerstack.findMatchingIndex(lambda l: l.name == layer_name)
num_slices = self.editor.dataShape['txyzc'.index(axis)]
view2d = self.editor.imageViews['xyz'.index(axis)]
view2d.scene().triggerPrefetch([layer_index], spatial_axis_range=(0, num_slices))
prefetch_menu = QMenu("Prefetch")
prefetch_menu.addAction( QAction("All Z-slices", prefetch_menu, triggered=partial(prefetch_layer, 'z')) )
prefetch_menu.addAction( QAction("All Y-slices", prefetch_menu, triggered=partial(prefetch_layer, 'y')) )
prefetch_menu.addAction( QAction("All X-slices", prefetch_menu, triggered=partial(prefetch_layer, 'x')) )
return prefetch_menu
def createMenuAssigned(self, position):
"""
Creates a pop up menu to show properties of a permission assigned to a user
"""
menu = QMenu()
item = self.assignedProfiles.itemAt(position)
if item:
menu.addAction(self.tr('Show properties'), self.showAssignedProperties)
menu.exec_(self.assignedProfiles.viewport().mapToGlobal(position))
def createMenuInstalled(self, position):
"""
Creates a pop up menu to show permission properties
"""
menu = QMenu()
item = self.installedProfiles.itemAt(position)
if item:
menu.addAction(self.tr('Show properties'), self.showInstalledProperties)
menu.exec_(self.installedProfiles.viewport().mapToGlobal(position))
def menu_file_open_recent(parent):
m = QMenu(parent)
m.setTitle(_("Open &Recent"))
m.triggered.connect(slot_file_open_recent_action)
import recentfiles
for url in recentfiles.urls():
f = url.toLocalFile()
dirname, basename = os.path.split(f)
text = "{0} ({1})".format(basename, util.homify(dirname))
m.addAction(text).url = url
qutil.addAccelerators(m.actions())
return m
def contextMenuEvent(self, event):
current_layout_lock.acquire()
if(self.sourcemodel.current_layout == "conn"):
current_layout_lock.release()
return
current_layout_lock.release()
#self.index = self.sourcemodel.indexAt(event.pos())
self.menu = QMenu(self)
delete_ruleAction = QAction(u"删除", self)
delete_ruleAction.triggered.connect(self.deleterule)
self.menu.addAction(delete_ruleAction)
self.menu.popup(QtGui.QCursor.pos())
def __init__(self):
self.snapshots = snapshots.Snapshots()
self.config = self.snapshots.config
if len(sys.argv) > 1:
if not self.config.set_current_profile(sys.argv[1]):
logger.warning("Failed to change Profile_ID %s" % sys.argv[1],
self)
self.qapp = qt4tools.create_qapplication(self.config.APP_NAME)
import icon
self.icon = icon
self.qapp.setWindowIcon(icon.BIT_LOGO)
self.status_icon = QSystemTrayIcon(icon.BIT_LOGO)
#self.status_icon.actionCollection().clear()
self.contextMenu = QMenu()
self.menuProfileName = self.contextMenu.addAction(
_('Profile: "%s"') % self.config.get_profile_name())
qt4tools.set_font_bold(self.menuProfileName)
self.contextMenu.addSeparator()
self.menuStatusMessage = self.contextMenu.addAction(_('Done'))
self.menuProgress = self.contextMenu.addAction('')
self.menuProgress.setVisible(False)
self.contextMenu.addSeparator()
self.startBIT = self.contextMenu.addAction(icon.BIT_LOGO,
_('Start BackInTime'))
QObject.connect(self.startBIT, SIGNAL('triggered()'), self.onStartBIT)
self.status_icon.setContextMenu(self.contextMenu)
self.pixmap = icon.BIT_LOGO.pixmap(24)
self.progressBar = QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(100)
self.progressBar.setValue(0)
self.progressBar.setTextVisible(False)
self.progressBar.resize(24, 6)
self.progressBar.render(self.pixmap,
sourceRegion=QRegion(0, -14, 24, 6),
flags=QWidget.RenderFlags(
QWidget.DrawChildren))
self.first_error = self.config.is_notify_enabled()
self.popup = None
self.last_message = None
self.timer = QTimer()
QObject.connect(self.timer, SIGNAL('timeout()'), self.update_info)
self.ppid = os.getppid()
def showTreeMenu(self, pos):
index = self.ui.treeView.indexAt(pos)
# if not index.isValid():
# return
self.treeMenu = QMenu(self)
self.treeMenu.addAction("Add Class", self.treeMenuAddClass)
if index.isValid():
self.treeMenu.addAction("Add Params",
lambda: self.treeMenuAddParams(index))
self.treeMenu.exec_(self.mapToGlobal(pos))
def _createSettingsMenu(self):
menu = QMenu("&Settings", self)
# Menu item: Keyboard Shortcuts
def editShortcuts():
mgrDlg = ShortcutManagerDlg(self)
shortcutsAction = menu.addAction("&Keyboard Shortcuts")
shortcutsAction.triggered.connect(editShortcuts)
return menu
def initMenu(self):
"""初始化右键菜单"""
self.menu = QMenu(self)
saveAction = QAction(u'保存内容', self)
saveAction.triggered.connect(self.saveToCsv)
resizeAction = QAction(u'调整列宽', self)
resizeAction.triggered.connect(self.resizeColumns)
self.menu.addAction(resizeAction)
self.menu.addAction(saveAction)
def getMenuFromModuleTag(self, tagname):
menu = QMenu()
modules = self.loader.modules
for mod in modules:
m = modules[mod]
try:
if m.tags == tagname:
menu.addAction(
newAction(self, self.mainwindow, mod, tagname, m.icon))
# actions.append(newAction(self, self.__mainWindow, mod, self.tags, m.icon))
except AttributeError, e:
pass
def _populate_menubar(self, action_lists):
self.menus['session'] = QMenu(_('&Session'), self.menubar)
self.menus['grading'] = QMenu(_('&Grading'), self.menubar)
self.menus['exams'] = QMenu(_('&Exams'), self.menubar)
self.menus['tools'] = QMenu(_('&Tools'), self.menubar)
self.menus['help'] = QMenu(_('&Help'), self.menubar)
self.menubar.addMenu(self.menus['session'])
self.menubar.addMenu(self.menus['grading'])
self.menubar.addMenu(self.menus['exams'])
self.menubar.addMenu(self.menus['tools'])
self.menubar.addMenu(self.menus['help'])
for action in action_lists['session']:
self.menus['session'].addAction(action)
for action in action_lists['grading']:
self.menus['grading'].addAction(action)
for action in action_lists['exams']:
self.menus['exams'].addAction(action)
for action in action_lists['tools']:
self.menus['tools'].addAction(action)
for action in action_lists['help']:
self.menus['help'].addAction(action)
def setOpenRelevant(self):
if self.selection != None:
node = self.selection
modules = node.compatibleModules()
if len(modules):
relevant = QMenu()
for modname in modules:
module = self.loader.modules[modname]
relevant.addAction(
newAction(self, self.mainwindow, modname, module.tags,
module.icon))
self.actionOpen.setMenu(relevant)
def createContextMenu(self, position):
"""
Creates the flag menu
"""
menu = QMenu()
item = self.tableView.indexAt(position)
if item:
menu.addAction(self.tr('Zoom to flag'), self.zoomToFlag)
menu.addAction(self.tr('Remove flag'), self.removeCurrentFlag)
# menu.addAction(self.tr('Set Visited'), self.setFlagVisited)
# menu.addAction(self.tr('Set Unvisited'), self.setFlagUnvisited)
menu.exec_(self.tableView.viewport().mapToGlobal(position))
def popup2(self, pos):
contextmenu = QMenu()
contextmenu.addAction("Play / Pause (SPACE)", self.handlePlayButton)
contextmenu.addSeparator()
contextmenu.addAction("Load Video (o)", self.handleButton)
contextmenu.addAction("Toggle Slider (s)", self.toggleSlider)
contextmenu.addSeparator()
contextmenu.addAction("Fullscreen (f)", self.handleFullscreen)
contextmenu.addAction("Information (i)", self.handleInfo)
contextmenu.addSeparator()
contextmenu.addAction("Exit (q)", self.handleQuit)
contextmenu.exec_(QCursor.pos())
def __init__(self, undo_stack, delete_act, sel_actions, *args):
"""
Constructor
"""
params = parameters.instance
QGraphicsScene.__init__(self, *args)
self.delete_act = delete_act
self.undo_stack = undo_stack
self.data_manager = None
self._mode = None
self.link = None
self.image_path = None
self.image_name = None
self.background_image = None
self.template = TemplateItem()
self.template.setPos(QPointF(0, 0))
self.template.setVisible(params.show_template)
self.show_template = False
self.points = {}
self.cells = {}
self._real_scene_rect = QRectF()
params.pointParameterChange.connect(self.updatePoints)
params.cellParameterChange.connect(self.updateCells)
params.searchParameterChange.connect(self.updateTemplate)
self.had_selection = None
self.selectionChanged.connect(self.updateSelectionActions)
self.current_data = None
self.back_matrix = QTransform()
self.invert_back_matrix = QTransform()
self.clear()
popup = QMenu("Scene menu")
validate_cell_act = popup.addAction("Validate cell", self.validateCell)
validate_cell_act.setVisible(False)
self._validate_cell_act = validate_cell_act
lifespan_act = popup.addAction("Change cell lifespan", self.changeLifespan)
lifespan_act.setVisible(False)
self.lifespan_act = lifespan_act
make_starshape_act = popup.addAction("Make cell star shaped", self.makeCellStarshaped)
make_starshape_act.setVisible(False)
self.make_starshape_act = make_starshape_act
sel = popup.addMenu("Selection")
for act in sel_actions:
if act == "-":
sel.addSeparator()
else:
sel.addAction(act)
popup.addAction(delete_act)
self._popup = popup
self._sel_rect = None
self._sel_first_pt = None
self._current_cell = None
self._first_point = None
self.mode = TrackingScene.Pan
def __init__(self):
super(QWidget, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.systemTray = QSystemTrayIcon(self)
self.systemTray.setIcon(QIcon(':/images/icon.png'))
self.act_autostart = QAction('开机启动', self)
self.act_autostart.setCheckable(True)
is_autostart = self.is_autostart()
self.act_autostart.setChecked(is_autostart)
self.act_autostart.triggered.connect(self.on_autostart)
act_setting = QAction('设置启动项', self)
act_setting.triggered.connect(self.on_settings)
act_exit = QAction('退出', self)
act_exit.triggered.connect(self.on_exit)
self.menu_run = QMenu('运行', self)
menu = QMenu('菜单', self)
menu.addMenu(self.menu_run)
menu.addAction(act_setting)
menu.addSeparator()
menu.addAction(self.act_autostart)
menu.addAction(act_exit)
self.systemTray.setContextMenu(menu)
self.systemTray.show()
self.showMessage('启动工具正在运行')
self.ui.btn_add.clicked.connect(self.on_add)
self.ui.btn_delete.clicked.connect(self.on_delete)
self.ui.btn_apply.clicked.connect(self.on_apply)
self.ui.btn_env_add.clicked.connect(self.on_env_add)
self.ui.btn_env_del.clicked.connect(self.on_env_del)
self.ui.btn_open.clicked.connect(self.on_open)
self.ui.btn_run.clicked.connect(self.on_run)
self.ui.le_args.textEdited.connect(self.on_edited)
self.ui.le_desc.textEdited.connect(self.on_edited)
self.ui.le_exe.textEdited.connect(self.on_edited)
self.ui.cb_process.currentIndexChanged.connect(self.on_index_changed)
self.ui.le_exe.installEventFilter(self)
self.init()
def install_shortcuts(obj, actions, ide):
short = resources.get_shortcut
for action in actions:
short_key = action.get("shortcut", None)
action_data = action.get("action", None)
connect = action.get("connect", None)
shortcut = None
item_ui = None
func = None
if connect:
func = getattr(obj, connect, None)
if short_key and not action_data:
if isinstance(short_key, QKeySequence):
shortcut = QShortcut(short_key, ide)
else:
shortcut = QShortcut(short(short_key), ide)
if isinstance(func, collections.Callable):
ide.connect(shortcut, SIGNAL("activated()"), func)
if action_data:
is_menu = action_data.get('is_menu', False)
if is_menu:
item_ui = QMenu(action_data['text'], ide)
else:
item_ui = QAction(action_data['text'], ide)
object_name = "%s.%s" % (obj.__class__.__name__, connect)
item_ui.setObjectName(object_name)
image_name = action_data.get('image', None)
section = action_data.get('section', None)
weight = action_data.get('weight', None)
keysequence = action_data.get('keysequence', None)
if image_name:
if isinstance(image_name, int):
icon = ide.style().standardIcon(image_name)
item_ui.setIcon(icon)
elif isinstance(image_name, str):
icon = QIcon(":img/" + image_name)
item_ui.setIcon(icon)
if short_key and not is_menu:
item_ui.setShortcut(short(short_key))
elif keysequence:
item_ui.setShortcut(short(keysequence))
if isinstance(func, collections.Callable) and not is_menu:
ide.connect(item_ui, SIGNAL("triggered()"), func)
if section and weight:
ide.register_menuitem(item_ui, section, weight)
if image_name and not is_menu:
ide.register_toolbar(item_ui, section, weight)
if short_key and shortcut:
ide.register_shortcut(short_key, shortcut, item_ui)
def _context_menu_requested(self, point):
"""Display context menu for the combo file."""
if self.combo.count() == 0:
# If there is not an Editor opened, don't show the menu
return
menu = QMenu()
actionAdd = menu.addAction(translations.TR_ADD_TO_PROJECT)
actionRun = menu.addAction(translations.TR_RUN_FILE)
menuSyntax = menu.addMenu(translations.TR_CHANGE_SYNTAX)
self._create_menu_syntax(menuSyntax)
menu.addSeparator()
actionClose = menu.addAction(translations.TR_CLOSE_FILE)
actionCloseAll = menu.addAction(translations.TR_CLOSE_ALL_FILES)
actionCloseAllNotThis = menu.addAction(
translations.TR_CLOSE_OTHER_FILES)
menu.addSeparator()
actionSplitH = menu.addAction(translations.TR_SPLIT_VERTICALLY)
actionSplitV = menu.addAction(translations.TR_SPLIT_HORIZONTALLY)
menu.addSeparator()
actionCopyPath = menu.addAction(
translations.TR_COPY_FILE_PATH_TO_CLIPBOARD)
actionShowFileInExplorer = menu.addAction(
translations.TR_SHOW_FILE_IN_EXPLORER)
actionReopen = menu.addAction(translations.TR_REOPEN_FILE)
actionUndock = menu.addAction(translations.TR_UNDOCK_EDITOR)
if len(settings.LAST_OPENED_FILES) == 0:
actionReopen.setEnabled(False)
#Connect actions
self.connect(actionSplitH, SIGNAL("triggered()"),
lambda: self._split(False))
self.connect(actionSplitV, SIGNAL("triggered()"),
lambda: self._split(True))
self.connect(actionRun, SIGNAL("triggered()"),
self._run_this_file)
self.connect(actionAdd, SIGNAL("triggered()"),
self._add_to_project)
self.connect(actionClose, SIGNAL("triggered()"),
self.about_to_close_file)
self.connect(actionCloseAllNotThis, SIGNAL("triggered()"),
self._close_all_files_except_this)
self.connect(actionCloseAll, SIGNAL("triggered()"),
self._close_all_files)
self.connect(actionCopyPath, SIGNAL("triggered()"),
self._copy_file_location)
self.connect(actionShowFileInExplorer, SIGNAL("triggered()"),
self._show_file_in_explorer)
self.connect(actionReopen, SIGNAL("triggered()"),
self._reopen_last_tab)
self.connect(actionUndock, SIGNAL("triggered()"),
self._undock_editor)
menu.exec_(QCursor.pos())
def createTable(self, header, tabledata):
"""creates a table"""
gridlayout2 = QGridLayout(self)
gridlayout2.setObjectName("gridlayout2")
tableView = QTableView(self)
tableView.setObjectName("tableView")
gridlayout2.addWidget(tableView, 0, 0, 1, 1)
self.__popUp = QMenu(tableView)
self.__copyAction = QAction(self.tr("Copy data"), tableView)
self.connect(self.__copyAction, SIGNAL("triggered()"), self.copy)
self.__popUp.addAction(self.__copyAction)
tableView.setContextMenuPolicy(Qt.CustomContextMenu)
self.connect(tableView, SIGNAL('customContextMenuRequested(QPoint)'),
self.popUpMenu)
# set the table model
tm = TableModel(tabledata, header, self)
tableView.setModel(tm)
tableView.setAlternatingRowColors(True)
# set the minimum size
self.setMinimumSize(400, 300)
# hide grid
tableView.setShowGrid(True)
# set the font
#font = QFont("Courier New", 12)
#self.tableView.setFont(font)
# hide vertical header
vh = tableView.verticalHeader()
vh.setVisible(True)
# set horizontal header properties
hh = tableView.horizontalHeader()
hh.setStretchLastSection(True)
# set column width to fit contents
tableView.resizeColumnsToContents()
tableView.setSortingEnabled(True)
tableView.sortByColumn(0, Qt.AscendingOrder)
# set row height
nrows = len(tabledata)
for row in xrange(nrows):
tableView.setRowHeight(row, 18)
def createStandardContextMenu(self):
menu = QMenu(self)
self.add_toggle_action_to_menu(menu, str("Show A&ddress"),
self.show_address, self.setShowAddress)
self.add_toggle_action_to_menu(menu, str("Show &Hex"), self.show_hex,
self.setShowHexDump)
self.add_toggle_action_to_menu(menu, str("Show &ASCII"),
self.show_ascii, self.setShowAsciiDump)
menu.addSeparator()
menu.addAction(str("&Copy Selection To Clipboard"), self.mnuCopy)
return menu
def setup_menu(self, show_downloads=False):
self.menu = QMenu()
if show_downloads:
self.download = QAction(self.tr("Download Version: %s!" %
self.ide_version),
self, triggered=self._show_download)
self.menu.addAction(self.download)
self.menu.addSeparator()
self.quit_action = QAction(self.tr("Close Update Notifications"),
self, triggered=self.hide)
self.menu.addAction(self.quit_action)
self.setContextMenu(self.menu)
