def _insert_menu(self):
"""Adds the menu entries for zooming."""
manager = self._window.get_ui_manager()
self._action_group = gtk.ActionGroup('ZoomPluginActions')
action_submenu = gtk.Action('ZoomSubMenu', _('_Zoom'), _('_Zoom'),
None)
action_enlarge_font = gtk.Action('EnlargeFont', _('Zoom _In'),
_('Zoom _In'), None)
action_enlarge_font.connect('activate', self._enlarge_font)
action_shrink_font = gtk.Action('ShrinkFont', _('Zoom _Out'),
_('Zoom _Out'), None)
action_shrink_font.connect('activate', self._shrink_font)
action_reset_font = gtk.Action('OriginalSize', _('_Reset'),
_('_Reset'), None)
action_reset_font.connect('activate', self._reset_font)
self._action_group.add_action(action_submenu)
self._action_group.add_action_with_accel(
action_enlarge_font, self.__class__._ENLARGE_ACCELERATORS[0])
self._action_group.add_action_with_accel(
action_shrink_font, self.__class__._SHRINK_ACCELERATORS[0])
self._action_group.add_action_with_accel(
action_reset_font, self.__class__._RESET_ACCELERATORS[0])
manager.insert_action_group(self._action_group)
self._ui_id = manager.add_ui_from_file(self.__class__._UI_FILE)
def activate(self, totem_object):
data = dict()
manager = totem_object.get_ui_manager()
data['action_group'] = gtk.ActionGroup('Python')
action = gtk.Action('Python', 'Python', _('Python Console Menu'), None)
data['action_group'].add_action(action)
action = gtk.Action('PythonConsole', _('_Python Console'),
_("Show Totem's Python console"),
'gnome-mime-text-x-python')
action.connect('activate', self.show_console, totem_object)
data['action_group'].add_action(action)
action = gtk.Action('PythonDebugger', _('Python Debugger'),
_("Enable remote Python debugging with rpdb2"),
None)
if have_rpdb2:
action.connect('activate', self.enable_debugging, totem_object)
else:
action.set_visible(False)
data['action_group'].add_action(action)
manager.insert_action_group(data['action_group'], 0)
data['ui_id'] = manager.add_ui_from_string(ui_str)
manager.ensure_update()
totem_object.set_data('PythonConsolePluginInfo', data)
def insert_menu_item(self, window):
manager = self.window.get_ui_manager()
self.action_group = gtk.ActionGroup("PythonPluginActions")
# Create an action for the "Run in python" menu option
# and set it to call the "run_document_in_python" function.
self.run_in_python_action = gtk.Action(name="ToolRunInPython", label="Run Document in Python", tooltip="Run the current document through the Python interpreter", stock_id=gtk.STOCK_REFRESH)
self.run_in_python_action.connect("activate", self.run_document_in_python)
# Create an action to allow the user to clear the contents of the bottom panel.
self.run_in_python_reset_action = gtk.Action(name="ToolRunInPython_Reset", label="Clear Run In Python output", tooltip="Clear the contents of the bottom panel", stock_id = None)
self.run_in_python_reset_action.connect("activate", lambda unused_param: self.output_area.output_data.clear())
# Add the action with Ctrl + F5 as its keyboard shortcut.
self.action_group.add_action_with_accel(self.run_in_python_action, "<Ctrl>F5")
self.action_group.add_action_with_accel(self.run_in_python_reset_action, "<Ctrl><Shift>F5")
# Add the action group.
manager.insert_action_group(self.action_group, -1)
# Add the item to the "Tools" menu.
self.ui_id = manager.add_ui_from_string(ui_string)
# Get the bottom panel.
panel = window.get_bottom_panel()
# Create an output area object (HBox) where we'll store the Python interpreter's output.
self.output_area = OutputArea(window)
# Add the item to the panel.
panel.add_item(self.output_area, "Output", gtk.Image())
def create_detach_popup(self, event):
if self.HAS_CONTROL_BOX and (self.HAS_CLOSE_BUTTON
or self.HAS_DETACH_BUTTON):
menu = gtk.Menu()
if self.HAS_DETACH_BUTTON:
act = gtk.Action(name='detach',
label='Detach',
tooltip='Detach this view',
stock_id='gtk-up')
def _det(_act):
self.__controlbar_clicked('detach')
act.connect('activate', _det)
mi = act.create_menu_item()
menu.add(mi)
if self.HAS_CLOSE_BUTTON:
act = gtk.Action(name='close',
label='Close',
tooltip='Close this view',
stock_id=gtk.STOCK_CLOSE)
def _close(_act):
self.__controlbar_clicked('close')
act.connect('activate', _close)
mi = act.create_menu_item()
menu.add(mi)
menu.show_all()
menu.popup(None, None, None, event.button, event.time)
def __init__(self, patchname):
title = _('gwsmhg: Patch "{0}" : {1}').format(
patchname, utils.path_rel_home(os.getcwd()))
dialogue.AmodalDialog.__init__(self,
title=title,
parent=dialogue.main_window,
flags=gtk.DIALOG_DESTROY_WITH_PARENT)
self.widget = Widget(patchname)
self.vbox.pack_start(self.widget, expand=True, fill=True)
self.refresh_action = gtk.Action('patch_view_refresh', _('_Refresh'),
_('Refresh this patch in database.'),
icons.STOCK_REFRESH_PATCH)
self.refresh_action.connect('activate', self._refresh_acb)
self.refresh_action.set_sensitive(
ifce.PM.get_top_patch() == self.widget.patchname)
refresh_button = gutils.ActionButton(self.refresh_action)
self.action_area.pack_start(refresh_button)
self._save_file = ifce.PM.get_patch_file_name(patchname)
self.save_action = gtk.Action('patch_view_save', _('_Export'),
_('Export patch to text file.'),
gtk.STOCK_SAVE_AS)
self.save_action.connect('activate', self._save_as_acb)
save_button = gutils.ActionButton(self.save_action)
self.action_area.pack_start(save_button)
self.add_buttons(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)
self.connect("response", self._close_cb)
self.add_notification_cb(
ws_event.PATCH_CHANGES | ws_event.FILE_CHANGES
| ws_event.AUTO_UPDATE, self._update_display_cb)
self.show_all()
def __init__(self):
self.config = tgcm.core.Config.Config(tgcm.country_support)
self.device_dialer = tgcm.core.FreeDesktop.DeviceDialer()
self.accelgroup = gtk.AccelGroup()
self.menubar = gtk.MenuBar()
self.main_actiongroup = gtk.ActionGroup('Tgcm')
self.help_actiongroup = gtk.ActionGroup('Help')
self.main_action = gtk.Action('Tgcm', self.config.get_app_name(), None,
None)
self.main_actiongroup.add_action(self.main_action)
self.main_menuitem = self.main_action.create_menu_item()
self.menubar.append(self.main_menuitem)
self.help_action = gtk.Action('HelpGroup', None, None, gtk.STOCK_HELP)
self.help_actiongroup.add_action(self.help_action)
self.help_menuitem = self.help_action.create_menu_item()
self.menubar.append(self.help_menuitem)
self.main_menu = gtk.Menu()
self.main_menuitem.set_submenu(self.main_menu)
self.help_menu = gtk.Menu()
self.help_menuitem.set_submenu(self.help_menu)
def __create_crypt(self):
root = gtk.Menu()
action = gtk.Action(None, _('Encryption'), None,
gtk.STOCK_DIALOG_AUTHENTICATION)
item = action.create_menu_item()
item.set_submenu(root)
self.menubar.append(item)
lbls = ('MD5', 'SHA-1', 'SHA-256', 'ROT13')
cbs = (self.__crypt_md5, self.__crypt_sha1, self.__crypt_sha256,
self.__crypt_rot13)
for lbl, cb in zip(lbls, cbs):
action = gtk.Action(None, lbl, None,
gtk.STOCK_DIALOG_AUTHENTICATION)
item = action.create_menu_item()
action.connect('activate', cb)
if lbl == "SHA-256":
item.set_sensitive(SHA256_ENABLED)
root.append(item)
def activate(self, shell):
data = dict()
manager = shell.get_player().get_property('ui-manager')
data['action_group'] = gtk.ActionGroup('PythonConsolePluginActions')
action = gtk.Action('PythonConsole', _('_Python Console'),
_("Show Rhythmbox's python console"),
'gnome-mime-text-x-python')
action.connect('activate', self.show_console, shell)
data['action_group'].add_action(action)
action = gtk.Action('PythonDebugger', _('Python Debugger'),
_("Enable remote python debugging with rpdb2"),
None)
if have_rpdb2:
action.connect('activate', self.enable_debugging, shell)
else:
action.set_visible(False)
data['action_group'].add_action(action)
manager.insert_action_group(data['action_group'], 0)
data['ui_id'] = manager.add_ui_from_string(ui_str)
manager.ensure_update()
shell.set_data('PythonConsolePluginInfo', data)
def activate(self, shell):
self.shell = shell # so the source can update the progress bar
self.db = shell.get_property("db")
self.entry_type = self.db.entry_register_type("MagnatuneEntryType")
# allow changes which don't do anything
self.entry_type.can_sync_metadata = True
self.entry_type.sync_metadata = None
theme = gtk.icon_theme_get_default()
rb.append_plugin_source_path(theme, "/icons")
width, height = gtk.icon_size_lookup(gtk.ICON_SIZE_LARGE_TOOLBAR)
icon = rb.try_load_icon(theme, "magnatune", width, 0)
group = rb.rb_source_group_get_by_name("stores")
self.source = gobject.new(MagnatuneSource,
shell=shell,
entry_type=self.entry_type,
source_group=group,
icon=icon,
plugin=self)
shell.register_entry_type_for_source(self.source, self.entry_type)
shell.append_source(self.source, None) # Add the source to the list
manager = shell.get_player().get_property('ui-manager')
# Add the popup menu actions
self.action_group = gtk.ActionGroup('MagnatunePluginActions')
action = gtk.Action('MagnatuneDownloadAlbum', _('Download Album'),
_("Download this album from Magnatune"),
'gtk-save')
action.connect(
'activate', lambda a: self.shell.get_property("selected-source").
download_album())
self.action_group.add_action(action)
action = gtk.Action('MagnatuneArtistInfo', _('Artist Information'),
_("Get information about this artist"), 'gtk-info')
action.connect(
'activate', lambda a: self.shell.get_property("selected-source").
display_artist_info())
self.action_group.add_action(action)
action = gtk.Action('MagnatuneCancelDownload', _('Cancel Downloads'),
_("Stop downloading purchased albums"), 'gtk-stop')
action.connect(
'activate', lambda a: self.shell.get_property("selected-source").
cancel_downloads())
action.set_sensitive(False)
self.action_group.add_action(action)
manager.insert_action_group(self.action_group, 0)
self.ui_id = manager.add_ui_from_string(popup_ui)
self.pec_id = shell.get_player().connect('playing-song-changed',
self.playing_entry_changed)
manager.ensure_update()
def _create_actions(self):
self._current = None
self.add_widget(
'dis_act',
gtk.Action('Disable', 'Disable', 'Disable this breakpoint',
gtk.STOCK_NO))
self.add_widget(
'en_act',
gtk.Action('Enable', 'Enable', 'Enable this breakpoint',
gtk.STOCK_YES))
def PyFileActionSubmenu(menu):
action = gtk.Action("TMP:SubSubmenuitem1", "Subsubmenuitem 1", None, None)
subitem = action.create_menu_item()
menu.append(subitem)
subitem.show()
action = gtk.Action("TMP:SubSubmenuitem2", "Subsubmenuitem 2", None, None)
subitem = action.create_menu_item()
menu.append(subitem)
subitem.show()
def _insert_menu( self ): manager = self._window.get_ui_manager() self._action_group = gtk.ActionGroup( "SnapOpenPluginActions" ) snapopen_menu_action = gtk.Action( name="SnapOpenMenuAction", label="Snap", tooltip="Snap tools", stock_id=None ) self._action_group.add_action( snapopen_menu_action ) snapopen_action = gtk.Action( name="SnapOpenAction", label="Snap Open...\t", tooltip="Open file by autocomplete...", stock_id=gtk.STOCK_JUMP_TO ) snapopen_action.connect( "activate", lambda a: self.on_snapopen_action() ) self._action_group.add_action_with_accel( snapopen_action, "<Ctrl><Alt>o" ) manager.insert_action_group( self._action_group, 0 ) self._ui_id = manager.new_merge_id() manager.add_ui_from_string( ui_str ) manager.ensure_update()
def _make_station_menu(self, station, port):
xml = """
<ui>
<popup name="menu">
<menuitem action="ping"/>
<menuitem action="conntest"/>
<menuitem action="reqpos"/>
<menuitem action="sendfile"/>
<menuitem action="version"/>
<menuitem action="mcheck"/>
<menuitem action="qrz"/>
<separator/>
<menuitem action="remove"/>
<menuitem action="reset"/>
<separator/>
<menuitem action="clearall"/>
<menuitem action="pingall"/>
<menuitem action="reqposall"/>
</popup>
</ui>
"""
ag = gtk.ActionGroup("menu")
actions = [("ping", _("Ping"), None),
("conntest", _("Test Connectivity"), None),
("reqpos", _("Request Position"), None),
("sendfile", _("Send file"), None),
("remove", _("Remove"), gtk.STOCK_DELETE),
("reset", _("Reset"), gtk.STOCK_JUMP_TO),
("version", _("Get version"), gtk.STOCK_ABOUT),
("mcheck", _("Request mail check"), None),
("qrz", _("Check on Qrz.com"), None)]
for action, label, stock in actions:
a = gtk.Action(action, label, None, stock)
a.connect("activate", self._mh, station, port)
a.set_sensitive(station is not None)
ag.add_action(a)
actions = [("clearall", _("Clear All"), gtk.STOCK_CLEAR),
("pingall", _("Ping All Stations"), None),
("reqposall", _("Request all positions"), None)]
for action, label, stock in actions:
a = gtk.Action(action, label, None, stock)
a.connect("activate", self._mh, station, port)
ag.add_action(a)
uim = gtk.UIManager()
uim.insert_action_group(ag, 0)
uim.add_ui_from_string(xml)
return uim.get_widget("/menu")
def activate(self, shell):
self.db = shell.get_property("db")
self.entry_type = self.db.entry_register_type("JamendoEntryType")
# allow changes which don't do anything
self.entry_type.can_sync_metadata = True
self.entry_type.sync_metadata = None
theme = gtk.icon_theme_get_default()
rb.append_plugin_source_path(theme, "/icons/")
width, height = gtk.icon_size_lookup(gtk.ICON_SIZE_LARGE_TOOLBAR)
icon = rb.try_load_icon(theme, "jamendo", width, 0)
group = rb.rb_source_group_get_by_name("stores")
self.source = gobject.new(JamendoSource,
shell=shell,
entry_type=self.entry_type,
plugin=self,
icon=icon,
source_group=group)
shell.register_entry_type_for_source(self.source, self.entry_type)
shell.append_source(self.source, None) # Add the source to the list
# Add button
manager = shell.get_player().get_property('ui-manager')
action = gtk.Action('JamendoDownloadAlbum', _('_Download Album'),
_("Download this album using BitTorrent"),
'gtk-save')
action.connect(
'activate',
lambda a: shell.get_property("selected-source").download_album())
self.action_group = gtk.ActionGroup('JamendoPluginActions')
self.action_group.add_action(action)
# Add Button for Donate
action = gtk.Action('JamendoDonateArtist', _('_Donate to Artist'),
_("Donate Money to this Artist"), 'gtk-jump-to')
action.connect(
'activate',
lambda a: shell.get_property("selected-source").launch_donate())
self.action_group.add_action(action)
manager.insert_action_group(self.action_group, 0)
self.ui_id = manager.add_ui_from_string(popup_ui)
manager.ensure_update()
self.pec_id = shell.get_player().connect('playing-song-changed',
self.playing_entry_changed)
def __on_button_press(self, tree, event):
self.last_pos = (event.x, event.y)
if event.button != 3:
return
selected = self.get_selected_ips()
if not selected:
return
info_str = len(selected) == 1 and \
selected[0] or _('%d IP') % len(selected)
session = ServiceBus().call('pm.sessions', 'get_current_session')
if session.session_name == 'AUDIT' and \
session.get_current_page_name() == 'TARGETS':
sensitive = True
else:
sensitive = False
menu = gtk.Menu()
act = gtk.Action('target1-add',
_("Add '%s' to target1") % info_str, None,
gtk.STOCK_ADD)
act.connect('activate', lambda a, (s, ip): \
s.target_page.target1_tree.append(ip), (session, selected))
item = act.create_menu_item()
item.set_sensitive(sensitive)
menu.append(item)
act = gtk.Action('target2-add',
_("Add '%s' to target2") % info_str, None,
gtk.STOCK_ADD)
act.connect('activate', lambda a, (s, ip): \
s.target_page.target2_tree.append(ip), (session, selected))
item = act.create_menu_item()
item.set_sensitive(sensitive)
menu.append(item)
menu.show_all()
menu.popup(None, None, None, event.button, event.time)
return True
def cb_popup(self, t, menu):
if not t.get_selection():
menu.get_children()[0].set_sensitive(False)
x, y = t.window_to_buffer_coords(*t.get_pointer())
i = t.get_iter_at_location(x, y)
if i.has_tag(self.it) or i.has_tag(self.pt):
e = i.copy()
if i.has_tag(self.it):
i.get_tag_start(self.it)
e.get_tag_end(self.it)
string = i.get_text(e)
filename, ln, empty = string.split(':')
elif i.has_tag(self.pt):
i.get_tag_start(self.pt)
e.get_tag_end(self.pt)
string = i.get_text(e)
filename, ln = pre.search(string).groups()
menu.add(gtk.SeparatorMenuItem())
a = gtk.Action('goto-line', 'Goto line', 'Goto the line',
gtk.STOCK_OK)
mi = a.create_menu_item()
menu.add(mi)
menu.show_all()
a.connect('activate', self.act_gotoline, filename, int(ln) - 1)
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 build_popup_menu(self):
# TEST
manager = self.window.get_ui_manager()
if (self.ui_popup_id):
manager.remove_ui(self.ui_popup_id)
self.ui_popup_id = None
self.action_group.remove_action(self.popup_action)
self.ui_popup_id = manager.new_merge_id()
action_name = "splitview_popup_submenu"
path = "/NotebookPopup/NotebookPupupOps_1"
manager.add_ui(merge_id=self.ui_popup_id,
path=path,
name=action_name,
action=action_name,
type=gtk.UI_MANAGER_MENU,
top=False)
self.popup_action = gtk.Action(
name=action_name,
label="Quick Splitview",
tooltip="Choose another document to view...",
stock_id=None)
self.popup_action.set_visible(True)
self.action_group.add_action(self.popup_action)
def test_linker(self):
buff = gtk.TextBuffer()
act = gtk.Action("Fop", "", None, None)
l = sensitive.SaveLinker(buff, act)
ref = weakref.ref(l)
l = None
assert ref() is None
def __init__(self):
self._ui = None
self.default_store = get_default_store()
self._printer_verified = False
# Delay printer creation until we are accessing pos or till app. Other
# applications should still be accessible without a printer
self._printer = None
SaleStatusChangedEvent.connect(self._on_SaleStatusChanged)
ECFIsLastSaleEvent.connect(self._on_ECFIsLastSale)
TillOpenEvent.connect(self._on_TillOpen)
TillCloseEvent.connect(self._on_TillClose)
TillAddCashEvent.connect(self._on_TillAddCash)
TillAddTillEntryEvent.connect(self._on_AddTillEntry)
TillRemoveCashEvent.connect(self._on_TillRemoveCash)
StartApplicationEvent.connect(self._on_StartApplicationEvent)
StopApplicationEvent.connect(self._on_StopApplicationEvent)
CouponCreatedEvent.connect(self._on_CouponCreatedEvent)
GerencialReportPrintEvent.connect(self._on_GerencialReportPrintEvent)
GerencialReportCancelEvent.connect(self._on_GerencialReportCancelEvent)
CheckECFStateEvent.connect(self._on_CheckECFStateEvent)
HasPendingReduceZ.connect(self._on_HasPendingReduceZ)
HasOpenCouponEvent.connect(self._on_HasOpenCouponEvent)
self._till_summarize_action = gtk.Action('Summary', _('Summary'), None,
None)
self._till_summarize_action.connect('activate',
self._on_TillSummary__activate)
add_bindings([
('plugin.ecf.read_memory', '<Primary>F9'),
('plugin.ecf.summarize', '<Primary>F11'),
])
def _make_session_menu(self, sid, event):
xml = """
<ui>
<popup name="menu">
<menuitem action="stop"/>
<menuitem action="cancel"/>
<menuitem action="restart"/>
</popup>
</ui>
"""
ag = gtk.ActionGroup("menu")
actions = [("stop", _("Stop"), not event.is_final()),
("cancel", _("Cancel"), not event.is_final()),
("restart", _("Restart"), event.get_restart_info())]
for action, label, sensitive in actions:
a = gtk.Action(action, label, None, None)
a.connect("activate", self._mh_xfer, event)
a.set_sensitive(bool(sensitive))
ag.add_action(a)
uim = gtk.UIManager()
uim.insert_action_group(ag, 0)
uim.add_ui_from_string(xml)
return uim.get_widget("/menu")
def start(self, reader):
self.reader = reader
self.icon = None
self.wnd_pos = (0, 0)
self.menu = gtk.Menu()
self.menu.show()
action = gtk.Action(None, '_Quit', 'Quit from UMIT', gtk.STOCK_QUIT)
action.connect('activate', self.__on_quit)
item = action.create_menu_item()
item.show()
self.menu.append(item)
self.type = self.notifier = None
# Force to use win32 module
if WIN32_PRESENT:
self.set_type(TrayPlugin.TYPE_WINDOWS)
else:
self.set_type(tray_prefs.parser['notifications']['type'].value)
tray_prefs.parser['notifications']['type'].value = self.type
logo = os.path.join(Path.icons_dir, 'umit_16.ico')
log.debug('Creating status icon with %s as logo' % logo)
self.icon = gtk.status_icon_new_from_file(logo)
tray_prefs.change_cb = self.set_type
self.icon.connect('popup-menu', self.__on_right_click)
self.icon.connect('activate', self.__on_activate)
def build_menus(self, accelerators):
menu_entries = (
('ConnectAction', gtk.STOCK_CONNECT, None, 'app.connect()',
self.main_menu),
('DisconnectAction', gtk.STOCK_DISCONNECT, None,
'app.disconnect()', self.main_menu),
('AnAction', None, _('Available networks'), 'app.networks()',
self.main_menu),
('QuitAction', gtk.STOCK_QUIT, None, 'window.close()',
self.main_menu),
('HelpAction', gtk.STOCK_HELP, None, 'app.help()', self.help_menu),
)
for entry_id, stock_id, name, oper_id, menu in menu_entries:
action = gtk.Action(entry_id, name, None, stock_id)
action.connect('activate', self.menu_callback, oper_id)
accelerator = None
if (oper_id in accelerators) and ('window.close' not in oper_id):
accelerator = accelerators[oper_id]
self.main_actiongroup.add_action_with_accel(action, accelerator)
action.set_accel_group(self.accelgroup)
action.connect_accelerator()
menu_item = action.create_menu_item()
menu.append(menu_item)
if entry_id == 'ConnectAction':
self.connect_menuitem = menu_item
elif entry_id == 'DisconnectAction':
self.disconnect_menuitem = menu_item
self.device_dialer.connect('connected', self._on_connected)
self.device_dialer.connect('disconnected', self._on_disconnected)
def add_macro(self, config_name, modulename, classname, methodname,
help, image_path, run_macro):
"""Add a macro to the macro menu."""
macro_address = '/TopMenuBar/Metadata'
macro_menu = self.uimanager.get_widget(macro_address).get_submenu()
if methodname == rose.macro.VALIDATE_METHOD:
all_v_item = self.uimanager.get_widget(macro_address + "/All V")
all_v_item.set_sensitive(True)
config_menu_name = config_name.replace('/', ':').replace('_', '__')
config_label_name = config_name.split('/')[-1].replace('_', '__')
label = rose.config_editor.TOP_MENU_METADATA_MACRO_CONFIG.format(
config_label_name)
config_address = macro_address + '/' + config_menu_name
config_item = self.uimanager.get_widget(config_address)
if config_item is None:
actiongroup = self.uimanager.get_action_groups()[0]
if actiongroup.get_action(config_menu_name) is None:
actiongroup.add_action(gtk.Action(config_menu_name,
label,
None, None))
new_ui = """<ui><menubar name="TopMenuBar">
<menu action="Metadata">
<menuitem action="{0}"/></menu></menubar>
</ui>""".format(config_menu_name)
self.macro_ids.append(self.uimanager.add_ui_from_string(new_ui))
config_item = self.uimanager.get_widget(config_address)
if image_path is not None:
image = gtk.image_new_from_file(image_path)
config_item.set_image(image)
if config_item.get_submenu() is None:
config_item.set_submenu(gtk.Menu())
macro_fullname = ".".join([modulename, classname, methodname])
macro_fullname = macro_fullname.replace("_", "__")
if methodname == rose.macro.VALIDATE_METHOD:
stock_id = gtk.STOCK_DIALOG_QUESTION
else:
stock_id = gtk.STOCK_CONVERT
macro_item = gtk.ImageMenuItem(stock_id=stock_id)
macro_item.set_label(macro_fullname)
macro_item.set_tooltip_text(help)
macro_item.show()
macro_item._run_data = [config_name, modulename, classname,
methodname]
macro_item.connect("activate",
lambda i: run_macro(*i._run_data))
config_item.get_submenu().append(macro_item)
if (methodname == rose.macro.VALIDATE_METHOD):
for item in config_item.get_submenu().get_children():
if hasattr(item, "_rose_all_validators"):
return False
all_item = gtk.ImageMenuItem(gtk.STOCK_DIALOG_QUESTION)
all_item._rose_all_validators = True
all_item.set_label(rose.config_editor.MACRO_MENU_ALL_VALIDATORS)
all_item.set_tooltip_text(
rose.config_editor.MACRO_MENU_ALL_VALIDATORS_TIP)
all_item.show()
all_item._run_data = [config_name, None, None, methodname]
all_item.connect("activate",
lambda i: run_macro(*i._run_data))
config_item.get_submenu().prepend(all_item)
def activate(self, shell):
self.shell = shell
self.db = shell.props.db
self.library = self.shell.props.library_source
self.player = shell.props.shell_player
data = dict()
ui_manager = shell.get_ui_manager()
icon_file_name = self.find_file("echo_logo_64a.png")
iconsource = gtk.IconSource()
iconsource.set_filename(icon_file_name)
iconset = gtk.IconSet()
iconset.add_source(iconsource)
iconfactory = gtk.IconFactory()
iconfactory.add("genius_icon", iconset)
iconfactory.add_default()
data['action_group'] = gtk.ActionGroup('GeniusPluginActions')
action = gtk.Action('MakeGeniusPlaylist',
_('Echo Nest Recommender Playlist'),
_("Make an Echo Nest Recommender playlist"),
"genius_icon")
action.connect('activate', self.make_playlist, shell)
data['action_group'].add_action(action)
ui_manager.insert_action_group(data['action_group'], 0)
data['ui_id'] = ui_manager.add_ui_from_string(ui_toolbar_button)
ui_manager.ensure_update()
shell.set_data('GeniusPluginInfo', data)
def os_append_menu(self):
"""
"""
self.os_action_group = gtk.ActionGroup('OpenSubtitles')
self.action = gtk.Action(
'opensubtitles', _('_Download Movie Subtitles...'),
_("Download movie subtitles from OpenSubtitles"), '')
self.os_action_group.add_action(self.action)
self.manager.insert_action_group(self.os_action_group, 0)
self.menu_id = self.manager.new_merge_id()
self.manager.add_ui(
self.menu_id,
'/tmw-menubar/view/subtitles/subtitle-download-placeholder',
'opensubtitles', 'opensubtitles', gtk.UI_MANAGER_MENUITEM, False)
self.action.set_visible(True)
self.manager.ensure_update()
self.action.connect('activate', self.os_show_dialog, self.totem)
self.action.set_sensitive(self.totem.is_playing()
and self.os_check_allowed_scheme()
and not self.os_check_is_audio())
def __init__(self):
gtk.VBox.__init__(self, False, 2)
self.entry = FilterEntry()
self.tree = AuditOutputTree()
self.toolbar = gtk.Toolbar()
self.toolbar.set_style(gtk.TOOLBAR_ICONS)
action = gtk.Action('save', _('Save log'),
_('Save log to file'), gtk.STOCK_SAVE)
action.connect('activate', self.tree.on_save_log)
item = action.create_tool_item()
self.toolbar.insert(item, -1)
item = gtk.ToolItem()
item.add(self.entry)
item.set_expand(True)
self.toolbar.insert(item, -1)
self.pack_start(self.toolbar, False, False)
self.pack_end(self.tree)
self.entry.get_entry().connect('changed', self.__on_filter)
def __on_button_press(self, widget, evt, typo):
if evt.button != 3:
return
menu = gtk.Menu()
# OK show a popup to copy and paste
# cut/copy/paste/delete
txts = (_('Cu_t'), _('_Copy'), _('_Paste'), _('Copy from _both'))
icons = (gtk.STOCK_CUT, gtk.STOCK_COPY, gtk.STOCK_PASTE,
gtk.STOCK_COPY)
cbcs = (self.__on_cut, self.__on_copy, self.__on_paste,
self.__on_bcopy)
clipboard_sel = gtk.clipboard_get().wait_for_text() and True or False
idx = 0
for txt, icon, cbc in zip(txts, icons, cbcs):
action = gtk.Action(None, txt, None, icon)
action.connect('activate', cbc, typo)
item = action.create_menu_item()
if not clipboard_sel and idx == 2:
item.set_sensitive(False)
menu.append(item)
idx += 1
menu.popup(None, None, None, evt.button, evt.time, None)
menu.show_all()
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 update_history (self, history):
''' fill the " Previous Documents " menu with the specified list of documents '''
if self.recents:
for mid in self.recents_mid:
self.uim.remove_ui (mid)
self.uim.remove_action_group (self.recents)
self.recents_mid = []
self.recents = gtk.ActionGroup ('Recent')
self.uim.insert_action_group (self.recents, 1)
for item in history:
# Display name in the menu
quoted = string.replace (item [0], '_', '__')
mid = self.uim.new_merge_id ()
self.recents_mid.append (mid)
action = gtk.Action (str (mid), quoted, None, None)
self.recents.add_action (action)
action.connect ('activate', self._history_open_cb, item)
self.uim.add_ui (mid, '/Menubar/File/Recent', str (mid),
str (mid), gtk.UI_MANAGER_MENUITEM, False)
return
