def _create_action_a(self, group, type):
actions = group.list_actions()
if actions:
radioaction = gtk.RadioAction(
self.name, "A", type, None, len(actions)
)
radioaction.set_group(actions[0])
else:
radioaction = gtk.RadioAction(self.name, "A", type, None, 0)
radioaction.activate()
self.sltv.set_video_source(self.name)
group.add_action(radioaction)
if type == A_BUTTON:
radioaction.connect_proxy(self.a_button)
radioaction.connect("changed", self._on_a_press)
def _update_notebook_menu(self, *args):
if self.tab_switch_merge_id:
self.ui.remove_ui(self.tab_switch_merge_id)
self.ui.remove_action_group(self.tab_switch_actiongroup)
self.tab_switch_merge_id = self.ui.new_merge_id()
self.tab_switch_actiongroup = gtk.ActionGroup("TabSwitchActions")
self.ui.insert_action_group(self.tab_switch_actiongroup)
group = None
current_page = self.notebook.get_current_page()
for i in range(self.notebook.get_n_pages()):
page = self.notebook.get_nth_page(i)
label = self.notebook.get_menu_label_text(page) or ""
name = "SwitchTab%d" % i
tooltip = _("Switch to this tab")
action = gtk.RadioAction(name, label, tooltip, None, i)
action.set_group(group)
if group is None:
group = action
action.set_active(current_page == i)
def current_tab_changed_cb(action, current):
if action == current:
self.notebook.set_current_page(action.get_current_value())
action.connect("changed", current_tab_changed_cb)
if i < 10:
accel = "<Alt>%d" % ((i + 1) % 10)
else:
accel = None
self.tab_switch_actiongroup.add_action_with_accel(action, accel)
self.ui.add_ui(self.tab_switch_merge_id,
"/Menubar/TabMenu/TabPlaceholder", name, name,
gtk.UI_MANAGER_MENUITEM, False)
def _raw_check_action(self,
action,
label,
groups,
callback,
index,
group=None):
gtk_action = gtk.RadioAction(action, label, None, None, index)
if group is not None:
gtk_action.set_group(group)
gtk_action.connect("activate", callback, index)
self.action_groups[groups[0]].add_action(gtk_action)
def make_radio_action(self, action, radio_group, label, groups, shortcuts):
gtk_action = gtk.RadioAction(action, label, None, get_stock_id(action),
0)
self.setup_action(gtk_action, groups, shortcuts)
try:
root_action = self.radio_group_actions[radio_group]
except KeyError:
# gtk_action is the first action for the group.
self.radio_group_actions[radio_group] = gtk_action
else:
# There was already a gtk_action for this group
gtk_action.set_group(root_action)
def create_menu(self):
sections = {}
doc = self.boss.cmd('buffer', 'get_current')
menu = gtk.Menu()
act = None
a = gtk.RadioAction('None', 'None', 'No specific document type',
gtk.STOCK_NEW, 0)
a.set_data('doctype', None)
menu.add(a.create_menu_item())
menu.add(gtk.SeparatorMenuItem())
show_all = self.get_action('show_all_types').get_active()
for index, target in enumerate(self.doctypes.itervalues()):
if not show_all and target.support < 1:
continue
act = gtk.RadioAction(target.internal, target.human
or target.internal, target.tooltip, '',
index + 1)
act.set_group(a)
act.set_data('doctype', target)
mi = act.create_menu_item()
if target.section not in sections:
sections[target.section] = gtk.Menu()
#menu.add(sections[target.section])
ms = gtk.MenuItem(target.section)
ms.set_submenu(sections[target.section])
menu.add(ms)
sections[target.section].add(mi)
if doc and doc.doctype == target:
a.set_current_value(index + 1)
if doc and not doc.doctype:
a.set_current_value(0)
menu.show_all()
a.connect('changed', self.change_doctype)
return menu
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 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, 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 __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 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)