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
