def register_display_item(self, name, label, weight=100): if name in self._display_items: self.log.debug("Tried to register display item '%s' twice" % name) return # create an action and three derived items: # - a checkbox for the preferences window # - a tool item for the drop-down list in the 3D window # - a menu item for the context menu in the 3D window action = gtk.ToggleAction(name, label, "Show/hide %s" % label, None) action.connect("toggled", lambda widget: \ self.core.emit_event("visual-item-updated")) checkbox = gtk.CheckButton(label) action.connect_proxy(checkbox) tool_item = action.create_tool_item() menu_item = action.create_menu_item() widgets = (checkbox, tool_item, menu_item) self._display_items[name] = { "name": name, "label": label, "weight": weight, "widgets": widgets, "action": action } self.core.add_item(name, action.get_active, action.set_active) self._rebuild_display_items() # add this item to the state handler self.register_state_item("settings/view/items/%s" % name, action.get_active, action.set_active)
def _create_file_hidden_check_toolbar(self): self._file_hidden_check_actions = {} menu = gtk.Menu() separator = gtk.SeparatorMenuItem() project_scope_count = 0 menu.append(separator) for checker in self.svc.features['file_hidden_check']: action = gtk.ToggleAction(checker.identifier, checker.label, checker.label, None) # active? if (checker.scope == filehiddencheck.SCOPE_GLOBAL): action.set_active( checker.identifier in self.svc.opt('file_hidden_check')) else: self.__file_hidden_check_scope_project_set_active(action) action.connect('activate', self._on_act_file_hidden_check, checker) self._file_hidden_check_actions[checker.identifier] = action menuitem = action.create_menu_item() if (checker.scope == filehiddencheck.SCOPE_GLOBAL): menu.prepend(menuitem) else: menu.append(menuitem) project_scope_count += 1 menu.show_all() if (project_scope_count == 0): separator.hide() toolitem = None for proxy in self.svc.get_action('toolbar_hidden_menu').get_proxies(): if (isinstance(proxy, DropDownMenuToolButton)): toolitem = proxy break if (toolitem is not None): toolitem.set_menu(menu)
def get_gtk_actiongroup(obj): '''Return a C{gtk.ActionGroup} for an object using L{Action} objects as attributes. Defines the attribute C{obj.actiongroup} if it does not yet exist. This method can only be used when gtk is available ''' import gtk if hasattr(obj, 'actiongroup') \ and obj.actiongroup is not None: return obj.actiongroup obj.actiongroup = gtk.ActionGroup(obj.__class__.__name__) for name, action in inspect.getmembers(obj.__class__, lambda m: isinstance(m, Action)): if isinstance(action, ToggleAction): gaction = gtk.ToggleAction(*action._attr) else: gaction = gtk.Action(*action._attr) action.connect_actionable(obj, gaction) obj.actiongroup.add_action_with_accel(gaction, action._accel) return obj.actiongroup
def _addToUIManager(self): self.script_type_actions = gtk.ActionGroup('ScriptTypes') self.script_type_actions.add_radio_actions( (('Level1', None, 'Level 1', None, None, 1), ('Level2', None, 'Level 2', None, None, 2)), 2, self._onChange) self._wait_for_focus_toggle = gtk.ToggleAction('WaitForFocus', 'Record focus events', None, None) self._wait_for_focus_toggle.set_active(True) self._wait_for_focus_toggle.connect('toggled', self._onWaitForFocusToggled) self.script_type_actions.add_action(self._wait_for_focus_toggle) script_type_ui = ''' <ui> <popup> <placeholder name="ScriptType"> <menuitem action="Level1" /> <menuitem action="Level2" /> <separator /> <menuitem action="WaitForFocus" /> </placeholder> </popup> </ui>''' self._uimanager.add_ui_from_string(script_type_ui) self._uimanager.insert_action_group(self.script_type_actions, 0)
def populate_action_groups(self): # Set up action groups # TODO: self.conditional_action_group = gtk.ActionGroup("save file dependent") self.action_groups[0].add_actions([ ("text_edit_ack", None, _('_Ack'), None, _('Insert Acked-by tag at cursor position'), self._insert_ack_acb), ("text_edit_sign_off", None, _('_Sign Off'), None, _('Insert Signed-off-by tag at cursor position'), self._insert_sign_off_acb), ("text_edit_author", None, _('A_uthor'), None, _('Insert Author tag at cursor position'), self._insert_author_acb), ("text_edit_save_as", gtk.STOCK_SAVE_AS, _('S_ave as'), "", _('Save summary to a file'), self._save_text_as_acb), ("text_edit_load_from", gtk.STOCK_REVERT_TO_SAVED, _('_Load from'), "", _('Load summary from a file'), self._load_text_from_acb), ("text_edit_insert_from", gtk.STOCK_PASTE, _('_Insert from'), '', _('Insert the contents of a file at cursor position'), self._insert_text_from_acb), ]) self.action_groups[self.AC_SAVE_OK].add_actions([ ("text_edit_save_to_file", gtk.STOCK_SAVE, _('_Save'), "", _('Save summary to file'), self._save_text_to_file_acb), ("text_edit_load_fm_file", gtk.STOCK_REVERT_TO_SAVED, _('_Revert'), "", _('Load summary from saved file'), self._load_text_fm_file_acb), ]) self.save_toggle_action = gtk.ToggleAction( "text_edit_toggle_auto_save", _('Auto Sa_ve'), _('Automatically/periodically save summary to file'), gtk.STOCK_SAVE) self.save_toggle_action.connect("toggled", self._toggle_auto_save_acb) self.action_groups[self.AC_SAVE_OK].add_action(self.save_toggle_action)
def createAg(self): ag = gtk.ActionGroup("a") for name in (ACTION_FIND_FORWARD, ACTION_FIND_BACKWARD): ag.add_action(gtk.Action(name, None, None, "gtk-open")) ag.add_action( gtk.ToggleAction(ACTION_FIND_TOGGLE, None, None, "gtk-open")) return ag
def create_dummy_action_group(): ag = gtk.ActionGroup("search+replace") for name in (ACTION_FIND_FORWARD, ACTION_FIND_BACKWARD, ACTION_REPLACE_FORWARD, ACTION_REPLACE_BACKWARD, ACTION_REPLACE_ALL): ag.add_action(gtk.Action(name, None, None, "gtk-open")) for name in (ACTION_FIND_TOGGLE, ACTION_REPLACE_TOGGLE): ag.add_action(gtk.ToggleAction(name, None, None, "gtk-open")) return ag
def make_check_action(self, action, check_group, label, groups, shortcuts): gtk_action = gtk.ToggleAction(action, label, None, None) self.actions[action] = gtk_action callback = menus.lookup_handler(gtk_action.get_name()) if callback is not None: gtk_action.connect("toggled", self.on_activate, callback) if check_group not in self.check_groups: self.check_groups[check_group] = list() self.check_groups[check_group].append(gtk_action) self.action_groups[groups[0]].add_action(gtk_action)
def __init__(self): """Instantiate instance vars and bind actions. """ self.__mask = [] self.mask_observers = [] action_name = "wheel%s_masked" % (id(self), ) self.mask_toggle = gtk.ToggleAction( action_name, _("Gamut mask active"), _("Limit your palette for specific moods using a gamut mask"), None) self.mask_toggle.connect("toggled", self.__mask_toggled_cb)
def _gtk_add_action_with_accel(obj, actiongroup, action, attr, accel): import gtk if isinstance(action, ToggleAction): gaction = gtk.ToggleAction(*attr) else: gaction = gtk.Action(*attr) gaction.zim_readonly = action.readonly # HACK action.connect_actionable(obj, gaction) actiongroup.add_action_with_accel(gaction, accel)
def __init_actions(self): self.__det_act = gtk.ToggleAction(name='detach', label='Detach', tooltip='Detach this view', stock_id='gtk-up') self.__close_act = gtk.Action(name='close', label='Close', tooltip='Close this view', stock_id=gtk.STOCK_CLOSE) self.__close_act.connect('activate', self.cb_close_action_activated) self.__det_act.connect('activate', self.cb_detach_action_activated)
def createToggleActions(self): for observer in self.observers: actionTitle = observer.getWidgetName() actionName = actionTitle.replace("_", "") gtkAction = gtk.ToggleAction(actionName, actionTitle, None, None) if observer.shouldShow(): gtkAction.set_active(True) else: gtkAction.set_sensitive(False) self.actionGroup.add_action(gtkAction) gtkAction.connect("toggled", self.toggleVisibility, observer) self.toggleActions.append(gtkAction)
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)
def __init__(self): gtksourceview.SourceView.__init__(self) self.set_auto_indent(True) self.set_show_line_numbers(True) self.set_show_line_markers(True) self.set_tabs_width(4) self.set_margin(80) self.set_show_margin(True) self.set_smart_home_end(True) self.set_highlight_current_line(True) font_desc = pango.FontDescription('monospace 10') if font_desc is not None: self.modify_font(font_desc) show_find = gtk.ToggleAction("FindToggle", "Find...", "Finds a string in current document", gtk.STOCK_FIND) self.find_toggle = show_find self.find_fw = gtk.Action("FindForward", "Find next", "Finds the string forward", gtk.STOCK_FIND) self.find_bw = gtk.Action("FindBackwards", "Find back", "Finds the string backwards", gtk.STOCK_FIND) self.replace_fw = gtk.Action("ReplaceForward", "Replace next", "Replaces the string forward", gtk.STOCK_FIND_AND_REPLACE) self.replace_toggle = gtk.ToggleAction("ReplaceToggle", "Replace...", "Replaces the string forward", gtk.STOCK_FIND_AND_REPLACE) self.replace_all = gtk.Action("ReplaceAll", "Replace all", "Replaces all the occurrences", gtk.STOCK_FIND_AND_REPLACE) self.search_bar = SearchBar(self, self.find_fw, self.find_bw, show_find) actions = (self.find_toggle, self.replace_toggle, self.replace_fw, self.replace_all) self.replace_bar = ReplaceBar(self, self.search_bar, *actions) self.find_fw.connect("activate", self.on_find_forward) self.find_bw.connect("activate", self.on_find_backwards)
def __init__(self, toggle_data, function=None, is_on=True, interval=10000): self._interval = abs(interval) self._timeout_id = None self._function = function self.toggle_action = gtk.ToggleAction(toggle_data.name, toggle_data.label, toggle_data.tooltip, toggle_data.stock_id) self.toggle_action.set_menu_item_type(gtk.CheckMenuItem) self.toggle_action.set_tool_item_type(gtk.ToggleToolButton) self.toggle_action.connect("toggled", self._toggle_acb) self.toggle_action.set_active(is_on) self._toggle_acb()
def init_actions(self): ag = self.draw_window.action_group actions = [] self.settings_actions = [] for name, ui_xml, label in MERGEABLE_XML: action = gtk.ToggleAction(name, label, None, None) action.connect("toggled", self.on_settings_toggle, ui_xml) self.settings_actions.append(action) actions += self.settings_actions for action in actions: ag.add_action(action)
def __init__(self): self.conf = SlogConf() gladefile = os.path.join(DATA_DIR, "slog.glade") self.wtree = gtk.glade.XML(gladefile, domain="slog") self.wtree.signal_autoconnect(self) # Create tray icon self.status_icon = gtk.status_icon_new_from_file(get_icon("slog.png")) self.status_icon.set_tooltip(APP_NAME) self.status_icon.connect("popup-menu", self.on_tray_popup) self.status_icon.connect("activate", self.on_tray_clicked) # Create main window self.window = self.wtree.get_widget("mainWindow") self.window.set_icon_from_file(get_icon("slog.png")) self.window.set_title("%s %s" % (APP_NAME, VERSION)) self.window.set_size_request(396, 256) # Restore window settings (width, height) = self.conf.get_size() (left, top) = self.conf.get_pos() if left != 0 or top != 0: self.window.move(left, top) self.window.set_default_size(width, height) self.wtree.get_widget("hPaned").set_position(self.conf.paned) self.sidebar = self.wtree.get_widget("sideBar") #Create Spy object self.spy = Spy() mb_menuitem_spy = self.wtree.get_widget("menuItemSpy1") tray_menuitem_spy = self.wtree.get_widget("menuItemSpy2") self.spy_action = gtk.ToggleAction("Spy", "_Spy", "Spy Service", None) self.spy_action.connect("activate", self.on_spy_clicked) self.spy_action.connect_proxy(tray_menuitem_spy) self.spy_action.connect_proxy(mb_menuitem_spy) if self.conf.tray_start == 0: self.window.show_all() if self.conf.spy_auto == 1: self.spy_action.activate() plugin_dir = os.path.join(DATA_DIR, "plugins") self.plugin_manager = PluginManager() self.plugin_manager.add_plugin_dir(plugin_dir) self.plugin_manager.scan_for_plugins() self.plugin_view = PluginView(self.wtree, self.plugin_manager) self.__load_plugins()
def _create_action(attrs): type_ = attrs.pop('type', None) name = str(attrs.pop('name')) label = attrs.pop('label') tooltip = attrs.pop('tooltip') stock_id = str(attrs.pop('stock_id')) value = attrs.pop('value', None) if type_ is None: return gtk.Action(name, label, tooltip, stock_id) elif type_ == 'toggle': return gtk.ToggleAction(name, label, tooltip, stock_id) elif type_ == 'radio': return gtk.RadioAction(name, label, tooltip, stock_id, int(value))
def __init__(self): """Instantiate instance vars and bind actions. """ self.__mask = [] self.mask_observers = [] action_name = "wheel%s_masked" % (id(self),) self.mask_toggle = gtk.ToggleAction( action_name, C_( "Color Wheels: activity toggle: action title", u"Gamut Mask Active", ), C_( "Color Wheels: activity toggle: action tooltip", u"Limit your palette for specific moods using a gamut mask.", ), None ) self.mask_toggle.connect("toggled", self.__mask_toggled_cb)
def create_actions(self): self._tips = gtk.Tooltips() self._homeact = gtk.Action('Home', 'Home', 'Browse the project root', 'gtk-project') self.add_action_to_toolbar(self._homeact) self._homeact.connect('activate', self.cb_act_home) self._upact = gtk.Action('Up', 'Up', 'Browse the parent directory', gtk.STOCK_GO_UP) self.add_action_to_toolbar(self._upact) self._upact.connect('activate', self.cb_act_up) self._refreshact = gtk.Action('Refresh', 'Refresh', 'Refresh the directory', gtk.STOCK_REFRESH) self.add_action_to_toolbar(self._refreshact) self._refreshact.connect('activate', self.cb_act_refresh) self._hidden_act = gtk.ToggleAction('ShowHidden', 'ShowHidden', 'Show the hidden files', 'gtk-hidden') self._hidden_act.connect('toggled', self.cb_show_hidden) self.add_action_to_toolbar(self._hidden_act) self._newfileact = gtk.Action('New', 'New', 'Create a new file here', gtk.STOCK_NEW) #self.add_action_to_toolbar(self._newfileact) self._newfileact.connect('activate', self.cb_act_new_file) self._newdiract = gtk.Action('NewDir', 'New Directory', 'Create a new directory here', 'gtk-directory') self.add_action_to_toolbar(self._newdiract) self._newdiract.connect('activate', self.cb_act_new_dir) # TODO: move this onto 'grepper' service self._searchact = gtk.Action('Search', 'Search', 'Search files for text', 'gtk-searchtool') self.add_action_to_toolbar(self._searchact) self._searchact.connect('activate', self.cb_act_search) for action in self.registry.get_features("toolbar_action"): self.add_action_to_toolbar(action)
def create_actions(self): self._tips = gtk.Tooltips() self._homeact = gtk.Action('Home', 'Home', 'Browse the project root', 'gtk-project') self.add_action_to_toolbar(self._homeact) self._homeact.connect('activate', self.cb_act_home) self._upact = gtk.Action('Up', 'Up', 'Browse the parent directory', gtk.STOCK_GO_UP) self.add_action_to_toolbar(self._upact) self._upact.connect('activate', self.cb_act_up) self._refreshact = gtk.Action('Refresh', 'Refresh', 'Refresh the directory', gtk.STOCK_REFRESH) self.add_action_to_toolbar(self._refreshact) self._refreshact.connect('activate', self.cb_act_refresh) self._hidden_act = gtk.ToggleAction('ShowHidden', 'ShowHidden', 'Show the hidden files', 'gtk-hidden') self._hidden_act.connect('toggled', self.cb_show_hidden) self.add_action_to_toolbar(self._hidden_act) self._newfileact = gtk.Action('New', 'New', 'Create a new file here', gtk.STOCK_NEW) #self.add_action_to_toolbar(self._newfileact) self._newfileact.connect('activate', self.cb_act_new_file) self._newdiract = gtk.Action('NewDir', 'New Directory', 'Create a new directory here', 'gtk-directory') self.add_action_to_toolbar(self._newdiract) self._newdiract.connect('activate', self.cb_act_new_dir) self._termact = gtk.Action('Terminal', 'Terminal', 'Open a terminal in this directory', 'gtk-terminal') self.add_action_to_toolbar(self._termact) self._termact.connect('activate', self.cb_act_terminal) self._searchact = gtk.Action('Search', 'Search', 'Search files for text', 'gtk-searchtool') self.add_action_to_toolbar(self._searchact) self._searchact.connect('activate', self.cb_act_search)
def insert_menu(self): manager = self.window.get_ui_manager() self.action_group = gtk.ActionGroup("RightPaneActionGroup1") rightpane_action = gtk.ToggleAction(name="ViewRightSidePane", label="Right Side Pane", tooltip="Right Pane", stock_id=None) rightpane_action.connect("activate", lambda a: self.display_right_pane()) self.action_group.add_toggle_actions([ ("ViewRightSidePane", None, _("Right Side Pane"), "<Ctrl>F8", _("Right Pane"), self.display_right_pane) ]) managerightpane_action = gtk.Action( name="ManageRightSidePane", label="Manage Left & Right Panes", tooltip="Left & Right Pane Manager", stock_id=None) managerightpane_action.connect("activate", lambda a: self.display_popup()) self.action_group.add_action_with_accel(managerightpane_action, "<Ctrl>F10") manager.insert_action_group(self.action_group, -1) self.ui_id = manager.new_merge_id() manager.add_ui_from_string(ui_str) group2 = gtk.ActionGroup("PythonPluginActions") action2 = gtk.Action(name="Python", label="Python", tooltip="All Python Plugins", stock_id=None) group2.add_action(action2) manager.insert_action_group(group2, -1) manager.ensure_update()
def build_action_group(obj, name=None): """ Build actions and a gtk.ActionGroup for each Action instance found in obj() (that's why Action is a class ;) ). This function requires GTK+. >>> class A(object): ... @action(name='bar') ... def bar(self): print('Say bar') ... @toggle_action(name='foo') ... def foo(self, active): print('Say foo', active) ... @radio_action(names=('baz', 'beer'), labels=('Baz', 'Beer')) ... def baz(self, value): ... print('Say', value, (value and "beer" or "baz")) >>> group = build_action_group(A()) Say 0 baz >>> len(group.list_actions()) 4 >>> a = group.get_action('bar') >>> a.activate() Say bar >>> group.get_action('foo').activate() Say foo True >>> group.get_action('beer').activate() Say 1 beer >>> group.get_action('baz').activate() Say 0 baz """ import gtk group = gtk.ActionGroup(name or obj) objtype = type(obj) for attrname in dir(obj): try: # Fetch the methods from the object's type instead of the object # itself. This prevents some desciptors (mainly gaphor.core.inject) # from executing. # Otherwise stuff like dependency resolving (=inject) may kick in # too early. method = getattr(objtype, attrname) except: continue act = getattr(method, '__action__', None) if isinstance(act, radio_action): actgroup = None if not act.labels: act.labels = [None] * len(act.names) if not act.tooltips: act.tooltips = [None] * len(act.names) if not act.stock_ids: act.stock_ids = [None] * len(act.names) if not act.accels: act.accels = [None] * len(act.names) assert len(act.names) == len(act.labels) assert len(act.names) == len(act.tooltips) assert len(act.names) == len(act.stock_ids) assert len(act.names) == len(act.accels) for i, n in enumerate(act.names): gtkact = gtk.RadioAction(n, act.labels[i], act.tooltips[i], act.stock_ids[i], value=i) if not actgroup: actgroup = gtkact else: gtkact.props.group = actgroup group.add_action_with_accel(gtkact, act.accels[i]) actgroup.connect('changed', _radio_action_changed, obj, attrname) actgroup.set_current_value(act.active) elif isinstance(act, toggle_action): gtkact = gtk.ToggleAction(act.name, act.label, act.tooltip, act.stock_id) gtkact.set_property('active', act.active) gtkact.connect('activate', _toggle_action_activate, obj, attrname) group.add_action_with_accel(gtkact, act.accel) elif isinstance(act, action): gtkact = gtk.Action(act.name, act.label, act.tooltip, act.stock_id) try: activate = act.opening and _action_opening or _action_activate except AttributeError: activate = _action_activate gtkact.connect('activate', activate, obj, attrname) group.add_action_with_accel(gtkact, act.accel) elif act is not None: raise TypeError('Invalid action type: %s' % action) return group
def __init__(self, kietol): self.kietol = kietol self.path = kietol.prefs.get("path") self.sort = kietol.prefs.getInt("sort") menuDef = """ <ui> <popup> <menu action="File"> <menuitem action="Open File"/> <menuitem action="Open Location"/> <menuitem action="Save List"/> <menuitem action="Clear List"/> <separator/> <menuitem action="Quit"/> </menu> <menu action="Options"> <menuitem action="Continuous Play"/> <menuitem action="Random Play"/> <menuitem action="Repeat List"/> <menuitem action="Edit MPlayer Config"/> </menu> <menu action="Sort"> <menuitem action="By Title"/> <menuitem action="By Full Path"/> <menuitem action="By Created"/> <menuitem action="By Accessed"/> <menuitem action="By Added"/> </menu> <menu action="Help"> <menuitem action="About"/> </menu> </popup> </ui> """ uiManager = gtk.UIManager() uiManager.add_ui_from_string(menuDef) actionGroup = gtk.ActionGroup("Actions") actions = ( ("File", None, "_File"), ("Open File", gtk.STOCK_OPEN, "_Open File", None, None, self.openFile), ("Open Location", gtk.STOCK_CONVERT, "Open _Location", "<Ctrl>L", None, self.openLocation), ("Save List", gtk.STOCK_SAVE, "_Save List", None, None, self.saveList), ("Clear List", gtk.STOCK_CANCEL, "_Clear List", None, None, self.clearList), ("Options", None, "_Options"), ("Edit MPlayer Config", gtk.STOCK_PROPERTIES, "_Edit MPlayer Config", None, None, self.editConfig), ("Sort", None, "_Sort"), ("Quit", gtk.STOCK_QUIT, "_Quit", None, None, kietol.quit), ("Help", None, "_Help"), ("About", gtk.STOCK_HELP, "About", None, None, self.openAbout), ) actionGroup.add_actions(actions) cont = gtk.ToggleAction("Continuous Play", "_Continuous Play", None, None) cont.connect("toggled", self.toggleContinuous) cont.set_active(self.kietol.playlist.continuous) actionGroup.add_action(cont) rand = gtk.ToggleAction("Random Play", "_Random Play", None, None) rand.connect("toggled", self.toggleRandom) rand.set_active(self.kietol.playlist.random) actionGroup.add_action(rand) rep = gtk.ToggleAction("Repeat List", "Repeat _List", None, None) rep.connect("toggled", self.toggleRepeat) rep.set_active(self.kietol.playlist.repeat) actionGroup.add_action(rep) self.sorts = [ ("By Title", None, "By _Title", None, None, playlist.COL_TITLE), ("By Full Path", None, "By _Full Path", None, None, playlist.COL_TARGET), ("By Created", None, "By _Created", None, None, playlist.COL_CTIME), ("By Accessed", None, "By _Accessed", None, None, playlist.COL_ATIME), ("By Added", None, "By _Added", None, None, playlist.COL_TID) ] actionGroup.add_radio_actions(self.sorts, self.sort, self.sortList) model = self.kietol.playlist.view.get_model() model.set_sort_column_id(self.sort, gtk.SORT_ASCENDING) uiManager.insert_action_group(actionGroup, 0) popup = uiManager.get_widget("/popup") self.kietol.window.add_accel_group(uiManager.get_accel_group()) self.popup = popup
def create_actions(self): # File menu self.action_open = gtk.Action('open_file', _('Add File'), _('Open a file or playlist'), gtk.STOCK_NEW) self.action_open.connect('activate', self.open_file_callback) self.action_open_dir = gtk.Action('open_dir', _('Add Folder'), _('Open a directory'), gtk.STOCK_OPEN) self.action_open_dir.connect('activate', self.open_dir_callback) self.action_save = gtk.Action('save', _('Save Playlist'), _('Save current playlist to file'), gtk.STOCK_SAVE_AS) self.action_save.connect('activate', self.save_to_playlist_callback) self.action_empty_playlist = gtk.Action('empty_playlist', _('Clear Playlist'), _('Clear current playlist'), gtk.STOCK_DELETE) self.action_empty_playlist.connect('activate', self.empty_playlist_callback) self.action_delete_bookmarks = gtk.Action('delete_bookmarks', _('Delete All Bookmarks'), _('Deleting all bookmarks'), gtk.STOCK_DELETE) self.action_delete_bookmarks.connect( 'activate', self.delete_all_bookmarks_callback) self.action_quit = gtk.Action('quit', _('Quit'), _('Close Panucci'), gtk.STOCK_QUIT) self.action_quit.connect('activate', self.destroy) # Tools menu self.action_playlist = gtk.Action('playlist', _('Playlist'), _('Open the current playlist'), None) self.action_playlist.connect('activate', lambda a: self.playlist_window.show()) self.action_settings = gtk.Action('settings', _('Settings'), _('Open the settings dialog'), None) self.action_settings.connect('activate', self.settings_callback) self.action_timer = gtk.Action('timer', _('Sleep Timer'), _('Start a timed shutdown'), None) self.action_timer.connect('activate', self.create_timer_dialog) # Settings menu self.action_lock_progress = gtk.ToggleAction('lock_progress', 'Lock Progress Bar', None, None) self.action_lock_progress.connect("activate", self.set_boolean_config_callback) self.action_lock_progress.set_active( self.config.getboolean("options", "lock_progress")) self.action_dual_action_button = gtk.ToggleAction( 'dual_action_button', 'Dual Action Button', None, None) self.action_dual_action_button.connect( "activate", self.set_boolean_config_callback) self.action_dual_action_button.set_active( self.config.getboolean("options", "dual_action_button")) self.action_stay_at_end = gtk.ToggleAction('stay_at_end', 'Stay at End', None, None) self.action_stay_at_end.connect("activate", self.set_boolean_config_callback) self.action_stay_at_end.set_active( self.config.getboolean("options", "stay_at_end")) self.action_seek_back = gtk.ToggleAction('seek_back', 'Seek Back', None, None) self.action_seek_back.connect("activate", self.set_boolean_config_callback) self.action_seek_back.set_active( self.config.getboolean("options", "seek_back")) self.action_scrolling_labels = gtk.ToggleAction( 'scrolling_labels', 'Scrolling Labels', None, None) self.action_scrolling_labels.connect("activate", self.scrolling_labels_callback) self.action_scrolling_labels.set_active( self.config.getboolean("options", "scrolling_labels")) self.action_play_mode = gtk.Action('play_mode', 'Play Mode', None, None) self.action_play_mode_all = gtk.RadioAction('all', 'All', None, None, 0) self.action_play_mode_all.connect("activate", self.set_play_mode_callback) self.action_play_mode_single = gtk.RadioAction('single', 'Single', None, None, 1) self.action_play_mode_single.connect("activate", self.set_play_mode_callback) self.action_play_mode_single.set_group(self.action_play_mode_all) self.action_play_mode_random = gtk.RadioAction('random', 'Random', None, None, 1) self.action_play_mode_random.connect("activate", self.set_play_mode_callback) self.action_play_mode_random.set_group(self.action_play_mode_all) self.action_play_mode_repeat = gtk.RadioAction('repeat', 'Repeat', None, None, 1) self.action_play_mode_repeat.connect("activate", self.set_play_mode_callback) self.action_play_mode_repeat.set_group(self.action_play_mode_all) if self.config.get("options", "play_mode") == "single": self.action_play_mode_single.set_active(True) elif self.config.get("options", "play_mode") == "random": self.action_play_mode_random.set_active(True) elif self.config.get("options", "play_mode") == "repeat": self.action_play_mode_repeat.set_active(True) else: self.action_play_mode_all.set_active(True) # Help menu self.action_about = gtk.Action('about', _('About'), _('Show application version'), gtk.STOCK_ABOUT) self.action_about.connect('activate', self.about_callback)
def __init__(self): # Create the toplevel window window = gtk.Window() window.connect('destroy', lambda w: gtk.main_quit()) window.set_size_request(300, -1) vbox = gtk.VBox() window.add(vbox) # Create an accelerator group accelgroup = gtk.AccelGroup() # Add the accelerator group to the toplevel window window.add_accel_group(accelgroup) # Create an ActionGroup named ActionExample actiongroup = gtk.ActionGroup('ActionExample') # Create an action for quitting the program using a stock item quitaction = gtk.Action('Quit', '_Quit me!', 'Quit the Program', gtk.STOCK_QUIT) quitaction.set_property('short-label', '_Quit') # Connect a callback to the action quitaction.connect('activate', self.quit_cb) # Add the action to the actiongroup with an accelerator # None means use the stock item accelerator actiongroup.add_action_with_accel(quitaction, None) # Have the action use accelgroup quitaction.set_accel_group(accelgroup) # Connect the accelerator to the action quitaction.connect_accelerator() # Create a ToggleAction, etc. muteaction = gtk.ToggleAction('Mute', '_Mute', 'Mute the volume', None) actiongroup.add_action_with_accel(muteaction, '<Control>m') muteaction.set_accel_group(accelgroup) muteaction.connect_accelerator() muteaction.connect('toggled', self.mute_cb) # Create some RadioActions amaction = gtk.RadioAction('AM', '_AM', 'AM Radio', None, 0) actiongroup.add_action_with_accel(amaction, '<Control>a') amaction.set_accel_group(accelgroup) amaction.connect_accelerator() amaction.set_active(True) fmaction = gtk.RadioAction('FM', '_FM', 'FM Radio', None, 1) actiongroup.add_action_with_accel(fmaction, '<Control>f') fmaction.set_accel_group(accelgroup) fmaction.connect_accelerator() fmaction.set_group(amaction) ssbaction = gtk.RadioAction('SSB', 'SS_B', 'Single Sideband Radio', None, 2) actiongroup.add_action_with_accel(ssbaction, '<Control>s') ssbaction.set_accel_group(accelgroup) ssbaction.connect_accelerator() ssbaction.connect('changed', self.radioband_cb) ssbaction.set_group(amaction) # Create a MenuBar menubar = gtk.MenuBar() vbox.pack_start(menubar, False) # Create the File Action and MenuItem file_action = gtk.Action('File', '_File', None, None) actiongroup.add_action(file_action) file_menuitem = file_action.create_menu_item() menubar.append(file_menuitem) # Create the File Menu file_menu = gtk.Menu() file_menuitem.set_submenu(file_menu) # Create a proxy MenuItem quititem = quitaction.create_menu_item() file_menu.append(quititem) # Create and populate the Sound menu with a Mute menuitem sound_action = gtk.Action('Sound', '_Sound', None, None) actiongroup.add_action(sound_action) sound_menuitem = sound_action.create_menu_item() menubar.append(sound_menuitem) sound_menu = gtk.Menu() sound_menuitem.set_submenu(sound_menu) muteitem = muteaction.create_menu_item() sound_menu.append(muteitem) # Create and populate the RadioBand menu radioband_action = gtk.Action('RadioBand', '_Radio Band', None, None) actiongroup.add_action(radioband_action) radioband_menuitem = radioband_action.create_menu_item() menubar.append(radioband_menuitem) radioband_menu = gtk.Menu() radioband_menuitem.set_submenu(radioband_menu) amitem = amaction.create_menu_item() radioband_menu.append(amitem) fmitem = fmaction.create_menu_item() radioband_menu.append(fmitem) ssbitem = ssbaction.create_menu_item() radioband_menu.append(ssbitem) # Create a Toolbar toolbar = gtk.Toolbar() vbox.pack_start(toolbar, False) # Create a proxy ToolItem quittoolitem = quitaction.create_tool_item() toolbar.insert(quittoolitem, 0) # Create a separator separator = gtk.SeparatorToolItem() toolbar.insert(separator, -1) # Create toggle and radio tool items and add to toolbar mutetoolitem = muteaction.create_tool_item() toolbar.insert(mutetoolitem, -1) separator = gtk.SeparatorToolItem() toolbar.insert(separator, -1) amtoolitem = amaction.create_tool_item() toolbar.insert(amtoolitem, -1) fmtoolitem = fmaction.create_tool_item() toolbar.insert(fmtoolitem, -1) ssbtoolitem = ssbaction.create_tool_item() toolbar.insert(ssbtoolitem, -1) # Create and pack two Labels label = gtk.Label('Sound is not muted') vbox.pack_start(label) self.mutelabel = label label = gtk.Label('Radio band is AM') vbox.pack_start(label) self.bandlabel = label # Create a button to use as another proxy widget quitbutton = gtk.Button() # add it to the window vbox.pack_start(quitbutton, False) # Connect the action to its proxy widget quitaction.connect_proxy(quitbutton) # Have to set tooltip after toolitems are added to toolbar for action in actiongroup.list_actions(): action.set_property('tooltip', action.get_property('tooltip')) tooltips = gtk.Tooltips() tooltips.set_tip(quitbutton, quitaction.get_property('tooltip')) window.show_all() return
def __init__(self, ctrl): GtkInterface.__init__(self, ctrl) self._changeset = None self._window = gtk.Window() self._window.set_title("Smart Package Manager %s" % VERSION) self._window.set_position(gtk.WIN_POS_CENTER) self._window.set_geometry_hints(min_width=640, min_height=480) def delete(widget, event): gtk.main_quit() return True self._window.connect("delete-event", delete) self._log.set_transient_for(self._window) self._progress.set_transient_for(self._window) self._hassubprogress.set_transient_for(self._window) self._changes.set_transient_for(self._window) self._watch = gtk.gdk.Cursor(gtk.gdk.WATCH) self._undo = [] self._redo = [] self._topvbox = gtk.VBox() self._topvbox.show() self._window.add(self._topvbox) globals = {"self": self, "gtk": gtk} self._actions = gtk.ActionGroup("Actions") self._actions.add_actions(compileActions(ACTIONS, globals)) self._filters = {} for name, label in [("hide-non-upgrades", _("Hide Non-upgrades")), ("hide-non-newest", _("Hide Non-newest")), ("hide-installed", _("Hide Installed")), ("hide-uninstalled", _("Hide Uninstalled")), ("hide-unmarked", _("Hide Unmarked")), ("hide-unlocked", _("Hide Unlocked")), ("hide-requested", _("Hide Requested")), ("hide-old", _("Hide Old"))]: action = gtk.ToggleAction(name, label, "", "") action.connect("toggled", lambda x, y: self.toggleFilter(y), name) self._actions.add_action(action) treestyle = sysconf.get("package-tree") lastaction = None for name, label in [("groups", _("Groups")), ("separate-groups", _("Separate Groups")), ("channels", _("Channels")), ("channels-groups", _("Channels & Groups")), ("none", _("None"))]: action = gtk.RadioAction("tree-style-"+name, label, "", "", 0) if name == treestyle: action.set_active(True) if lastaction: action.set_group(lastaction) lastaction = action action.connect("toggled", lambda x, y: self.setTreeStyle(y), name) self._actions.add_action(action) self._ui = gtk.UIManager() self._ui.insert_action_group(self._actions, 0) self._ui.add_ui_from_string(UI) self._menubar = self._ui.get_widget("/menubar") self._topvbox.pack_start(self._menubar, False) self._toolbar = self._ui.get_widget("/toolbar") self._toolbar.set_style(gtk.TOOLBAR_ICONS) self._topvbox.pack_start(self._toolbar, False) if sysconf.getReadOnly(): # Can't update channels in readonly mode. updatetoolitem = self._ui.get_widget("/toolbar/update-channels") updatetoolitem.set_property("sensitive", False) self._window.add_accel_group(self._ui.get_accel_group()) self._execmenuitem = self._ui.get_action("/menubar/file/exec-changes") self._execmenuitem.set_property("sensitive", False) self._clearmenuitem = self._ui.get_action("/menubar/edit/clear-changes") self._clearmenuitem.set_property("sensitive", False) self._undomenuitem = self._ui.get_action("/menubar/edit/undo") self._undomenuitem.set_property("sensitive", False) self._redomenuitem = self._ui.get_action("/menubar/edit/redo") self._redomenuitem.set_property("sensitive", False) # Search bar if gtk.gtk_version >= (2, 16, 0) or sexy: self._searchbar = gtk.ToolItem() self._searchbar.set_expand(True) self._searchbar.set_homogeneous(False) self._searchbar.show() count = self._toolbar.get_n_items() find = self._toolbar.get_nth_item(count - 1) self._toolbar.remove(find) self._toolbar.insert(self._searchbar, -1) searchtable = gtk.Table(1, 1) searchtable.set_row_spacings(5) searchtable.set_col_spacings(5) searchtable.set_border_width(5) searchtable.show() self._searchbar.add(searchtable) if gtk.gtk_version >= (2, 16, 0): self._searchentry = gtk.Entry() self._searchentry.set_property("primary-icon-name", "gtk-find") self._searchentry.set_property("secondary-icon-name", "gtk-clear") def press(entry, icon_pos, event): if int(icon_pos) == 0: # "primary" self._searchmenu.popup(None, None, None, event.button, event.time) elif int(icon_pos) == 1: # "secondary" self._searchentry.set_text("") self.refreshPackages() self._searchentry.connect("icon-press", press) elif sexy: self._searchentry = sexy.IconEntry() image = gtk.Image() image.set_from_stock("gtk-find", gtk.ICON_SIZE_BUTTON) self._searchentry.set_icon(sexy.ICON_ENTRY_PRIMARY, image) image = gtk.Image() image.set_from_stock("gtk-clear", gtk.ICON_SIZE_BUTTON) self._searchentry.set_icon(sexy.ICON_ENTRY_SECONDARY, image) def pressed(entry, icon_pos, button): if icon_pos == 0: # "primary" self._searchmenu.popup(None, None, None, button, gtk.get_current_event_time()) elif icon_pos == 1: # "secondary" self._searchentry.set_text("") self.refreshPackages() self._searchentry.connect("icon-pressed", pressed) self._searchentry.connect("activate", lambda x: self.refreshPackages()) self._searchentry.show() searchtable.attach(self._searchentry, 0, 1, 0, 1) self._searchmenu = gtk.Menu() self._searchname = gtk.CheckMenuItem(_("Automatic")) self._searchname.set_draw_as_radio(True) self._searchname.set_active(True) def search_automatic(item): self._searchdesc.set_active(not item.get_active()) self.refreshPackages() self._searchname.connect("activate", search_automatic) self._searchname.show() self._searchmenu.append(self._searchname) self._searchdesc = gtk.CheckMenuItem(_("Description")) self._searchdesc.set_draw_as_radio(True) self._searchdesc.set_active(False) def search_description(item): self._searchname.set_active(not item.get_active()) self.refreshPackages() self._searchdesc.connect("activate", search_description) self._searchdesc.show() self._searchmenu.append(self._searchdesc) else: self._searchbar = gtk.Alignment() self._searchbar.set(0, 0, 1, 1) self._searchbar.set_padding(3, 3, 0, 0) self._topvbox.pack_start(self._searchbar, False) searchvp = gtk.Viewport() searchvp.set_shadow_type(gtk.SHADOW_OUT) searchvp.show() self._searchbar.add(searchvp) searchtable = gtk.Table(1, 1) searchtable.set_row_spacings(5) searchtable.set_col_spacings(5) searchtable.set_border_width(5) searchtable.show() searchvp.add(searchtable) label = gtk.Label(_("Search:")) label.show() searchtable.attach(label, 0, 1, 0, 1, 0, 0) self._searchentry = gtk.Entry() self._searchentry.connect("activate", lambda x: self.refreshPackages()) self._searchentry.show() searchtable.attach(self._searchentry, 1, 2, 0, 1) button = gtk.Button() button.set_relief(gtk.RELIEF_NONE) button.connect("clicked", lambda x: self.refreshPackages()) button.show() searchtable.attach(button, 2, 3, 0, 1, 0, 0) image = gtk.Image() image.set_from_stock("gtk-find", gtk.ICON_SIZE_BUTTON) image.show() button.add(image) align = gtk.Alignment() align.set(1, 0, 0, 0) align.set_padding(0, 0, 10, 0) align.show() searchtable.attach(align, 3, 4, 0, 1, gtk.FILL, gtk.FILL) button = gtk.Button() button.set_size_request(20, 20) button.set_relief(gtk.RELIEF_NONE) button.connect("clicked", lambda x: self.toggleSearch()) button.show() align.add(button) image = gtk.Image() image.set_from_stock("gtk-close", gtk.ICON_SIZE_MENU) image.show() button.add(image) hbox = gtk.HBox() hbox.set_spacing(10) hbox.show() searchtable.attach(hbox, 1, 2, 1, 2) self._searchmenu = None self._searchname = gtk.RadioButton(None, _("Automatic")) self._searchname.set_active(True) self._searchname.connect("clicked", lambda x: self.refreshPackages()) self._searchname.show() hbox.pack_start(self._searchname, False) self._searchdesc = gtk.RadioButton(self._searchname, _("Description")) self._searchdesc.connect("clicked", lambda x: self.refreshPackages()) self._searchdesc.show() hbox.pack_start(self._searchdesc, False) # Packages and information self._hpaned = gtk.HPaned() self._hpaned.show() self._topvbox.pack_start(self._hpaned) scrollwin = gtk.ScrolledWindow() scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS) scrollwin.set_shadow_type(gtk.SHADOW_IN) self._hpaned.pack1(scrollwin, True) self._pg = gtk.TreeView() def group_selected(treeview): self.refreshPackages() self._pg.connect("cursor_changed", group_selected) self._pg.show() scrollwin.add(self._pg) selection = self._pg.get_selection() selection.set_mode(gtk.SELECTION_MULTIPLE) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn(_("Group"), renderer, text=1) self._pg.append_column(column) self._vpaned = gtk.VPaned() self._vpaned.show() self._hpaned.pack2(self._vpaned, True) self._pv = GtkPackageView() self._pv.show() self._vpaned.pack1(self._pv, True) self._pi = GtkPackageInfo() self._pi.show() self._pv.connect("package_selected", lambda x, y: self._pi.setPackage(y)) self._pv.connect("package_activated", lambda x, y: self.actOnPackages(y)) self._pv.connect("package_popup", self.packagePopup) self._vpaned.pack2(self._pi, False) self._status = gtk.Statusbar() self._status.show() self._topvbox.pack_start(self._status, False) self._legend = GtkLegend()
def __init__(self, ctrl): GtkInterface.__init__(self, ctrl) self._changeset = None self._window = gtk.Window() self._window.set_title("Smart Package Manager %s" % VERSION) self._window.set_position(gtk.WIN_POS_CENTER) self._window.set_geometry_hints(min_width=640, min_height=480) self._window.connect("destroy", lambda x: gtk.main_quit()) self._log.set_transient_for(self._window) self._progress.set_transient_for(self._window) self._hassubprogress.set_transient_for(self._window) self._watch = gtk.gdk.Cursor(gtk.gdk.WATCH) self._undo = [] self._redo = [] self._topvbox = gtk.VBox() self._topvbox.show() self._window.add(self._topvbox) globals = {"self": self, "gtk": gtk} self._actions = gtk.ActionGroup("Actions") self._actions.add_actions(compileActions(ACTIONS, globals)) self._filters = {} for name, label in [("hide-non-upgrades", _("Hide Non-upgrades")), ("hide-installed", _("Hide Installed")), ("hide-uninstalled", _("Hide Uninstalled")), ("hide-unmarked", _("Hide Unmarked")), ("hide-old", _("Hide Old"))]: action = gtk.ToggleAction(name, label, "", "") action.connect("toggled", lambda x, y: self.toggleFilter(y), name) self._actions.add_action(action) treestyle = sysconf.get("package-tree") lastaction = None for name, label in [("groups", _("Groups")), ("channels", _("Channels")), ("channels-groups", _("Channels & Groups")), ("none", _("None"))]: action = gtk.RadioAction("tree-style-" + name, label, "", "", 0) if name == treestyle: action.set_active(True) if lastaction: action.set_group(lastaction) lastaction = action action.connect("toggled", lambda x, y: self.setTreeStyle(y), name) self._actions.add_action(action) self._ui = gtk.UIManager() self._ui.insert_action_group(self._actions, 0) self._ui.add_ui_from_string(UI) self._menubar = self._ui.get_widget("/menubar") self._topvbox.pack_start(self._menubar, False) self._toolbar = self._ui.get_widget("/toolbar") self._toolbar.set_style(gtk.TOOLBAR_ICONS) self._topvbox.pack_start(self._toolbar, False) self._window.add_accel_group(self._ui.get_accel_group()) self._execmenuitem = self._ui.get_action("/menubar/file/exec-changes") self._execmenuitem.set_property("sensitive", False) self._clearmenuitem = self._ui.get_action( "/menubar/edit/clear-changes") self._clearmenuitem.set_property("sensitive", False) self._undomenuitem = self._ui.get_action("/menubar/edit/undo") self._undomenuitem.set_property("sensitive", False) self._redomenuitem = self._ui.get_action("/menubar/edit/redo") self._redomenuitem.set_property("sensitive", False) # Search bar self._searchbar = gtk.Alignment() self._searchbar.set(0, 0, 1, 1) self._searchbar.set_padding(3, 3, 0, 0) self._topvbox.pack_start(self._searchbar, False) searchvp = gtk.Viewport() searchvp.set_shadow_type(gtk.SHADOW_OUT) searchvp.show() self._searchbar.add(searchvp) searchtable = gtk.Table(1, 1) searchtable.set_row_spacings(5) searchtable.set_col_spacings(5) searchtable.set_border_width(5) searchtable.show() searchvp.add(searchtable) label = gtk.Label(_("Search:")) label.show() searchtable.attach(label, 0, 1, 0, 1, 0, 0) self._searchentry = gtk.Entry() self._searchentry.connect("activate", lambda x: self.refreshPackages()) self._searchentry.show() searchtable.attach(self._searchentry, 1, 2, 0, 1) button = gtk.Button() button.set_relief(gtk.RELIEF_NONE) button.connect("clicked", lambda x: self.refreshPackages()) button.show() searchtable.attach(button, 2, 3, 0, 1, 0, 0) image = gtk.Image() image.set_from_stock("gtk-find", gtk.ICON_SIZE_BUTTON) image.show() button.add(image) align = gtk.Alignment() align.set(1, 0, 0, 0) align.set_padding(0, 0, 10, 0) align.show() searchtable.attach(align, 3, 4, 0, 1, gtk.FILL, gtk.FILL) button = gtk.Button() button.set_size_request(20, 20) button.set_relief(gtk.RELIEF_NONE) button.connect("clicked", lambda x: self.toggleSearch()) button.show() align.add(button) image = gtk.Image() image.set_from_stock("gtk-close", gtk.ICON_SIZE_MENU) image.show() button.add(image) hbox = gtk.HBox() hbox.set_spacing(10) hbox.show() searchtable.attach(hbox, 1, 2, 1, 2) self._searchname = gtk.RadioButton(None, _("Automatic")) self._searchname.set_active(True) self._searchname.connect("clicked", lambda x: self.refreshPackages()) self._searchname.show() hbox.pack_start(self._searchname, False) self._searchdesc = gtk.RadioButton(self._searchname, _("Description")) self._searchdesc.connect("clicked", lambda x: self.refreshPackages()) self._searchdesc.show() hbox.pack_start(self._searchdesc, False) # Packages and information self._vpaned = gtk.VPaned() self._vpaned.show() self._topvbox.pack_start(self._vpaned) self._pv = GtkPackageView() self._pv.show() self._vpaned.pack1(self._pv, True) self._pi = GtkPackageInfo() self._pi.show() self._pv.connect("package_selected", lambda x, y: self._pi.setPackage(y)) self._pv.connect("package_activated", lambda x, y: self.actOnPackages(y)) self._pv.connect("package_popup", self.packagePopup) self._vpaned.pack2(self._pi, False) self._status = gtk.Statusbar() self._status.show() self._topvbox.pack_start(self._status, False)
def create_widgets(self): gtk.HPaned.__init__(self) self.create_spectralist() self.sl_add_action = gtk.Action("sl_add", None, _("Add spectra"), gtk.STOCK_ADD) self.sl_add_action.connect("activate", self.sl_add_button_cb) self.sl_remove_action = gtk.Action("sl_remove", None, _("Eliminate selected spectra"), gtk.STOCK_REMOVE) self.sl_remove_action.connect("activate", self.sl_remove_button_cb) self.sl_remove_action.set_sensitive(False) self.dil_paste_action = gtk.Action("dil_paste", None, _("Paste dilution data"), gtk.STOCK_PASTE) self.dil_paste_action.connect("activate", self._request_targets) self.dil_paste_action.set_sensitive(False) self.dil_reset_action = gtk.Action("dil_reset", None, _("Erase dilution data"), gtk.STOCK_CLEAR) self.dil_reset_action.connect("activate", self.reset_dilution_button_cb) self.show_preview_action = gtk.ToggleAction( "show_preview_action", _("Preview"), _("Show a plot of the selected spectrum"), gtk.STOCK_PRINT_PREVIEW) self.show_preview_action.connect("toggled", self._show_preview_toggle_cb) dil_menu = gtk.Menu() dil_menu.insert(self.dil_paste_action.create_menu_item(), -1) dil_menu.insert(self.dil_reset_action.create_menu_item(), -1) dil_toolmenu = gtk.MenuToolButton( \ icon_widget = gtk.image_new_from_stock(gtk.STOCK_PASTE, gtk.ICON_SIZE_SMALL_TOOLBAR), label=_("Dilution data")) dil_toolmenu.set_menu(dil_menu) dil_toolmenu.connect("clicked", self.dilution_menutoolbutton_cb) dil_toolmenu.set_tooltip(gtk.Tooltips(), _("Paste dilution factors")) dil_toolmenu.set_is_important(True) toolbar = gtk.Toolbar() toolbar.insert(self.sl_add_action.create_tool_item(), -1) toolbar.insert(self.sl_remove_action.create_tool_item(), -1) toolbar.insert(gtk.SeparatorToolItem(), -1) toolbar.insert(dil_toolmenu, -1) toolbar.insert(gtk.SeparatorToolItem(), -1) toolbar.insert(self.show_preview_action.create_tool_item(), -1) toolbar.set_style(gtk.TOOLBAR_BOTH_HORIZ) tv_vbox = gtk.VBox() tv_vbox.pack_start(toolbar, False, False, 4) tv_vbox.pack_start(self.spectra_scroll, True, True, 0) tv_frame = gtk.Frame(_("Spectra to be processed:")) tv_frame.add(tv_vbox) self.spectrum_panel = ShowSpectrumPanel() self.pack1(tv_frame, True, True) self.clipboard = gtk.clipboard_get(selection="CLIPBOARD")
def activate(self, shell): # internationalization LOCALE_DIR = self.find_file('locale') for module in (gettext, gtk.glade): module.bindtextdomain('RBLyrics', LOCALE_DIR) module.textdomain('RBLyrics') gettext.install('RBLyrics') # logging log.setLevel(logging.DEBUG) console_handler = logging.StreamHandler() console_handler.setLevel(logging.DEBUG) console_handler.setFormatter( logging.Formatter( '%(name)s %(levelname)-8s %(module)s::%(funcName)s - %(message)s' )) log.addHandler(console_handler) # log.info(sys.version) # self._prefs = Preference() self._display = Display(shell, self._prefs) self._chooser = LyricsChooser(self._chooser_handler) self._lyrics = None if not os.path.exists(self._prefs.get('main.directory')): os.mkdir(self._prefs.get('main.directory')) self._shell = shell self._handler = [ self._shell.props.shell_player.connect( 'playing-song-changed', self._on_playing_song_changed), self._shell.props.shell_player.connect('elapsed-changed', self._on_elapsed_changed), self._shell.props.shell_player.connect('playing-changed', self._on_playing_changed) ] # self._action = {} self._actiongroup = gtk.ActionGroup('RBLyricsActions') action = gtk.Action('OpenLyricsToolBar', _('Lyrics'), _('Open lyrics of the playing song'), gtk.STOCK_EDIT) action.connect('activate', self._on_lyrics_shortcut_activated) self._actiongroup.add_action(action) action = gtk.Action('OpenLyricsPopup', _('Edit Lyrics'), None, gtk.STOCK_EDIT) action.connect('activate', self._on_lyrics_popup_activated) self._actiongroup.add_action(action) action = gtk.Action('download-lyrics', _('Download Lyrics Manually'), None, gtk.STOCK_FIND) action.connect('activate', self._on_download_activated) self._actiongroup.add_action(action) action = gtk.ToggleAction('rblyrics-embedded', _('RBLyrics.Embedded'), None, None) action.set_active(self._prefs.get('display.embedded') == 'True') action.connect('toggled', self._on_embedded_toggled) self._action['display.embedded'] = action self._actiongroup.add_action(action) action = gtk.ToggleAction('rblyrics-gosd', _('RBLyrics.OSD'), None, None) action.set_active(self._prefs.get('display.gosd') == 'True') action.connect('toggled', self._on_gosd_toggled) self._action['display.gosd'] = action self._actiongroup.add_action(action) action = gtk.ToggleAction('rblyrics-roller', _('RBLyrics.Roller'), None, None) action.set_active(self._prefs.get('display.roller') == 'True') action.connect('toggled', self._on_roller_toggled) self._action['display.roller'] = action self._actiongroup.add_action(action) action = gtk.ToggleAction('rblyrics-single', _('RBLyrics.Single'), None, None) action.set_active(self._prefs.get('display.single') == 'True') action.connect('toggled', self._on_single_toggled) self._action['display.single'] = action self._actiongroup.add_action(action) # uim = shell.props.ui_manager uim.insert_action_group(self._actiongroup, 0) self._ui_id = uim.add_ui_from_file(self.find_file('ui.xml')) uim.ensure_update() self._prefs.watcher.append(self) log.info('activated') return