def _add_menu_optional_actions(self, action_group, uimanager): if graphs.has_matplotlib: action = Gtk.Action(name='ToolsGraphMenu', label='Create Graph', tooltip=None, stock_id=None) action_group.add_action(action) for graph_name in graphs.get_graphs(): action_name = 'ToolsGraph' + graph_name action = Gtk.Action(name=action_name, label=graph_name, tooltip=graph_name, stock_id=None) action.connect('activate', lambda _: self.show_campaign_graph(graph_name)) action_group.add_action(action) merge_id = uimanager.new_merge_id() uimanager.add_ui(merge_id, '/MenuBar/ToolsMenu', 'ToolsGraphMenu', 'ToolsGraphMenu', Gtk.UIManagerItemType.MENU, False) for graph_name in graphs.get_graphs(): action_name = 'ToolsGraph' + graph_name uimanager.add_ui(merge_id, '/MenuBar/ToolsMenu/ToolsGraphMenu', action_name, action_name, Gtk.UIManagerItemType.MENUITEM, False) if sys.platform.startswith('linux'): action = Gtk.Action(name='ToolsSFTPClient', label='SFTP Client', tooltip='SFTP Client', stock_id=None) action.connect('activate', lambda x: self.start_sftp_client()) action_group.add_action(action) merge_id = uimanager.new_merge_id() uimanager.add_ui(merge_id, '/MenuBar/ToolsMenu', 'ToolsSFTPClient', 'ToolsSFTPClient', Gtk.UIManagerItemType.MENUITEM, False)
def add_choices_menu_actions(self, action_group): action_group.add_action( Gtk.Action("ChoicesMenu", "Choices", None, None)) action_group.add_radio_actions( [("ChoiceOne", None, "One", None, None, 1), ("ChoiceTwo", None, "Two", None, None, 2)], 1, self.on_menu_choices_changed) three = Gtk.ToggleAction("ChoiceThree", "Three", None, None) three.connect("toggled", self.on_menu_choices_toggled) action_group.add_action(three) ad = Gtk.Action('DisabledAction', 'Disabled Action', None, None) ad.set_sensitive(False) action_group.add_action(ad) ia = Gtk.Action('InvisibleAction', 'Invisible Action', None, None) ia.set_visible(False) action_group.add_action(ia) ta = Gtk.Action('TooltipAction', 'Tooltip Action', 'A tooltip', None) action_group.add_action(ta) action_group.add_action( Gtk.Action('IconAction', 'Icon Action', None, None))
def do_activate(self): self._totem = self.object totem_object = self.object data = dict() manager = totem_object.get_ui_manager() data['action_group'] = Gtk.ActionGroup('Python') action = Gtk.Action('Sleep', 'Sleep', _('System Shutdown Menu'), None) data['action_group'].add_action(action) action = Gtk.Action('SleepConfigure', _('_Configure'), _("Show Totem's Python console"), 'gnome-mime-text-x-python') action.connect('activate', self.show_config, totem_object) data['action_group'].add_action(action) manager.insert_action_group(data['action_group'], 0) data['ui_id'] = manager.add_ui_from_string(ui_str) manager.ensure_update() totem_object.ShutdownPluginInfo = data
def add_file_menu_actions(self, action_group): action_filemenu = Gtk.Action("FileMenu", "File", None, None) action_group.add_action(action_filemenu) action_filenewmenu = Gtk.Action("FileNew", None, None, Gtk.STOCK_NEW) action_group.add_action(action_filenewmenu) action_new = Gtk.Action("FileNewStandard", "_New", "Create a new file", Gtk.STOCK_NEW) action_new.connect("activate", self.on_menu_file_new_generic) action_group.add_action_with_accel(action_new, None) action_group.add_actions([ ("FileNewFoo", None, "New Foo", None, "Create new foo", self.on_menu_file_new_generic), ("FileNewGoo", None, "_New Goo", None, "Create new goo", self.on_menu_file_new_generic), ]) action_filequit = Gtk.Action("FileQuit", None, None, Gtk.STOCK_QUIT) action_filequit.connect("activate", self.on_menu_file_quit) action_group.add_action(action_filequit)
def do_activate(self): self.__action = Gtk.Action( name='SendTo', label=_('Send to...'), tooltip=_('Send files by mail, instant message...'), stock_id='') shell = self.object self.__action.connect('activate', self.send_to, shell) self.__action_group = Gtk.ActionGroup(name='SendToActionGroup') self.__action_group.add_action(self.__action) shell.get_ui_manager().insert_action_group(self.__action_group, -1) self.__ui_id = shell.get_ui_manager().add_ui_from_string(ui_definition)
def create_menu_item(self): """ Create a menu item in the "Tools" menu. """ action = gtk.Action("RegexSearch", _("Regular expression..."), _("Search using regular expressions"), None) action.connect("activate", self.on_open_regex_dialog) action_group = gtk.ActionGroup("RegexSearchActions") action_group.add_action_with_accel(action, "<control>r") manager = self._window.get_ui_manager() manager.insert_action_group(action_group, -1) manager.add_ui_from_string(ui_str)
def _insert_menu(self): manager = self._window.get_ui_manager() self._action_group = Gtk.ActionGroup("FuzzyOpenPluginActions") fuzzyopen_action = Gtk.Action(name="FuzzyOpenAction", label="Fuzzy Open...\t", tooltip="Open file by autocomplete...", stock_id=Gtk.STOCK_JUMP_TO) fuzzyopen_action.connect("activate", lambda a: self.on_fuzzyopen_action()) self._action_group.add_action_with_accel(fuzzyopen_action, "<Ctrl><Shift>o") manager.insert_action_group(self._action_group) self._ui_id = manager.add_ui_from_string(ui_str) manager.ensure_update()
def __init__(self, callbacks): super(ContextualMenu, self).__init__() for callback in callbacks: name = callback[0] label = self.menu_labels[name] action = Gtk.Action(name=name, label=label, tooltip=None, stock_id=None) action.connect('activate', callback[1]) menuitem = action.create_menu_item() menuitem.action_id = name self.append(menuitem) self.show_all()
def do_activate(self): self.xplayer = self.object data = dict() manager = self.xplayer.get_ui_manager() data['action_group'] = Gtk.ActionGroup(name='Python') action = Gtk.Action(name='Python', label='Python', tooltip=_(u'Python Console Menu'), stock_id=None) data['action_group'].add_action(action) action = Gtk.Action(name='PythonConsole', label=_(u'_Python Console'), tooltip=_(u"Show Xplayer's Python console"), stock_id='gnome-mime-text-x-python') action.connect('activate', self._show_console) data['action_group'].add_action(action) action = Gtk.Action (name = 'PythonDebugger', label = _(u'Python Debugger'), tooltip = _(u"Enable remote Python debugging "\ "with rpdb2"), stock_id = None) if HAVE_RPDB2: action.connect('activate', self._enable_debugging) else: action.set_visible(False) data['action_group'].add_action(action) manager.insert_action_group(data['action_group'], 0) data['ui_id'] = manager.add_ui_from_string(UI_STR) manager.ensure_update() self.xplayer.PythonConsolePluginInfo = data
def __init__(self, structure, conditions, callbacks, action_group): """ @param structure: Menu structure @type structure: list Note on "structure". The menu structure is defined in a list of tuples of two elements each. The first element is a class - the MenuItem subclass that defines the menu interface (see below). The second element is either None (if there is no submenu) or a list of tuples if there is a submenu. The submenus are generated recursively. FYI, this is a list of tuples so that we retain the desired menu item order (dicts do not retain order) Example: [ (MenuClassOne, [ (MenuClassOneSubA, (MenuClassOneSubB ]), (MenuClassTwo, (MenuClassThree ] """ self.action_group = action_group for item_class in structure: item = item_class(conditions, callbacks) default_name = MenuItem.make_default_name(item.identifier) action = Gtk.Action(item.identifier, item.label, item.tooltip, item.icon) if item.icon and hasattr(action, "set_icon_name"): action.set_icon_name(item.icon) if item.callback: if item.callback_args: action.connect("activate", item.callback, item.callback_args) else: action.connect("activate", item.callback) action.set_property("visible", item.show()) setattr(action, "item", item) self.action_group.add_action(action)
def build_menus(self): action_group = Gtk.ActionGroup("global_actions") # Create Import menu action_import_menu = Gtk.Action("ImportMenu", "Import", None, None) action_group.add_action(action_import_menu) action_import_opml = Gtk.Action("ImportOPML", "_Import OPML", "Import feeds from OPML file", Gtk.STOCK_FILE) action_import_opml.connect("activate", self.on_menu_import, "OPML") action_group.add_action(action_import_opml) action_import_file = Gtk.Action("ImportFeedFile", "_Import Feeds File", "Import feeds from file", Gtk.STOCK_FILE) action_import_file.connect("activate", self.on_menu_import, "FEEDS") action_group.add_action(action_import_file) # Create Export menu action_export_menu = Gtk.Action("ExportMenu", "Export", None, None) action_group.add_action(action_export_menu) action_export_file = Gtk.Action("ExportFeedFile", "_Export Feeds File", "Export feeds to file", Gtk.STOCK_FILE) action_export_file.connect("activate", self.on_menu_export_feeds) action_group.add_action(action_export_file) # Setup UI manager self.ui_manager.add_ui_from_string(UI_INFO) self.add_accel_group(self.ui_manager.get_accel_group()) self.ui_manager.insert_action_group(action_group)
def __init__(self, allApps, *args): guiplugins.ActionDialogGUI.__init__(self, allApps, *args) self.directAccel = None self.directAction = Gtk.Action("Approve", "_Approve", self.getDirectTooltip(), self.getStockId()) self.directAction.connect("activate", self._respond) self.directAction.set_property("sensitive", False) self.addOption("v", "Version to approve", self.defaultVersionStr) self.addOption("old", "Version(s) to store previous results as") self.addSwitch("over", "Replace successfully compared files also", 0) if self.hasPerformance(allApps): self.addSwitch("ex", "Store", 1, ["Average performance", "Exact performance"]) # Must do this in the constructor, so that "Approve" also takes account of them for option in list(self.optionGroup.options.values()): self.addValuesFromConfig(option)
def get_test_window_availablepane(): # needed because available pane will try to get it vm = get_test_gtk3_viewmanager() assert vm is not None db = get_test_db() cache = get_test_pkg_info() icons = get_test_gtk3_icon_cache() backend = get_test_install_backend() distro = softwarecenter.distro.get_distro() manager = appmanager.get_appmanager() if manager is None: # create global AppManager instance manager = appmanager.ApplicationManager(db, backend, icons) navhistory_back_action = Gtk.Action("navhistory_back_action", "Back", "Back", None) navhistory_forward_action = Gtk.Action("navhistory_forward_action", "Forward", "Forward", None) zl = "softwarecenter.backend.zeitgeist_logger.ZeitgeistLogger" patch(zl + ".log_install_event").start().return_value = False patch(zl + ".log_uninstall_event").start().return_value = False patch("softwarecenter.utils.is_unity_running").start().return_value = False w = availablepane.AvailablePane(cache, db, distro, icons, navhistory_back_action, navhistory_forward_action) w.init_view() w.show() win = get_test_window(child=w, width=800, height=600) # this is used later in tests win.set_data("pane", w) win.set_data("vm", vm) return win
def add_choices_menu_actions(self, action_group): action_group.add_action(Gtk.Action(name="ChoicesMenu", label="Choices")) action_group.add_radio_actions( [ ("ChoiceOne", None, "One", None, None, 1), ("ChoiceTwo", None, "Two", None, None, 2), ], 1, self.on_menu_choices_changed, ) three = Gtk.ToggleAction(name="ChoiceThree", label="Three") three.connect("toggled", self.on_menu_choices_toggled) action_group.add_action(three)
def do_activate(self): shell = self.object print "Activating Random Album Plugin" action = Gtk.Action('RandomAlbum', _('Random Album'), _('Play a Random Album'), "") action.connect('activate', self.random_album, shell) action_group = Gtk.ActionGroup('RandomAlbumActionGroup') action_group.add_action_with_accel(action, "<alt>R") ui_manager = shell.props.ui_manager ui_manager.insert_action_group(action_group) self.ui_id = ui_manager.add_ui_from_string(random_album_menu_item) self.settings = Gio.Settings( 'org.gnome.rhythmbox.plugins.randomalbumplayer')
def add_edit_menu_actions(self, action_group): ''' Command项目的菜单设定。 ''' action_command_menu = Gtk.Action("MenuEdit", "Edit", None, None) action_group.add_action(action_command_menu) action_edit_execute = Gtk.Action("ItemExecute", None, None, Gtk.STOCK_EXECUTE) action_edit_execute.connect("activate", self.on_menu_edit_execute) action_group.add_action_with_accel(action_edit_execute, "<control>Return") self.action_edit_execute = action_edit_execute action_edit_keep = Gtk.Action("ItemKeep", "Keep", None, Gtk.STOCK_SAVE) action_edit_keep.connect("activate", self.on_menu_edit_keep) action_group.add_action_with_accel(action_edit_keep, "<control>k") self.action_edit_keep = action_edit_keep action_edit_undo = Gtk.Action("ItemUndo", None, None, Gtk.STOCK_UNDO) action_edit_undo.connect("activate", self.on_menu_edit_undo) action_group.add_action_with_accel(action_edit_undo, "<control>Left") self.action_edit_undo = action_edit_undo action_edit_restore = Gtk.Action("ItemRestore", "Restore", None, Gtk.STOCK_GOTO_FIRST) action_edit_restore.connect("activate", self.on_menu_edit_restore) action_group.add_action_with_accel(action_edit_restore, "<control>Home") self.action_edit_store = action_edit_restore
def merge(self): action_group = self.action_group = Gtk.ActionGroup( "GeditLineEndingStylePluginActions") action_group.set_translation_domain("gedit-line-ending-style-plugin") _ = lambda s: gettext.dgettext("gedit-line-ending-style-plugin", s) window = self.window statusbar = window.get_statusbar() sb_combo = self.sb_combo = GeditStatusComboBox.new(None) entries = [ ("GeditLineEndingStylePluginStatusComboToLFItem", "Unix/Linux", "Switch to Unix/Linux-style line endings (LF)", Gedit.DocumentNewlineType.LF, "LF"), ("GeditLineEndingStylePluginStatusComboToCRItem", "Mac OS Classic", "Switch to Mac OS Classic-style line endings (CR)", Gedit.DocumentNewlineType.CR, "CR"), ("GeditLineEndingStylePluginStatusComboToCRLFItem", "Windows", "Switch to Windows-style line endings (CRLF)", Gedit.DocumentNewlineType.CR_LF, "CRLF") ] for entry in entries: action = Gtk.Action(entry[0], _(entry[1]), _(entry[2]), None) action_group.add_action(action) item = action.create_menu_item() item.set_data(LineEndingStylePluginUI.ITEM_VALUE_KEY, entry[3]) activate_handler_id = item.connect("activate", self.__activate_item) item.set_data(LineEndingStylePluginUI.ITEM_ACTIVATE_HANDLER_ID_KEY, activate_handler_id) sb_combo.add_item(item, _(entry[4])) sb_combo.show_all() statusbar.pack_end(sb_combo, False, True, 0) doc = window.get_active_document() if doc: self.__update_state_per_document(doc) self.tab_added_handler_id = window.connect("tab-added", self.__tab_added) self.active_tab_changed_handler_id = window.connect( "active-tab-changed", self.__active_tab_changed) self.tab_removed_handler_id = window.connect("tab-removed", self.__tab_removed) for doc in window.get_documents(): self.__connect_document(doc)
def do_activate(self): shell = self.object self.action = Gtk.Action( 'OpenFolder', _('Open Containing Folder'), _('Open the folder that contains the selected song.'), 'rb-open-folder') self.activate_id = self.action.connect('activate', self.open_folder, shell) self.action_group = Gtk.ActionGroup('OpenFolderPluginActions') self.action_group.add_action(self.action) uim = shell.get_ui_manager() uim.insert_action_group(self.action_group, 0) self.ui_id = uim.add_ui_from_string(ui_str) uim.ensure_update()
def _create_application_actions(self): def callback(action, name): self.switch_application(name) self.application_actions = {} actions = [] for app in self.get_available_applications(): action = Gtk.Action(app.name, app.fullname, app.description, app.icon) action.connect('activate', callback, app.name) actions.append(action) self.application_actions[app.name] = action # By default, the menu comes with an 'Empty' item that we must hide self.HomeToolItem.get_proxies()[0].get_menu().get_children()[-1].hide() self.HomeToolItem.add_actions(self.uimanager, actions, add_separator=False)
def _insert_menu(self): # Get the GtkUIManager manager = self._window.get_ui_manager() self._menubar_menu = GeditMenu(self, self.vcs_client, self.base_dir, [self._get_document_path()]) self._menu_action = gtk.Action( name="RabbitVCSMenu", label="RabbitVCS", tooltip="Excellent Version Control for Linux", stock_id=None ) self._action_group = gtk.ActionGroup("RabbitVCSActions") self._action_group = self._menubar_menu.get_action_group(self._action_group) self._action_group.add_action( self._menu_action ) # Insert the action group manager.insert_action_group(self._action_group, 0) # Merge the UI self._ui_id = manager.add_ui_from_string(ui_str)
def add_menuitem(self, entry): """Add a menu item to the current menu Params: entry (tuple): tuple containing name, label and callback Returns: Gtk.MenuItem """ name, label, callback = entry action = Gtk.Action(name=name, label=label) action.connect("activate", callback) menu_item = action.create_menu_item() menu_item.action_id = name self.append(menu_item) return menu_item
def do_activate(self): self._action = Gtk.Action('InstallPlugins', 'Install Plugins', 'Easily discover and install plugins', None) self._action.connect("activate", self._run) self._actiongroup = Gtk.ActionGroup("InstallPlugins") self._actiongroup.add_action(self._action) self._ui_manager = self.shell.get_property("ui-manager") self._ui_manager.insert_action_group(self._actiongroup) self._ui_manager.add_ui_from_string("""<ui> <menubar name='MainwindowMenubar'> <menu action='ToolsMenu'> <menuitem action='InstallPlugins'/> </menu> </menubar> </ui>""")
def menuArchivo(self, action_group): ''' Pestaña 'Archivo' :param action_group: :return: ''' action_group.add_actions( [ ("archivo", None, "Archivo"), ("cargarImagen", None, 'Cargar', '<control>N', None, self.cargaImagen), ("guardarASCII", None, 'Guardar ASCII', "<control>G", None, self.guardar), ] ) action_filequit = Gtk.Action(name="FileQuit", stock_id=Gtk.STOCK_QUIT) action_filequit.connect("activate", self.cerrarVentana) action_group.add_action(action_filequit)
def add_about(self): group = Gtk.ActionGroup(name="xapp-status-applet-group") group.set_translation_domain("xapp") about_action = Gtk.Action(name="ShowAbout", icon_name="info", label=_("About"), visible=True) about_action.connect("activate", self.show_about) group.add_action(about_action) xml = '\ <menuitem name="ShowDesktopAboutItem" action="ShowAbout"/> \ ' self.applet.setup_menu(xml, group)
def __init__(self, allApps, dynamic, *args): guiplugins.ActionTabGUI.__init__(self, allApps) AllTestsHandler.__init__(self) self.dynamic = dynamic self.filterAccel = None self.filterAction = Gtk.Action("Filter", "Filter", self.getFilterTooltip(), self.getStockId()) self.filterAction.connect("activate", self.filterTests) self.selectDiag = logging.getLogger("Select Tests") self.addOption("vs", "Tests for version", description="Select tests for a specific version.", possibleValues=self.getPossibleVersions(allApps)) self.selectionGroup = plugins.OptionGroup(self.getTabTitle()) self.selectionGroup.addSwitch("select_in_collapsed_suites", "Select in collapsed suites", 0, description="Select in currently collapsed suites as well?") currSelectDesc = ["Unselect all currently selected tests before applying the new selection criteria.", "Apply the new selection criteria only to the currently selected tests, to obtain a subselection.", "Keep the currently selected tests even if they do not match the new criteria, and extend the selection with all other tests which meet the new criteria.", "After applying the new selection criteria to all tests, unselect the currently selected tests, to exclude them from the new selection."] self.selectionGroup.addSwitch("current_selection", options=["Discard", "Refine", "Extend", "Exclude"], description=currSelectDesc) self.filteringGroup = plugins.OptionGroup("Filtering") currFilterDesc = ["Show all tests which match the criteria, and hide all those that do not.", "Hide all tests which do not match the criteria. Do not show any tests that aren't already shown.", "Show all tests which match the criteria. Do not hide any tests that are currently shown."] self.filteringGroup.addSwitch("current_filtering", options=[ "Discard", "Refine", "Extend"], description=currFilterDesc) excludeKeys = set(self.optionGroup.keys()) # remember these so we don't try and save them to selections self.addApplicationOptions(allApps, self.optionGroup) appNames = set([app.name for app in allApps]) if len(appNames) > 1: self.addOption("app", "App names containing", description="Select tests for which the application name matches the entered text. The text can be a regular expression.") if self.hasPerformance(allApps, "performance"): self.optionGroup.moveToEnd(["r"]) self.addOption("fastest", "Only fastest tests", 0, description="Select the given number of tests which match the other selected criteria and have the fastest runtimes") self.addOption("slowest", "Only slowest tests", 0, description="Select the given number of tests which match the other selected criteria and have the longest runtimes") self.optionGroup.moveToEnd(["grep", "grepfile"]) if self.dynamic: self.addSwitch("std", options=["Use test-files from current run", "Use stored test-files"], description=["When searching using 'test-files containing', look in the results of tests in the current run", "When searching using 'test-files containing', look in the stored results, i.e. the same search as would be done in the static GUI"]) self.appKeys = set(self.optionGroup.keys()) self.appKeys.difference_update(excludeKeys)
def build_menus(self): action_group = Gtk.ActionGroup("global_actions") # Create Import menu action_import_menu = Gtk.Action("ImportMenu", _("Import"), None, None) action_group.add_action(action_import_menu) action_import_opml = Gtk.Action("ImportOPML", _("_Import OPML"), _("Import feeds from OPML file"), Gtk.STOCK_FILE) action_import_opml.connect("activate", self.on_menu_import, "OPML") action_group.add_action(action_import_opml) action_import_file = Gtk.Action("ImportFeedFile", _("_Import Feeds File"), _("Import feeds from file"), Gtk.STOCK_FILE) action_import_file.connect("activate", self.on_menu_import, "FEEDS") action_group.add_action(action_import_file) # Create Export menu action_export_menu = Gtk.Action("ExportMenu", _("Export"), None, None) action_group.add_action(action_export_menu) action_export_file = Gtk.Action("ExportFeedFile", _("_Export Feeds File"), _("Export feeds to file"), Gtk.STOCK_FILE) action_export_file.connect("activate", self.on_menu_export_feeds) action_group.add_action(action_export_file) # Create Option menu action_option_menu = Gtk.Action("OptionMenu", _("Options"), None, None) action_group.add_action(action_option_menu) action_toggle_hidden = Gtk.Action("ShowHideFields", _("_Toggle Hidden Fields"), _("Show or Hide hidden fields"), Gtk.STOCK_FILE) action_toggle_hidden.connect("activate", self.on_menu_toggle_hidden) action_group.add_action(action_toggle_hidden) # Setup UI manager self.ui_manager.add_ui_from_string(UI_INFO) self.add_accel_group(self.ui_manager.get_accel_group()) self.ui_manager.insert_action_group(action_group)
def add_menu_actions(window, actiongroup) -> None: """Add actions to application menu.""" actionfilemenu = Gtk.Action("FileMenu", language.MT_("File"), None, None) actiongroup.add_action(actionfilemenu) actionfilemenusave = Gtk.Action("save", language.MT_('Save'), None, Gtk.STOCK_SAVE) actionfilemenusave.connect("activate", save_tlp_config, window) actiongroup.add_action(actionfilemenusave) actionfilemenuquit = Gtk.Action("quit", language.MT_('Quit'), None, Gtk.STOCK_QUIT) actionfilemenuquit.connect("activate", quit_tlp_config, window) actiongroup.add_action(actionfilemenuquit) actionlanguagemenu = Gtk.Action("LanguageMenu", language.MT_("Language"), None, None) actiongroup.add_action(actionlanguagemenu) zhlanguagesubmenu = Gtk.Action("zhSubMenu", "zh", None, None) actiongroup.add_action(zhlanguagesubmenu) actionhelpmenu = Gtk.Action("HelpMenu", language.MT_("Help"), None, None) actiongroup.add_action(actionhelpmenu) aboutdialogmenu = Gtk.Action("AboutDialog", language.MT_("About"), None, Gtk.STOCK_INFO) actiongroup.add_action(aboutdialogmenu) aboutdialogmenu.connect('activate', show_about_dialog) langdir = Path(settings.langdir) for langobject in langdir.iterdir(): if langobject.is_dir(): locale = langobject.name if locale == settings.userconfig.language: actionlang = Gtk.Action(locale, locale, None, Gtk.STOCK_APPLY) else: actionlang = Gtk.Action(locale, locale, None, None) actionlang.connect("activate", switch_language, locale, window) actiongroup.add_action(actionlang)
def menuArchivo(self, action_group): ''' Pestaña 'Archivo' :param action_group: :return: ''' action_group.add_actions([ ("archivo", None, "Archivo"), ("cargarInicio", None, 'Cargar', '<control>N', None, self.cargaEstado), ("guardarSimulacion", None, 'Guardar Estado', "<control>G", None, self.guardarEstado), ("random", None, 'Configuracion Random', "<control>R", None, self.random), ]) action_filequit = Gtk.Action(name="FileQuit", stock_id=Gtk.STOCK_QUIT) action_filequit.connect("activate", self.cerrarVentana) action_group.add_action(action_filequit)
def __init__(self): self._ui = None self.default_store = get_default_store() self._printer_verified = False # Delay printer creation until we are accessing pos or till app. Other # applications should still be accessible without a printer self._printer = None self._setup_params() self._setup_events() self._till_summarize_action = Gtk.Action( 'Summary', _('Summary'), None, None) self._till_summarize_action.connect( 'activate', self._on_TillSummary__activate) add_bindings([ ('plugin.ecf.read_memory', '<Primary>F9'), ('plugin.ecf.summarize', '<Primary>F11'), ])
def add_command_group_menu_actions(self, action_group): ''' Command Group项目的菜单设定。 ''' action_command_menu = Gtk.Action("CommandGroupMenu", "CommandGroup", None, None) action_group.add_action(action_command_menu) action_command_group_new = Gtk.Action("CommandGroupNew", None, "Create a command group", Gtk.STOCK_NEW) action_command_group_new.connect("activate", self.on_menu_command_group_new) action_group.add_action_with_accel(action_command_group_new, "<control>N") self.action_command_group_new = action_command_group_new action_command_group_open = Gtk.Action("CommandGroupOpen", None, "Open a command group", Gtk.STOCK_OPEN) action_command_group_open.connect("activate", self.on_menu_command_group_open) action_group.add_action_with_accel(action_command_group_open, "<control>O") self.action_command_group_open = action_command_group_open action_command_group_close = Gtk.Action("CommandGroupClose", None, "Close current command group", Gtk.STOCK_CLOSE) action_command_group_close.connect("activate", self.on_menu_command_group_close) action_group.add_action_with_accel(action_command_group_close, "<control>W") self.action_command_group_close = action_command_group_close action_command_group_save = Gtk.Action("CommandGroupSave", None, "Save current command group", Gtk.STOCK_SAVE) action_command_group_save.connect("activate", self.on_menu_command_group_save) action_group.add_action_with_accel(action_command_group_save, "<control>S") self.action_command_group_save = action_command_group_save action_command_group_delete = Gtk.Action( "CommandGroupDelete", None, "Delete current command group", Gtk.STOCK_DELETE) action_command_group_delete.connect("activate", self.on_menu_command_group_delete) action_group.add_action(action_command_group_delete) self.action_command_group_delete = action_command_group_delete