def popup_menu(icon, button, tm, none): menu = gtk.Menu() #item = gtk.ImageMenuItem(gtk.STOCK_QUIT) #item.connect("activate", quit_finch, None) #menu.append(item) item = gtk.ImageMenuItem(gtk.STOCK_CLOSE) item.connect("activate", close_docklet, None) menu.append(item) menu.append(gtk.MenuItem()) item = gtk.CheckMenuItem("Blink for unread IM") item.set_active(purple.PurplePrefsGetBool("/plugins/dbus/docklet/blink/im")) item.connect("activate", toggle_pref, "/plugins/dbus/docklet/blink/im") menu.append(item) item = gtk.CheckMenuItem("Blink for unread Chats") item.set_active(purple.PurplePrefsGetBool("/plugins/dbus/docklet/blink/chat")) item.connect("activate", toggle_pref, "/plugins/dbus/docklet/blink/chat") menu.append(item) menu.append(gtk.MenuItem()) #item = pack_image_label(menu, None, "Change Status...") item = gtk.MenuItem("Change Status...") menu.append(item) submenu = gtk.Menu() item.set_submenu(submenu) generate_status_menu(submenu) menu.show_all() menu.popup(None, None, None, button, tm)
def refresh(self, devices): """ Fire this method with the list of devices to display in order to refresh the menu. If there is only one device, the "Natural scrolling" menu item will be a gtk.CheckMenuItem, but if there are more than one devcice, then "Natural scrolling" menu item will be a gtk.Menu of gtk.CheckMenuItem per device. """ if self.__natural_scrolling: self.remove(self.__natural_scrolling) self.__natural_scrolling = None if len(devices) == 1: self.__natural_scrolling = gtk.CheckMenuItem("Natural Scrolling") self.__natural_scrolling.set_tooltip_text(devices[0].keys()[0]) self.__natural_scrolling.connect("toggled", self.on_natural_scrolling_toggled) self.__natural_scrolling.show() else: self.__natural_scrolling = gtk.MenuItem("Natural Scrolling") self.__natural_scrolling.show() devices_menu = gtk.Menu() for device in devices: sub_item = gtk.CheckMenuItem(device.values()[0]) sub_item.set_tooltip_text(device.keys()[0]) devices_menu.append(sub_item) sub_item.connect("toggled", self.on_natural_scrolling_toggled) sub_item.show() self.__natural_scrolling.set_submenu(devices_menu) self.insert(self.__natural_scrolling, 0) self.sync_checked_items_from_gconf()
def make_menu(event_button, event_time, data=None): menu = gtk.Menu() profiles_submenu = gtk.Menu() profiles_item = gtk.MenuItem("Power Profiles") profiles_item.set_submenu(profiles_submenu) performance_item = gtk.MenuItem("High Performance") balanced_item = gtk.MenuItem("Balanced") battery_item = gtk.MenuItem("Battery Life") profiles_submenu.append(performance_item) profiles_submenu.append(balanced_item) profiles_submenu.append(battery_item) graphics_submenu = gtk.Menu() graphics_item = gtk.MenuItem("Graphics") graphics_item.set_submenu(graphics_submenu) intel_item = gtk.CheckMenuItem("Intel Graphics") nvidia_item = gtk.CheckMenuItem("Nvidia Graphics") if selected_graphics_card() == "intel": intel_item.set_active(True) else: nvidia_item.set_active(True) graphics_submenu.append(intel_item) graphics_submenu.append(nvidia_item) firmware_item = gtk.MenuItem("Update Firmware") exit_item = gtk.MenuItem("Exit") #Append the menu items menu.append(profiles_item) menu.append(graphics_item) menu.append(gtk.SeparatorMenuItem()) menu.append(firmware_item) menu.append(gtk.SeparatorMenuItem()) menu.append(exit_item) #add callbacks performance_item.connect_object("activate", select_power_profile, "performance") balanced_item.connect_object("activate", select_power_profile, "balanced") battery_item.connect_object("activate", select_power_profile, "battery") intel_item.connect_object("activate", select_graphics_card, "intel") nvidia_item.connect_object("activate", select_graphics_card, "nvidia") firmware_item.connect_object("activate", update_firmware, "Firmware") exit_item.connect_object("activate", exit_app, "Exit") #Show the menu items menu.show_all() #Popup the menu menu.popup(None, None, None, event_button, event_time)
def __init__(self, main_instance): """ Constructor """ gtk.Menu.__init__(self) self.main = main_instance self.toggle_mute = gtk.CheckMenuItem(_("Mute")) self.toggle_mute.set_active(self.main.alsactrl.is_muted()) self.mute_handler_id = self.toggle_mute.connect( "toggled", self.on_toggle_mute) self.add(self.toggle_mute) self.toggle_mixer = gtk.CheckMenuItem(_("Show Mixer")) self.toggle_mixer.set_active(self.main.mixer_get_active()) self.mixer_handler_id = self.toggle_mixer.connect( "toggled", self.on_toggle_mixer) self.add(self.toggle_mixer) item = gtk.ImageMenuItem("gtk-preferences") item.connect("activate", self.show_preferences) self.add(item) item = gtk.ImageMenuItem("gtk-quit") item.connect("activate", self.main.quit) self.add(item) self.show_all()
def generate_menu(self): """Generates the checklist menu for all the tabs and attaches it""" menu = gtk.Menu() # Create 'All' menuitem and a separator menuitem = gtk.CheckMenuItem(self.translate_tabs["All"], True) menuitem.set_name("All") all_tabs = True for key in self.tabs: if not self.tabs[key].is_visible: all_tabs = False break menuitem.set_active(all_tabs) menuitem.connect("toggled", self._on_menuitem_toggled) menu.append(menuitem) menuitem = gtk.SeparatorMenuItem() menu.append(menuitem) # Create a list in order of tabs to create menu menuitem_list = [] for tab_name in self.tabs: menuitem_list.append((self.tabs[tab_name].weight, tab_name)) menuitem_list.sort() for pos, name in menuitem_list: menuitem = gtk.CheckMenuItem(self.translate_tabs[name], True) menuitem.set_name(name) menuitem.set_active(self.tabs[name].is_visible) menuitem.connect("toggled", self._on_menuitem_toggled) menu.append(menuitem) self.menu_tabs.set_submenu(menu) self.menu_tabs.show_all()
def get_menuitems(self): """Return the menuitems specific to this view.""" items = [] self.headings_menu_item = gtk.CheckMenuItem( 'Toggle _Hide Task Headings') self.headings_menu_item.set_active(self.t.should_hide_headings) items.append(self.headings_menu_item) self.headings_menu_item.show() self.headings_menu_item.connect('toggled', self.toggle_headings) self.group_menu_item = gtk.CheckMenuItem('Toggle _Family Grouping') self.group_menu_item.set_active(self.t.should_group_families) items.append(self.group_menu_item) self.group_menu_item.connect('toggled', self.toggle_grouping) self.transpose_menu_item = gtk.CheckMenuItem('Toggle _Transpose View') self.transpose_menu_item.set_active(self.t.should_transpose_view) items.append(self.transpose_menu_item) self.transpose_menu_item.connect('toggled', self.toggle_transpose) if self.cfg.use_defn_order: self.defn_order_menu_item = gtk.CheckMenuItem( 'Toggle _Definition Order') self.defn_order_menu_item.set_active(self.t.defn_order_on) items.append(self.defn_order_menu_item) self.defn_order_menu_item.connect('toggled', self.toggle_defn_order) return items
def menu_setup(self): self.menu = gtk.Menu() self.BTCtickers = None self.btceBTC = gtk.RadioMenuItem(self.BTCtickers, "BTC-E") self.btceBTC.connect("activate", lambda x: self.toggleBTCdisplay("btce")) self.btceBTC.show() self.BTCtickers = self.btceBTC self.mtgoxBTC = gtk.RadioMenuItem(self.BTCtickers, "MtGox") self.mtgoxBTC.connect("activate", lambda x: self.toggleBTCdisplay("mtgox")) self.mtgoxBTC.show() self.BTCtickers = self.mtgoxBTC self.bitstampBTC = gtk.RadioMenuItem(self.BTCtickers, "BitStamp") self.bitstampBTC.connect("activate", lambda x: self.toggleBTCdisplay("bitstamp")) self.bitstampBTC.show() self.BTCtickers = self.bitstampBTC self.blockchainBTC = gtk.RadioMenuItem(self.BTCtickers, "BlockChain") self.blockchainBTC.connect( "activate", lambda x: self.toggleBTCdisplay("blockchain")) self.blockchainBTC.show() self.BTCtickers = self.blockchainBTC self.defSet = gtk.MenuItem("Choose exchange : ") self.defSet.show() self.menu.append(self.defSet) self.menu.append(self.mtgoxBTC) self.menu.append(self.btceBTC) self.menu.append(self.bitstampBTC) self.menu.append(self.blockchainBTC) self.setRefreshMenu(self.menu) self.ltcAdd = gtk.CheckMenuItem("LTC Price") self.ltcAdd.connect("activate", self.initLTCAddOn) if self.LTCMODE: self.ltcAdd.activate() self.ltcAdd.show() self.menu.append(self.ltcAdd) self.nmcAdd = gtk.CheckMenuItem("NMC Price") self.nmcAdd.connect("activate", self.initNMCAddOn) if self.NMCMODE: self.nmcAdd.activate() self.nmcAdd.show() self.menu.append(self.nmcAdd) self.getNewPricesBTC() self.about = gtk.MenuItem("About") self.about.connect("activate", self.menu_about_response) self.about.show() self.menu.append(self.about) self.quit_item = gtk.MenuItem("Quit Indicator") self.quit_item.connect("activate", self.quit) self.quit_item.show() self.menu.append(self.quit_item)
def get_menuitems(self): """Return the menu items specific to this view.""" items = [] autoex_item = gtk.CheckMenuItem('Toggle _Auto-Expand Tree') autoex_item.set_active(self.t.autoexpand) items.append(autoex_item) autoex_item.connect('activate', self.toggle_autoexpand) self.group_menu_item = gtk.CheckMenuItem('Toggle _Family Grouping') self.group_menu_item.set_active(self.t.should_group_families) items.append(self.group_menu_item) self.group_menu_item.connect('toggled', self.toggle_grouping) return items
def populate_popup_cb(self, webview, menu): item = gtk.MenuItem(label="Source Edition") menu.append(item) submenu = gtk.Menu() menuitem = gtk.MenuItem(label="Loaded Source or File Source") menuitem.connect('activate', self.edit_source_activated_cb) submenu.append(menuitem) menuitem = gtk.MenuItem(label="Interpreted Source (JS useful)") menuitem.connect('activate', self.edit_loaded_activated_cb) submenu.append(menuitem) item.set_submenu(submenu) # ------------------------------- menu.append(gtk.SeparatorMenuItem()) # ------------------------------- item = gtk.ImageMenuItem(stock_id=gtk.STOCK_HOME) item.connect('activate', self.go_home_activated_cb) item.set_property('label', 'Starting Page') menu.append(item) # ------------------------------- menu.append(gtk.SeparatorMenuItem()) # ------------------------------- self.append_plugins_submenu(menu) item = gtk.MenuItem(label="Server Config") menu.append(item) submenu = gtk.Menu() menuitem = gtk.CheckMenuItem(label="Enable Server") menuitem.connect('toggled', self.toggle_serveur_activated_cb) menuitem.set_property('active', self.flag_serveur) submenu.append(menuitem) menuitem = gtk.RadioMenuItem(None, "Localhost Acces Only") menuitem.connect('toggled', self.toggle_local_acces_activated_cb) menuitem.set_property('active', self.flag_local_acces) menuitem.set_property('sensitive', self.flag_serveur) submenu.append(menuitem) menuitem = gtk.RadioMenuItem(menuitem, "Global Acces") menuitem.connect('toggled', self.toggle_general_acces_activated_cb) menuitem.set_property('active', not self.flag_local_acces) menuitem.set_property('sensitive', self.flag_serveur) submenu.append(menuitem) item.set_submenu(submenu) # ------------------------------- menu.append(gtk.SeparatorMenuItem()) # ------------------------------- item = gtk.CheckMenuItem(label="Auto Refresh") item.connect('toggled', self.toggle_auto_refresh_cb) item.set_property('active', self.auto_refresh) menu.append(item) item = gtk.MenuItem(label="Panel location") item.connect('activate', self.toggle_view_activated_cb) menu.append(item) menu.show_all()
def get_menuitems(self): """Return the menu items specific to this view.""" items = [] graph_range_item = gtk.MenuItem('Time Range Focus ...') items.append(graph_range_item) graph_range_item.connect('activate', self.graph_timezoom_popup) crop_item = gtk.CheckMenuItem('Toggle _Crop Base Graph') items.append(crop_item) crop_item.set_active(self.t.crop) crop_item.connect('activate', self.toggle_crop) self.menu_group_item = gtk.ImageMenuItem('_Group All Families') img = gtk.image_new_from_stock('group', gtk.ICON_SIZE_MENU) self.menu_group_item.set_image(img) items.append(self.menu_group_item) self.menu_group_item.connect('activate', self.group_all, True) self.menu_ungroup_item = gtk.ImageMenuItem('_UnGroup All Families') img = gtk.image_new_from_stock('ungroup', gtk.ICON_SIZE_MENU) self.menu_ungroup_item.set_image(img) items.append(self.menu_ungroup_item) self.menu_ungroup_item.connect('activate', self.group_all, False) menu_left_to_right_item = gtk.CheckMenuItem( '_Transpose Graph') items.append(menu_left_to_right_item) menu_left_to_right_item.set_active(self.t.orientation == "LR") menu_left_to_right_item.connect('activate', self.toggle_left_to_right_mode) self.menu_subgraphs_item = gtk.CheckMenuItem( '_Organise by Cycle Point') items.append(self.menu_subgraphs_item) self.menu_subgraphs_item.set_active(self.t.subgraphs_on) self.menu_subgraphs_item.connect('activate', self.toggle_cycle_point_subgraphs) igsui_item = gtk.CheckMenuItem('_Ignore Suicide Triggers') items.append(igsui_item) igsui_item.set_active(self.t.ignore_suicide) igsui_item.connect('activate', self.toggle_ignore_suicide_triggers) self.menu_frames_item = gtk.CheckMenuItem('_Write Graph Frames') items.append(self.menu_frames_item) self.menu_frames_item.set_active(self.t.write_dot_frames) self.menu_frames_item.connect( 'activate', self.toggle_write_dot_frames) return items
def _popup_view_menu(self, widget, event): # Create a menu below the widget for view options. menu = gtk.Menu() meta_menuitem = gtk.CheckMenuItem(label="Show expanded value info") if len(self.column_names) == len(self._visible_metadata_columns): meta_menuitem.set_active(True) meta_menuitem.connect("toggled", self._toggle_show_more_info) meta_menuitem.show() if not self.stash_meta_lookup: meta_menuitem.set_sensitive(False) menu.append(meta_menuitem) col_title_menuitem = gtk.CheckMenuItem( label="Show expanded column titles") if self._should_show_meta_column_titles: col_title_menuitem.set_active(True) col_title_menuitem.connect("toggled", self._toggle_show_meta_column_titles) col_title_menuitem.show() if not self.stash_meta_lookup: col_title_menuitem.set_sensitive(False) menu.append(col_title_menuitem) sep = gtk.SeparatorMenuItem() sep.show() menu.append(sep) show_column_menuitem = gtk.MenuItem("Show/hide columns") show_column_menuitem.show() show_column_menu = gtk.Menu() show_column_menuitem.set_submenu(show_column_menu) menu.append(show_column_menuitem) for i, column in enumerate(self._view.get_columns()): col_name = self.column_names[i] col_title = col_name.replace("_", "__") if self._should_show_meta_column_titles: col_meta = self.stash_meta_lookup.get(col_name, {}) title = col_meta.get(rose.META_PROP_TITLE) if title is not None: col_title = title col_menuitem = gtk.CheckMenuItem(label=col_title, use_underline=False) col_menuitem.show() col_menuitem.set_active(column.get_visible()) col_menuitem._connect_args = (col_name, ) col_menuitem.connect( "toggled", lambda c: self._toggle_show_column_name(*c._connect_args)) show_column_menu.append(col_menuitem) menu.popup(None, None, widget.position_menu, event.button, event.time, widget)
def on_populate_popup(self, treeview, menu): # Add a popup menu item to switch the treeview mode populate_popup_add_separator(menu, prepend=True) item = gtk.CheckMenuItem(_('Show full page name')) # T: menu option item.set_active(self.uistate['show_full_page_name']) item.connect_object('toggled', self.__class__.toggle_show_full_page_name, self) menu.prepend(item) item = gtk.CheckMenuItem(_('Sort pages by tags')) # T: menu option item.set_active(self.uistate['treeview'] == 'tags') item.connect_object('toggled', self.__class__.toggle_treeview, self) menu.prepend(item) menu.show_all()
def create_checklist_menu(self): """Creates a menu used for toggling the display of columns.""" menu = self.menu = gtk.Menu() # Iterate through the column_index list to preserve order for name in self.column_index: column = self.columns[name] # If the column is hidden, then we do not want to show it in the # menu. if column.hidden is True: continue menuitem = gtk.CheckMenuItem(column.name) # If the column is currently visible, make sure it's set active # (or checked) in the menu. if column.column.get_visible() is True: menuitem.set_active(True) # Connect to the 'toggled' event menuitem.connect('toggled', self.on_menuitem_toggled) # Add the new checkmenuitem to the menu menu.append(menuitem) # Attach this new menu to all the checklist_menus for _menu in self.checklist_menus: _menu.set_submenu(menu) _menu.show_all() return menu
def open_menu(self, icon, button, time): """ The right click action for the status icon; launches a menu with various options """ menu = gtk.Menu() menu.set_border_width(5) config = gtk.MenuItem("Configure") about = gtk.MenuItem("About") quit = gtk.MenuItem("Quit") config.connect("activate", self.show_config_dialog) about.connect("activate", self.show_about_dialog) quit.connect("activate", self.quit) silenced = gtk.CheckMenuItem("Silence Mail") silenced.connect("button-press-event", self.toggle_silenced) silenced.set_active(self.silenced) menu.append(config) menu.append(silenced) menu.append(about) menu.append(quit) menu.show_all() menu.popup(None, None, gtk.status_icon_position_menu, button, time, self.statusicon)
def __init__(self, args): # Load the database home = expanduser("~") with open(home + '/.hackertray.json', 'a+') as content_file: content_file.seek(0) content = content_file.read() try: self.db = set(json.loads(content)) except ValueError: self.db = set() # create an indicator applet self.ind = appindicator.Indicator("Hacker Tray", "hacker-tray", appindicator.CATEGORY_APPLICATION_STATUS) self.ind.set_status(appindicator.STATUS_ACTIVE) self.ind.set_icon(get_icon_filename("hacker-tray.png")) # create a menu self.menu = gtk.Menu() # The default state is false, and it toggles when you click on it self.commentState = args.comments # create items for the menu - refresh, quit and a separator menuSeparator = gtk.SeparatorMenuItem() menuSeparator.show() self.menu.append(menuSeparator) btnComments = gtk.CheckMenuItem("Show Comments") btnComments.show() btnComments.set_active(args.comments) btnComments.connect("activate", self.toggleComments) self.menu.append(btnComments) btnAbout = gtk.MenuItem("About") btnAbout.show() btnAbout.connect("activate", self.showAbout) self.menu.append(btnAbout) btnRefresh = gtk.MenuItem("Refresh") btnRefresh.show() # the last parameter is for not running the timer btnRefresh.connect("activate", self.refresh, True, args.chrome) self.menu.append(btnRefresh) if Version.new_available(): btnUpdate = gtk.MenuItem("New Update Available") btnUpdate.show() btnUpdate.connect('activate', self.showUpdate) self.menu.append(btnUpdate) btnQuit = gtk.MenuItem("Quit") btnQuit.show() btnQuit.connect("activate", self.quit) self.menu.append(btnQuit) self.menu.show() self.ind.set_menu(self.menu) self.refresh(chrome_data_directory=args.chrome, firefox_data_directory=args.firefox) self.launch_analytics(args)
def createMenu(self): menu = gtk.Menu() item = gtk.MenuItem("Select _All") menu.append(item) item.connect("activate", self.selectAll) item.show() item = gtk.MenuItem("Save Selected Data...") menu.append(item) item.connect("activate", self.saveSelectedData) item.show() item = gtk.CheckMenuItem("Follow Log") item.set_active(self.followLog) menu.append(item) item.connect("activate", self.followLogToggled) item.show() item = gtk.MenuItem("Filter") item.set_submenu(self.createFilterMenu()) menu.append(item) item.show() return menu
def __init__(self, controller, msn, action=None): '''Contructor''' self.theme = controller.theme self.sound = Sound(self.theme) self.controller = controller self.config = self.controller.config self.msn = msn self.muteSound = self.config.user['soundsmuteSound'] self.checkBox = gtk.CheckMenuItem(_('Mute Sounds')) self.checkBox.set_active(self.muteSound) if action == 'start': self.onlineId = None self.offlineId = None self.messageId = None self.nudgeId = None self.transferId = None self.sendMessageId = None self.connectpbId = None self.senderrorId = None self.exceptionId = None self.errorId = None self.check() self.checkBox.connect('activate', self.on_muteSounds_activate) self.updateTrayIconMenuList() self.update() self.start()
def make_menu(self): self.menu = menu = gtk.Menu() show_item = gtk.CheckMenuItem(_("Show keys")) show_item.set_active(True) show_item.connect("toggled", self.on_show_keys) show_item.show() menu.append(show_item) preferences_item = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) preferences_item.connect("activate", self.on_preferences_dialog) preferences_item.show() menu.append(preferences_item) about_item = gtk.ImageMenuItem(gtk.STOCK_ABOUT) about_item.connect("activate", self.on_about_dialog) about_item.show() menu.append(about_item) separator_item = gtk.SeparatorMenuItem() separator_item.show() menu.append(separator_item) image = gtk.ImageMenuItem(gtk.STOCK_QUIT) image.connect("activate", self.quit) image.show() menu.append(image) menu.show()
def on_populate_popup(self, view, menu): menu.prepend(gtk.SeparatorMenuItem()) def activate_linenumbers(item): self.show_line_numbers(item.get_active()) item = gtk.CheckMenuItem(_('Show Line Numbers')) item.set_active(self._attrib['linenumbers'] == 'true') # FIXME - make this attrib boolean item.connect_after('activate', activate_linenumbers) menu.prepend(item) def activate_lang(item): self.set_language(item.zim_sourceview_languageid) item = gtk.MenuItem(_('Syntax')) submenu = gtk.Menu() for lang in sorted(LANGUAGES, key=lambda k: k.lower()): langitem = gtk.MenuItem(lang) langitem.connect('activate', activate_lang) langitem.zim_sourceview_languageid = LANGUAGES[lang] submenu.append(langitem) item.set_submenu(submenu) menu.prepend(item) menu.show_all()
def create_context_menu(self): """Create a context menu on right click.""" menu = gtk.Menu() toggle_chrome = gtk.CheckMenuItem(_('Window _Chrome')) toggle_chrome.set_active(self.window.get_decorated()) toggle_chrome.connect_object('activate', self.toggle_chrome, self.window.get_decorated()) toggle_chrome.show() menu.append(toggle_chrome) settings_click = gtk.MenuItem(_('_Settings...\tCtrl-S')) settings_click.connect_object('activate', self.show_settings_dlg, None) settings_click.show() menu.append(settings_click) about_click = gtk.MenuItem(_('_About...')) about_click.connect_object('activate', self.show_about_dlg, None) about_click.show() menu.append(about_click) quitcmd = gtk.MenuItem(_('_Quit\tCtrl-Q')) quitcmd.connect_object('activate', self.destroy, None) quitcmd.show() menu.append(quitcmd) return menu
def setup_context_menu(self): """Add options to the context menu. """ menu = self.applet.dialog.menu menu_index = len(menu) - 1 self.context_menu_unit = gtk.CheckMenuItem( label=_('Use KBps instead of Kbps')) if self.unit == 1: self.context_menu_unit.set_active(True) def menu_opened(widget): self.context_menu_unit.disconnect(self.context_menu_unit_handler) self.context_menu_unit.set_active(self.unit == 1) self.context_menu_unit_handler = self.context_menu_unit.connect( 'toggled', self.call_change_unit) menu.connect("show", menu_opened) self.context_menu_unit_handler = self.context_menu_unit.connect( 'toggled', self.call_change_unit) menu.insert(self.context_menu_unit, menu_index) iface_submenu = self.generate_iface_submenu() self.iface_submenu = iface_submenu map_item = gtk.MenuItem(_("Interfaces")) map_item.set_submenu(iface_submenu) menu.insert(map_item, menu_index + 1) menu.insert(gtk.SeparatorMenuItem(), menu_index + 2)
def make_popup(self): menu = gtk.Menu() no_music = 'no-music' names = self.config.keys() for name in [no_music] + sorted(names): real_name = 'None' if name in self.config: real_name = self.config[name]['name'] if name == self.playlist or (name == no_music and self.playlist == None): item = gtk.CheckMenuItem(real_name) item.set_active(True) else: item = gtk.MenuItem(real_name) def make_click(name): def click(object): if name == no_music: self.stop_music() else: self.play_music(name) return click item.connect('activate', make_click(name)) item.show() menu.append(item) menu.popup(None, None, None, 0, gtk.get_current_event_time())
def _add_item_to_platform_menu(self, item, name, command = None, index = None): checked = item.checked if checked is None: gtk_item = gtk.MenuItem(name) else: gtk_item = gtk.CheckMenuItem(name) self._gtk_add_item(gtk_item) if not item.enabled: gtk_item.set_sensitive(0) if checked: gtk_item.set_active(1) if command: app = application() if index is not None: action = lambda widget: app.dispatch(command, index) else: action = lambda widget: app.dispatch(command) gtk_item.connect('activate', action) key = item._key if key: gtk_modifiers = gdk.CONTROL_MASK if item._shift: gtk_modifiers |= gdk.SHIFT_MASK if item._option: gtk_modifiers |= gdk.MOD1_MASK gtk_item.add_accelerator('activate', self._gtk_accel_group, ord(key), gtk_modifiers, gtk.ACCEL_VISIBLE)
def build_menu(self): self.menu = gtk.Menu() self.switch = gtk.CheckMenuItem() self.initial_state_checker() self.switch.set_sensitive(False) self.menu.append(self.switch) self.build_menu_separator(self.menu) self.prefered_app_submenu = gtk.MenuItem("Preferred Apps") self.update_menu() self.prefered_app_submenu.connect('activate', self.update_menu) self.menu.append(self.prefered_app_submenu) item2 = gtk.MenuItem("Configure Apps") item2.connect("activate", self.app_configure) self.menu.append(item2) #TODO An UI to configure Bumblebee would be nice self.build_menu_separator(self.menu) quit = gtk.ImageMenuItem(gtk.STOCK_QUIT) quit.connect("activate", self.quit) self.menu.append(quit) self.menu.show_all()
def create_menu_items_from_view(menu, items): # TODO: images & radio groups, for now only basic representation for item in items: if item.type is MenuItemView.COMMAND: it = gtk.MenuItem(item.label) it.connect("activate", lambda i, item: item.command(), item ) it.show() menu.append(it) elif item.type is MenuItemView.CASCADE_MENU: men = gtk.Menu() it = gtk.MenuItem(item.label) create_menu_items_from_view(men, item.items) it.set_submenu(men) it.show() menu.append(it) elif item.type is MenuItemView.SEPARATOR: it = gtk.SeperatorMenuItem() it.show() menu.append(it) elif item.type is MenuItemView.CHECKBUTTON: it = gtk.CheckMenuItem(item.label) if item.checkbox: it.set_active() it.show() menu.append(it) elif item.type is MenuItemView.RADIOBUTTON: it = gtk.RadioMenuItem(item.label) it.show() menu.append(it) elif item.type is MenuItemView.RADIOBUTTONGROUP: pass
def show_menu(self, event): #Create the menu and menu items if they don't exist if not self.menu: #Create the items add_feed = awn.image_menu_item_new_with_label(_("Add Feed")) update = gtk.ImageMenuItem(gtk.STOCK_REFRESH) self.show_only_new_check = gtk.CheckMenuItem(_("Show Only _New Feeds")) sep = gtk.SeparatorMenuItem() prefs_item = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) about = gtk.ImageMenuItem(_("_About %s") % _("Feeds Applet")) about.props.always_show_image = True about.set_image(gtk.image_new_from_stock(gtk.STOCK_ABOUT, gtk.ICON_SIZE_MENU)) #Add icon for "Add Feed" add_icon = gtk.image_new_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_MENU) add_feed.set_image(add_icon) if self.client.get_value(GROUP_DEFAULT, 'show_only_new'): self.show_only_new_check.set_active(True) add_feed.connect('activate', self.add_feed_dialog) update.connect('activate', self.update_feeds) self.show_only_new_check.connect('toggled', self.toggle_show_only_new) prefs_item.connect('activate', self.open_prefs) about.connect('activate', self.show_about) #Create the menu self.menu = self.create_default_menu() for item in (add_feed, update, self.show_only_new_check, sep, prefs_item, about): self.menu.append(item) self.menu.show_all() self.popup_gtk_menu (self.menu, event.button, event.time)
def _CheckOOFMenuItem_construct_gui(self, base, parent_menu, accelgroup): debug.mainthreadTest() new_gtkitem = gtk.CheckMenuItem() new_gtkitem.add(self.gtklabel(new_gtkitem)) gtklogger.setWidgetName(new_gtkitem, self.name) try: self.gtkitem.append(new_gtkitem) except AttributeError: self.gtkitem = [new_gtkitem] new_gtkitem.connect("destroy", self.gtkitem_destroyed) # Set the state of the button. This calls the callback, so we do # it here before the callback is connected. new_gtkitem.set_active(self.value) if self.accel is not None and accelgroup is not None: new_gtkitem.add_accelerator('activate', accelgroup, ord(self.accel), gtk.gdk.MOD1_MASK, gtk.ACCEL_VISIBLE) # Handler IDs are added in the same order as items, so there # is item-for-item correspondence of the lists. new_handler = gtklogger.connect(new_gtkitem, 'activate', CheckMenuCallBackWrapper(self)) try: self.handlerid.append(new_handler) except AttributeError: self.handlerid = [new_handler] if not self.enabled(): new_gtkitem.set_sensitive(0) parent_menu.insert(new_gtkitem, self.gui_order())
def add_check_menu_item(self, label, command, menu=None, value=True): item = gtk.CheckMenuItem(label) item.set_active(value) item.connect('activate', self.handle_menu_item, command) if menu is None: menu = self.menu menu.append(item)
def _make_axis_menu(self): # called by self._update*() def toggled(item, data=None): if item == self.itemAll: for item in items: item.set_active(True) elif item == self.itemInvert: for item in items: item.set_active(not item.get_active()) ind = [i for i, item in enumerate(items) if item.get_active()] self.set_active(ind) menu = gtk.Menu() self.itemAll = gtk.MenuItem("All") menu.append(self.itemAll) self.itemAll.connect("activate", toggled) self.itemInvert = gtk.MenuItem("Invert") menu.append(self.itemInvert) self.itemInvert.connect("activate", toggled) items = [] for i in range(len(self._axes)): item = gtk.CheckMenuItem("Axis %d" % (i + 1)) menu.append(item) item.connect("toggled", toggled) item.set_active(True) items.append(item) menu.show_all() return menu
def _item_checkbox(self, item): """Create checkbox menu item""" active = item['active'] if 'active' in item else False result = gtk.CheckMenuItem(label=item['label'], use_underline=True) result.set_active(active) return result