def _menu_action_pressed(widget, event): menu = _hamburger_menu guiutils.remove_children(menu) menu.add( guiutils.get_menu_item(_("Cancel Selected Render"), _hamburger_item_activated, "cancel_selected")) menu.add( guiutils.get_menu_item(_("Cancel All Renders"), _hamburger_item_activated, "cancel_all")) guiutils.add_separetor(menu) sequential_render_item = Gtk.CheckMenuItem() sequential_render_item.set_label(_("Render All Jobs Sequentially")) sequential_render_item.set_active( editorpersistance.prefs.render_jobs_sequentially) sequential_render_item.connect("activate", _hamburger_item_activated, "sequential_render") menu.add(sequential_render_item) open_on_add_item = Gtk.CheckMenuItem() open_on_add_item.set_label(_("Show Jobs Panel on Adding New Job")) open_on_add_item.set_active(editorpersistance.prefs.open_jobs_panel_on_add) open_on_add_item.connect("activate", _hamburger_item_activated, "open_on_add") menu.add(open_on_add_item) menu.show_all() menu.popup(None, None, None, None, event.button, event.time)
def create_menu(self, active, primary, resolution, active_resolution): self.menu = Gtk.Menu() prim = Gtk.CheckMenuItem("Primary") prim.set_active(primary) prim.connect("activate", self.menu_change_stat_primary) self.menu.append(prim) act = Gtk.CheckMenuItem("Active") act.set_active(active) act.connect("activate", self.menu_change_stat_active) self.menu.append(act) res_submenu = Gtk.Menu() menu = None for r in resolution: title = str(r[0]) + "x" + str(r[1]) menu = Gtk.RadioMenuItem(title, group=menu) if title == active_resolution: menu.set_active(True) menu.connect("activate", self.menu_change_resolution, r[0], r[1]) res_submenu.append(menu) res = Gtk.MenuItem("Resolution") res.set_submenu(res_submenu) self.menu.append(res) self.menu.show_all()
def on_gremlin_clicked(self, widget, event, data=None): if event.type == Gdk.EventType.DOUBLE_BUTTON_PRESS: self.clear_live_plotter() # Settings if event.type == Gdk.EventType.BUTTON_PRESS and event.button == 3: menu = Gtk.Menu() program_alpha = Gtk.CheckMenuItem("Program alpha") program_alpha.set_active(self.program_alpha) program_alpha.connect("activate", self.toggle_program_alpha) menu.append(program_alpha) show_limits = Gtk.CheckMenuItem("Show limits") show_limits.set_active(self.show_limits) show_limits.connect("activate", self.toggle_show_limits) menu.append(show_limits) show_extents = Gtk.CheckMenuItem("Show extents") show_extents.set_active(self.show_extents_option) show_extents.connect("activate", self.toggle_show_extents_option) menu.append(show_extents) live_plot = Gtk.CheckMenuItem("Show live plot") live_plot.set_active(self.show_live_plot) live_plot.connect("activate", self.toggle_show_live_plot) menu.append(live_plot) # lathe = gtk.CheckMenuItem("Lathe mode") # lathe.set_active(self.lathe_option ) # lathe.connect("activate", self.toggle_lathe_option) # menu.append(lathe) menu.popup(None, None, None, event.button, event.time) menu.show_all()
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 get_popup_filter_menu(self): # create filter menu and menuitems filter_menu = Gtk.Menu() menu_item_expired = Gtk.CheckMenuItem('Expired campaigns') menu_item_user = Gtk.CheckMenuItem('Your campaigns') menu_item_other = Gtk.CheckMenuItem('Other campaigns') self.filter_menu_items = { 'expired_campaigns': menu_item_expired, 'your_campaigns': menu_item_user, 'other_campaigns': menu_item_other } # set up the menuitems and add it to the menubutton for menus in self.filter_menu_items: filter_menu.append(self.filter_menu_items[menus]) self.filter_menu_items[menus].connect( 'toggled', self.signal_checkbutton_toggled) self.filter_menu_items[menus].show() self.filter_menu_items['expired_campaigns'].set_active( self.config['filter.campaign.expired']) self.filter_menu_items['your_campaigns'].set_active( self.config['filter.campaign.user']) self.filter_menu_items['other_campaigns'].set_active( self.config['filter.campaign.other_users']) self.gobjects['menubutton_filter'].set_popup(filter_menu) filter_menu.connect('destroy', self._save_filter)
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 _on_button_release(self, treeview, event): if event.button != 3: return False pos = treeview.get_path_at_pos(int(event.x), int(event.y)) if not pos: return False row = self._model[pos[0]] if row[Row.HasState] and not row[Row.State]: return False if not self._row_menu: self._row_menu = Gtk.Menu() self._row_menu_reset = Gtk.MenuItem( C_('option-entry|indicators', 'Reset to _defaults')) self._row_menu_text = Gtk.CheckMenuItem( C_('option-entry|indicators', 'Display _label')) self._row_menu_image = Gtk.CheckMenuItem( C_('option-entry|indicators', 'Display _image')) self._row_menu_remove = Gtk.MenuItem( C_('option-entry|indicators', '_Remove')) self._row_menu_text_id = self._row_menu_text.connect( 'toggled', self._on_row_menu_toggled, Option.Text) self._row_menu_image_id = self._row_menu_image.connect( 'toggled', self._on_row_menu_toggled, Option.Image) self._row_menu_reset.connect('activate', self._on_row_menu_reset_clicked) self._row_menu_remove.connect('activate', self._on_remove_clicked) self._row_menu.append(self._row_menu_reset) self._row_menu.append(self._row_menu_text) self._row_menu.append(self._row_menu_image) self._row_menu.append(Gtk.SeparatorMenuItem()) self._row_menu.append(self._row_menu_remove) for item in self._row_menu: if type(item) is not Gtk.SeparatorMenuItem: item.props.use_underline = True item.props.visible = True options = row[Row.Options].data with self._row_menu_text.handler_block(self._row_menu_text_id): self._row_menu_text.props.active = Option.Text in options with self._row_menu_image.handler_block(self._row_menu_image_id): self._row_menu_image.props.active = Option.Image in options editable = options[Option.Name] not in { Indicators.Spacer, Indicators.Separator } self._row_menu_reset.props.sensitive = editable self._row_menu_text.props.sensitive = editable self._row_menu_image.props.sensitive = editable self._row_menu.popup(None, None, None, None, 0, Gtk.get_current_event_time()) return True
def __update_menu(self): menu = gtk.Menu() for crypto_currency in self.prices: item = gtk.MenuItem( self.__get_exchange_price_label(crypto_currency, self.prices[crypto_currency])) item.connect('activate', self.__open_store) menu.append(item) menu.append(gtk.SeparatorMenuItem()) item_refresh = gtk.MenuItem('Refresh prices') item_refresh.connect('activate', lambda _: self.refresh_fc()) menu.append(item_refresh) menu.append(gtk.SeparatorMenuItem()) crypto_currency_options = self.config.get_crypto_currency_options() for crypto_currency in crypto_currency_options: crypto_currency_sub_menu = gtk.Menu() for option_key in crypto_currency_options[crypto_currency]: item = gtk.CheckMenuItem( crypto_currency_options[crypto_currency] [option_key].get_label(), active=crypto_currency_options[crypto_currency] [option_key].get_status()) item.connect( "activate", lambda _, currency, key: self. __toggle_crypto_currency_option_status(currency, key), crypto_currency, option_key) crypto_currency_sub_menu.append(item) crypto_currency_item = gtk.MenuItem(crypto_currency) crypto_currency_item.set_submenu(crypto_currency_sub_menu) menu.append(crypto_currency_item) menu.append(gtk.SeparatorMenuItem()) general_settings_sub_menu = gtk.Menu() options = self.config.get_general_options() for option_key in options: item = gtk.CheckMenuItem(options[option_key].get_label(), active=options[option_key].get_status()) item.connect( "activate", lambda _, key: self.__toggle_general_option_status(key), option_key) general_settings_sub_menu.append(item) general_settings_item = gtk.MenuItem('Settings') general_settings_item.set_submenu(general_settings_sub_menu) menu.append(general_settings_item) menu.append(gtk.SeparatorMenuItem()) item_quit = gtk.MenuItem('Quit') item_quit.connect('activate', lambda _: self.quit_fc()) menu.append(item_quit) menu.show_all() self.indicator.set_menu(menu)
def update_device_list(self): disconnected_devs, connected_devs = self.update_bluetooth_devices() if self.connected_devs != connected_devs: opened_devices = self.get_opened_terminals() for dev in self.connect_menu: self.connect_menu.remove(dev) for dev in connected_devs: dev_menu_item = Gtk.CheckMenuItem( self.get_device_name(dev) + ' (' + dev + ')') if dev in opened_devices: dev_menu_item.set_active(True) self.connect_to_device(dev) dev_menu_item.connect("activate", self.connect_disconnect) self.connect_menu.append(dev_menu_item) self.connect_menu.show_all() self.update_terminal_devices(disconnected_devs, connected_devs) # When there are no connected NUS devices, show info in menu items = [item for item in self.connect_menu] if not items: no_bonded_menu_item = Gtk.CheckMenuItem( 'No compatible devices connected') self.connect_menu.append(no_bonded_menu_item) self.connect_menu.show_all() self.disconnected_devs = disconnected_devs self.connected_devs = connected_devs time.sleep(0.01) return True
def __init__(self, controls): Gtk.Box.__init__(self, orientation=Gtk.Orientation.HORIZONTAL, spacing=0) self.order = ToggleImageButton("edit-redo", size=Gtk.IconSize.BUTTON) self.order.connect("button-press-event", self.on_order) self.pack_start(self.order, False, False, 0) self.repeat = ToggleImageButton("view-refresh", size=Gtk.IconSize.BUTTON) self.repeat.connect("button-press-event", self.choise) try: self.order.set_has_tooltip(True) self.repeat.set_has_tooltip(True) except: pass self.pack_start(self.repeat, False, False, 0) self.menu = Gtk.Menu() self.item_all = Gtk.CheckMenuItem(_("Repeat all")) self.item_all.connect("button-press-event", self.on_repeat) self.menu.append(self.item_all) self.item_single = Gtk.CheckMenuItem(_("Repeat single")) self.item_single.connect("button-press-event", lambda item, *a: self.on_repeat(item, False)) self.menu.append(self.item_single)
def build_ui(self): self.tray = tray = Gtkti.TrayIcon() eventbox = Gtk.EventBox() if background_color: css = Gtk.CssProvider() css.load_from_data( ('* { background-color: ' + background_color + '; }').encode()) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) tray.add(eventbox) self.tray_label = tray_label = Gtk.Label(label=self.prefix + self.suffix) eventbox.add(tray_label) tray.show_all() menu = Gtk.Menu() item_show_date = Gtk.CheckMenuItem(label='Show Date') item_show_date.set_active(self.show_date) def toggle_date(item_show_date, self=self): self.show_date = item_show_date.get_active() self.gtk_update_ui() item_show_date.connect('toggled', toggle_date) menu.append(item_show_date) item_show_seconds = Gtk.CheckMenuItem(label='Show Seconds') item_show_seconds.set_active(self.show_seconds) self.toggle_seconds_event = threading.Event() def toggle_seconds(item_show_seconds, self=self): self.show_seconds = item_show_seconds.get_active() # Wake the update thread, which will update the UI, then sleep again self.toggle_seconds_event.set() item_show_seconds.connect('toggled', toggle_seconds) menu.append(item_show_seconds) item_quit = Gtk.MenuItem(label='Quit') def quit(menu_item): if sys.version_info < (3, 0): os.kill(os.getpid(), signal.SIGINT) else: Gtk.main_quit() item_quit.connect('activate', quit) menu.append(item_quit) menu.show_all() def button_pressed(eventbox, event, menu=menu): if event.type == Gdk.EventType.BUTTON_PRESS and event.button == 3: menu.popup(None, None, None, None, event.button, event.time) eventbox.connect('button-press-event', button_pressed)
def _add_prefs_menu(self, oPrefsMenu): """Add the File Preferences menu""" self._dMenus["File Preferences"] = oPrefsMenu oCheckForUpdates = Gtk.CheckMenuItem(label='Check for Cardlist updates' ' on startup') oCheckForUpdates.set_inconsistent(False) if self._oConfig.get_check_for_updates(): oCheckForUpdates.set_active(True) else: oCheckForUpdates.set_active(False) oCheckForUpdates.connect('activate', self.do_toggle_check_for_updates) oPrefsMenu.add(oCheckForUpdates) oNameDisplay = Gtk.CheckMenuItem( label='Use "something ..., the" name display') oNameDisplay.set_inconsistent(False) if self._oConfig.get_postfix_the_display(): oNameDisplay.set_active(True) else: oNameDisplay.set_active(False) oNameDisplay.connect('activate', self.do_postfix_the_display) oPrefsMenu.add(oNameDisplay) oSaveOnExit = Gtk.CheckMenuItem(label='Save Pane Set on Exit') oSaveOnExit.set_inconsistent(False) if self._oConfig.get_save_on_exit(): oSaveOnExit.set_active(True) else: oSaveOnExit.set_active(False) oSaveOnExit.connect('activate', self.do_toggle_save_on_exit) oPrefsMenu.add(oSaveOnExit) oSavePos = Gtk.CheckMenuItem(label='Save Exact Pane Positions') oSavePos.set_inconsistent(False) if self._oConfig.get_save_precise_pos(): oSavePos.set_active(True) else: oSavePos.set_active(False) oSavePos.connect('activate', self.do_toggle_save_precise_pos) oPrefsMenu.add(oSavePos) oSaveWinSize = Gtk.CheckMenuItem(label='Save Window Size') oSaveWinSize.set_inconsistent(False) if self._oConfig.get_save_window_size(): oSaveWinSize.set_active(True) else: oSaveWinSize.set_active(False) oSaveOnExit.connect('activate', self.do_toggle_save_window_size) oPrefsMenu.add(oSaveWinSize)
def show_config_menu(self, widget): notif = Gtk.CheckMenuItem(i18n.get('notificate')) sound = Gtk.CheckMenuItem(i18n.get('sound')) refresh = Gtk.MenuItem(i18n.get('manual_update')) refresh.connect('activate', self.__refresh, self.column.id_) self.menu = Gtk.Menu() self.menu.append(sound) self.menu.append(notif) self.menu.append(refresh) self.menu.show_all() self.menu.popup(None, None, None, None, 0, Gtk.get_current_event_time())
def _get_workflow_tool_submenu(callback, tool_id, position): sub_menu = Gtk.Menu() tool_active = (tool_id in editorpersistance.prefs.active_tools) activity_item = Gtk.CheckMenuItem(_("Tool Active").encode('utf-8')) activity_item.set_active(tool_active) activity_item.connect("toggled", callback, (tool_id, "activity")) activity_item.show() sub_menu.add(activity_item) guiutils.add_separetor(sub_menu) position_item = Gtk.MenuItem.new_with_label(_("Set Position")) if tool_active == False: position_item.set_sensitive(False) position_item.show() position_menu = Gtk.Menu() for i in range(1, len(editorpersistance.prefs.active_tools) + 1): move_to_position_item = guiutils.get_menu_item( str(i), _workflow_menu_callback, (tool_id, str(i))) if i == position or position == -1: move_to_position_item.set_sensitive(False) move_to_position_item.show() position_menu.add(move_to_position_item) position_item.set_submenu(position_menu) sub_menu.add(position_item) return sub_menu
def addMenuAction(self, menu_name_id, act_name_id, act_name_string, is_check=False): i = self.get_menu_index(menu_name_id) if i < 0: return menu_widget = self.menu_indexes[i][iMenuWidget] if TrayEngine == "KDE": act_widget = KAction(act_name_string, menu_widget) act_widget.setCheckable(is_check) menu_widget.addAction(act_widget) elif TrayEngine == "AppIndicator": menu_widget = menu_widget.get_submenu() if is_check: act_widget = Gtk.CheckMenuItem(act_name_string) else: act_widget = Gtk.ImageMenuItem(act_name_string) act_widget.set_image(None) act_widget.show() menu_widget.append(act_widget) elif TrayEngine == "Qt": act_widget = QAction(act_name_string, menu_widget) act_widget.setCheckable(is_check) menu_widget.addAction(act_widget) else: act_widget = None act_obj = [None, None, None, None] act_obj[iActNameId] = act_name_id act_obj[iActWidget] = act_widget act_obj[iActParentMenuId] = menu_name_id self.act_indexes.append(act_obj)
def PressHeader(widget, event): if event.button != 3: return False columns = widget.get_parent().get_columns() visible_columns = [column for column in columns if column.get_visible()] one_visible_column = len(visible_columns) == 1 menu = gtk.Menu() pos = 1 for column in columns: title = column.get_title() if title == "": title = _("Column #%i") % pos item = gtk.CheckMenuItem(title) if column in visible_columns: item.set_active(True) if one_visible_column: item.set_sensitive(False) else: item.set_active(False) item.connect('activate', header_toggle, columns, pos - 1) menu.append(item) pos += 1 menu.show_all() menu.attach_to_widget(widget.get_toplevel(), None) menu.popup(None, None, None, None, event.button, event.time) return True
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 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.MenuItem(_("Preferences")) preferences_item.connect("activate", self.on_preferences_dialog) preferences_item.show() menu.append(preferences_item) about_item = Gtk.MenuItem(_("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.MenuItem(_("Quit")) image.connect("activate", self.quit) image.show() menu.append(image) menu.show()
def checkitem(self, title, cb=None, active=False): check_item = Gtk.CheckMenuItem(label=title) check_item.set_active(active) if cb: check_item.connect("toggled", cb) check_item.show() return check_item
def on_populate_popup(self, view, menu): menu.prepend(Gtk.SeparatorMenuItem()) def activate_linenumbers(item): self.buffer.set_show_line_numbers(item.get_active()) item = Gtk.CheckMenuItem(_('Show Line Numbers')) # T: preference option for sourceview plugin item.set_active(self.buffer.object_attrib['linenumbers']) item.set_sensitive(self.view.get_editable()) item.connect_after('activate', activate_linenumbers) menu.prepend(item) def activate_lang(item): self.buffer.set_language(item.zim_sourceview_languageid) item = Gtk.MenuItem.new_with_mnemonic(_('Syntax')) item.set_sensitive(self.view.get_editable()) submenu = Gtk.Menu() for lang in sorted(LANGUAGES, key=lambda k: k.lower()): langitem = Gtk.MenuItem.new_with_mnemonic(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 __init__(self, songs, library, label=_("_Rating")): super(RatingsMenuItem, self).__init__(label=label, use_underline=True) self._songs = songs image = Gtk.Image.new_from_icon_name(Icons.FAVORITE, Gtk.IconSize.MENU) image.show() self.set_image(image) submenu = Gtk.Menu() self.set_submenu(submenu) self._rating_menu_items = [] for i in RATINGS.all: text = "%0.2f\t%s" % (i, util.format_rating(i)) itm = Gtk.CheckMenuItem(label=text) itm.rating = i submenu.append(itm) handler = itm.connect('toggled', self._on_rating_change, i, library) self._rating_menu_items.append((itm, handler)) reset = Gtk.MenuItem(label=_("_Remove Rating"), use_underline=True) reset.connect('activate', self._on_rating_remove, library) self._select_ratings() submenu.append(SeparatorMenuItem()) submenu.append(reset) submenu.show_all()
def _menuitem(self, label, icon, onclick, checked=None): """ Create a generic menu item. :param str label: text :param Gtk.Image icon: icon (may be ``None``) :param onclick: onclick handler, either a callable or Gtk.Menu :returns: the menu item object :rtype: Gtk.MenuItem """ if checked is not None: item = Gtk.CheckMenuItem() item.set_active(checked) elif icon is None: item = Gtk.MenuItem() else: item = Gtk.ImageMenuItem() item.set_image(icon) # I don't really care for the "show icons only for nouns, not # for verbs" policy: item.set_always_show_image(True) if label is not None: item.set_label(label) if isinstance(onclick, Gtk.Menu): item.set_submenu(onclick) elif onclick is not None: item.connect('activate', onclick) return item
def __init__(self, player): super(VolumeMenu, self).__init__() # ubuntu 12.04.. if hasattr(player, "bind_property"): # Translators: player state, no action item = Gtk.CheckMenuItem(label=_("_Mute"), use_underline=True) player.bind_property("mute", item, "active", GObject.BindingFlags.BIDIRECTIONAL) self.append(item) item.show() item = Gtk.MenuItem(label=_("_Replay Gain Mode"), use_underline=True) self.append(item) item.show() # Set replaygain mode as saved in configuration replaygain_mode = config.gettext("player", "replaygain_mode", "auto") self.__set_mode(player, replaygain_mode) rg = Gtk.Menu() rg.show() item.set_submenu(rg) item = None for mode, title, profile in self.__modes: item = RadioMenuItem(group=item, label=title, use_underline=True) rg.append(item) item.connect("toggled", self.__changed, player, mode) if replaygain_mode == mode: item.set_active(True) item.show()
def get_menu_item(self): """Overrides method from base class. Adds the menu item on the MainWindow if the starters can be found. """ MessageBus.subscribe(MessageBus.Type.CARD_TEXT_MSG, 'post_set_text', self.post_set_card_text) # Listen for card set changes to manage the cache listen_row_update(self.card_set_changed, PhysicalCardSet) listen_row_destroy(self.card_set_added_deleted, PhysicalCardSet) listen_row_created(self.card_set_added_deleted, PhysicalCardSet) self._bDoSignalCleanup = True # Make sure we add the tag we need oCardTextView = self.parent.card_text_pane.view oCardTextView.text_buffer.add_list_tag('starters') self.oToggle = Gtk.CheckMenuItem(label="Show Starter Information") self.oToggle.connect('toggled', self._toggle_starter) self.oToggle.set_active(False) if self.check_enabled(): sPrefsValue = self.get_config_item('show starters') if sPrefsValue == 'Yes': self.oToggle.set_active(True) else: self.oToggle.set_sensitive(False) oDownload = Gtk.MenuItem(label="Download starter decks") oDownload.connect('activate', self.do_download) return [('Preferences', self.oToggle), ('Data Downloads', oDownload)]
def __init__(self): self.statusIcon = gtk.StatusIcon() pix = gdkpixbuf.Pixbuf.new_from_file_at_size("./masgor.svg",48,48) self.statusIcon.set_from_pixbuf(pix) self.statusIcon.set_visible(True) self.statusIcon.set_tooltip_text("MASGOR") self.menu = gtk.Menu() self.Item = gtk.CheckMenuItem("Başlat",None) self.Item.connect('activate', self.komut, self.statusIcon) self.menu.append(self.Item) self.Item1 = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) self.Item1.connect('activate', self.tercihler, self.statusIcon) self.menu.append(self.Item1) self.Item3 = gtk.ImageMenuItem(gtk.STOCK_ABOUT) self.Item3.connect('activate', self.komut2, self.statusIcon) self.menu.append(self.Item3) self.Item2 = gtk.ImageMenuItem(gtk.STOCK_QUIT) self.Item2.connect('activate', self.komut1, self.statusIcon) self.menu.append(self.Item2) self.menu.show_all() self.statusIcon.connect('popup-menu', self.popup_menu_cb, self.menu) self.statusIcon.set_visible(1)
def __init__(self): self.ind = appindicator.Indicator.new( "example-simple-client", "indicator-messages", appindicator.IndicatorCategory.APPLICATION_STATUS) self.ind.set_status(appindicator.IndicatorStatus.ACTIVE) self.ind.set_attention_icon("indicator-messages-new") self.ind.set_icon("distributor-logo") # create a menu self.menu = gtk.Menu() # create items for the menu - labels, checkboxes, radio buttons and images are supported: item = gtk.MenuItem(label="Regular Menu Item") item.show() self.menu.append(item) check = gtk.CheckMenuItem(label="Check Menu Item") check.show() self.menu.append(check) radio = gtk.RadioMenuItem(label="Radio Menu Item") radio.show() self.menu.append(radio) image = gtk.ImageMenuItem(gtk.STOCK_QUIT) image.connect("activate", self.quit) image.show() self.menu.append(image) self.menu.show() self.ind.set_menu(self.menu)
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 _setup_widgets(self): self.set_main_item = Gtk.ImageMenuItem.new() self.set_main_item.set_image( Gtk.Image.new_from_icon_name(STOQ_CHECK, Gtk.IconSize.MENU)) self.set_main_item.set_label(_("Set as main image")) self.set_internal_item = Gtk.CheckMenuItem( label=_("Internal use only")) self.view_item = Gtk.MenuItem(label=_("View")) self.save_item = Gtk.MenuItem(label=_("Save")) self.erase_item = Gtk.MenuItem(label=_("Remove")) self.popmenu = Gtk.Menu() for item, callback in [ (self.set_main_item, self._on_popup_set_main__activate), (self.set_internal_item, self._on_popup_set_internal__activate), (self.view_item, self._on_popup_view__activate), (self.erase_item, self._on_popup_erase__activate), (self.save_item, self._on_popup_save__activate) ]: self.popmenu.append(item) item.connect('activate', callback) self.popmenu.show_all() self._update_widgets() if self.visual_mode: self.image.set_sensitive(False)
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
def addAction(self, act_name_id, act_name_string, is_check=False): if TrayEngine == "KDE": act_widget = KAction(act_name_string, self.menu) act_widget.setCheckable(is_check) self.menu.addAction(act_widget) elif TrayEngine == "AppIndicator": if is_check: act_widget = Gtk.CheckMenuItem(act_name_string) else: act_widget = Gtk.ImageMenuItem(act_name_string) act_widget.set_image(None) act_widget.show() self.menu.append(act_widget) elif TrayEngine == "Qt": act_widget = QAction(act_name_string, self.menu) act_widget.setCheckable(is_check) self.menu.addAction(act_widget) else: act_widget = None act_obj = [None, None, None, None] act_obj[iActNameId] = act_name_id act_obj[iActWidget] = act_widget self.act_indexes.append(act_obj)