def do_create_configure_widget(self):
def account_details_changed(entry, event):
username = builder.get_object('usernameEntry').get_text()
password = builder.get_object('passwordEntry').get_text()
gStatsUtil.save_account_info(username, password, self.plugin_info.get_data_dir())
return False
self.configure_callback_dic = {
"rb_google_sync_info_changed_cb" : account_details_changed,
}
builder = Gtk.Builder()
builder.add_from_file(rb.find_plugin_file(self, 'preferences.ui'))
dialog = builder.get_object('vbox1')
builder.connect_signals(self.configure_callback_dic)
account_file = rb.find_plugin_file(self, 'account.dat')
if account_file != None:
f = open(account_file)
builder.get_object('usernameEntry').set_text(f.readline().rstrip())
builder.get_object('passwordEntry').set_text(f.readline())
f.close()
return dialog
def __init__(self, plugin, sprite_name, size=None):
self.plugin = plugin
self.popups = rb.find_plugin_file(plugin, self.popups)
self.tree = ET.ElementTree(file=self.popups)
root = self.tree.getroot()
base = 'spritesheet[@name="' + sprite_name + '"]/'
image = rb.find_plugin_file(plugin, 'img/' +
root.findall(base + 'image')[0].text)
icon_width = int(root.findall(base + 'icon')[0].attrib['width'])
icon_height = int(root.findall(base + 'icon')[0].attrib['height'])
x_spacing = int(root.findall(base + 'spacing')[0].attrib['x'])
y_spacing = int(root.findall(base + 'spacing')[0].attrib['y'])
x_start = int(root.findall(base + 'start-position')[0].attrib['x'])
y_start = int(root.findall(base + 'start-position')[0].attrib['y'])
try:
alpha_color = map(int,
root.findall(base + 'alpha')[0].text.split(' '))
except:
alpha_color = None
self.names = []
for elem in root.findall(sprite_name + '/' + sprite_name +
'[@spritesheet="' + sprite_name + '"]'):
self.names.append(elem.attrib['name'])
self._sheet = SpriteSheet(image, icon_width, icon_height, x_spacing,
y_spacing, x_start, y_start, alpha_color, size)
def __init__(self, source, window):
super(ViewManager, self).__init__()
self.source = source
self.window = window
# initialize views
self._views = {}
ui = Gtk.Builder()
ui.add_from_file(rb.find_plugin_file(source.plugin,
'ui/coverart_iconview.ui'))
self._views[CoverIconView.name] = ui.get_object('covers_view')
self._views[CoverFlowView.name] = CoverFlowView()
self._views[ListView.name] = ListView()
ui.add_from_file(rb.find_plugin_file(source.plugin,
'ui/coverart_artistview.ui'))
self._views[ArtistView.name] = ui.get_object('artist_view')
self._lastview = None
self.controller = ViewController(source.shell, self)
# connect signal and properties
self._connect_signals()
self._connect_properties()
self._lastview = self.view_name
if self.current_view.use_plugin_window:
window.add(self.current_view.view)
window.show_all()
def load_templates(self, plugin):
'''
Loads the templates and stylesheets to be used by the pane.
'''
# input_encoding='utf-8',
path = rb.find_plugin_file(plugin,
'tmpl/albumartsearch-tmpl.html')
self.template = Template(filename=path,
default_filters=['decode.utf8'],
module_directory='/tmp/',
encoding_errors='replace')
path = rb.find_plugin_file(plugin,
'tmpl/albumartsearchempty-tmpl.html')
self.empty_template = Template(filename=path,
default_filters=['decode.utf8'],
module_directory='/tmp/',
encoding_errors='replace')
path = rb.find_plugin_file(plugin,
'tmpl/artistartsearch-tmpl.html')
self.artist_template = Template(filename=path,
default_filters=['decode.utf8'],
module_directory='/tmp/',
encoding_errors='replace')
self.styles = rb.find_plugin_file(plugin, 'tmpl/main.css')
def __init__(self, plugin, sprite_name, size=None):
super(GenreConfiguredSpriteSheet,
self).__init__(plugin, sprite_name, size)
self.genre_alternate = {} # contains GenreType tuples
self._alt_icons = {}
self._sprite_name = sprite_name
self._size = size
popups = rb.find_plugin_file(plugin, 'img/popups.xml')
root = ET.parse(open(popups)).getroot()
self._parse_popups(plugin, root, self.GENRE_SYSTEM)
try:
self._user_popups = rb.find_plugin_file(
plugin, 'img/usericons/popups.xml')
root = ET.parse(open(self._user_popups)).getroot()
self._parse_popups(plugin, root, self.GENRE_USER)
elem = root.xpath(self._sprite_name + '/index')
curr_index = long(elem[0].text)
for index in range(0, curr_index + 1):
key = RB.ExtDBKey.create_lookup('icon', str(index))
icon_location = self._genre_db.lookup(key)
sprite = GdkPixbuf.Pixbuf.new_from_file(icon_location)
if self._size:
sprite = sprite.scale_simple(self._size[0], self._size[1],
GdkPixbuf.InterpType.BILINEAR)
self._alt_icons[str(index)] = sprite
self.names.append(str(index))
except:
pass
def __init__(self, source, window):
super(ViewManager, self).__init__()
self.source = source
self.window = window
# initialize views
self._views = {}
ui = Gtk.Builder()
ui.add_from_file(
rb.find_plugin_file(source.plugin, 'ui/coverart_iconview.ui'))
self._views[CoverIconView.name] = ui.get_object('covers_view')
self._views[CoverFlowView.name] = CoverFlowView()
self._views[ListView.name] = ListView()
ui.add_from_file(
rb.find_plugin_file(source.plugin, 'ui/coverart_artistview.ui'))
self._views[ArtistView.name] = ui.get_object('artist_view')
self._lastview = None
self.controller = ViewController(source.shell, self)
# connect signal and properties
self._connect_signals()
self._connect_properties()
self._lastview = self.view_name
if self.current_view.use_plugin_window:
window.add(self.current_view.view)
window.show_all()
def __init__(self, plugin, sprite_name, size=None):
super(GenreConfiguredSpriteSheet, self).__init__(plugin, sprite_name,
size)
self.genre_alternate = {} # contains GenreType tuples
self._alt_icons = {}
self._sprite_name = sprite_name
self._size = size
popups = rb.find_plugin_file(plugin, 'img/popups.xml')
root = ET.parse(open(popups)).getroot()
self._parse_popups(plugin, root, self.GENRE_SYSTEM)
try:
self._user_popups = rb.find_plugin_file(plugin, 'img/usericons/popups.xml')
root = ET.parse(open(self._user_popups)).getroot()
self._parse_popups(plugin, root, self.GENRE_USER)
elem = root.xpath(self._sprite_name + '/index')
curr_index = long(elem[0].text)
for index in range(0,curr_index+1):
key = RB.ExtDBKey.create_lookup('icon', str(index))
icon_location = self._genre_db.lookup(key)
sprite = GdkPixbuf.Pixbuf.new_from_file(icon_location)
if self._size:
sprite = sprite.scale_simple(self._size[0], self._size[1],
GdkPixbuf.InterpType.BILINEAR)
self._alt_icons[str(index)] = sprite
self.names.append(str(index))
except:
pass
def load_tmpl(self):
self.path = rb.find_plugin_file(self.plugin, 'tmpl/artist-tmpl.html')
self.loading_path = rb.find_plugin_file(self.plugin,
'tmpl/loading.html')
self.template = Template(filename=self.path)
self.loading_template = Template(filename=self.loading_path)
self.styles = self.basepath + '/tmpl/main.css'
def do_create_configure_widget(self):
builder = Gtk.Builder()
print rb.find_plugin_file(self, "tab-prefs.ui")
builder.add_from_file(rb.find_plugin_file(self, "tab-prefs.ui"))
self.dialog = builder.get_object("preferences_dialog")
self.path_display = builder.get_object("path_display")
self.dialog.connect("response", self.dialog_response)
preferences = self.get_prefs()
site_box = builder.get_object("sites")
self.site_checks = {}
for s in tab_sites:
site_id = s['id']
checkbutton = Gtk.CheckButton(label = s['name'])
checkbutton.set_active(s['id'] in preferences['sites'])
self.site_checks[site_id] = checkbutton
site_box.pack_start(checkbutton, expand=False, fill=True, padding=0)
self.filechooser = builder.get_object('filechooser')
self.filechooser.set_current_folder(preferences['folder'])
self.preventAutoWebLookup_checkbutton = builder.get_object('preventAutoWebLookup_checkbutton')
self.preventAutoWebLookup_checkbutton.set_active(preferences['preventAutoWebLookup'])
self.default_folder_button = builder.get_object('default_folder_button')
self.default_folder_button.connect('clicked', self.set_folderchooser_to_default)
site_box.show_all()
def do_activate(self):
'''
Called by Rhythmbox when the plugin is activated. It creates the
plugin's source and connects signals to manage the plugin's
preferences.
'''
print("CoverArtBrowser DEBUG - do_activate")
self.shell = self.object
self.db = self.shell.props.db
try:
entry_type = CoverArtBrowserEntryType()
self.db.register_entry_type(entry_type)
except NotImplementedError:
entry_type = self.db.entry_register_type(
'CoverArtBrowserEntryType')
cl = CoverLocale()
cl.switch_locale(cl.Locale.LOCALE_DOMAIN)
entry_type.category = RB.RhythmDBEntryCategory.NORMAL
group = RB.DisplayPageGroup.get_by_id('library')
# load plugin icon
theme = Gtk.IconTheme.get_default()
rb.append_plugin_source_path(theme, '/icons')
# lets assume that python3 versions of RB only has the new icon attribute in the source
if rb3compat.PYVER >=3:
iconfile = Gio.File.new_for_path(
rb.find_plugin_file(self, 'img/' + Theme(self).current\
+ '/covermgr.png'))
self.source = CoverArtBrowserSource(
shell=self.shell,
name=_("CoverArt"),
entry_type=entry_type,
plugin=self,
icon=Gio.FileIcon.new(iconfile),
query_model=self.shell.props.library_source.props.base_query_model)
else:
what, width, height = Gtk.icon_size_lookup(Gtk.IconSize.LARGE_TOOLBAR)
pxbf = GdkPixbuf.Pixbuf.new_from_file_at_size(
rb.find_plugin_file(self, 'img/' + Theme(self).current\
+ '/covermgr.png'), width, height)
self.source = CoverArtBrowserSource(
shell=self.shell,
name=_("CoverArt"), entry_type=entry_type,
plugin=self, pixbuf=pxbf,
query_model=self.shell.props.library_source.props.base_query_model)
self.shell.register_entry_type_for_source(self.source, entry_type)
self.shell.append_display_page(self.source, group)
self.source.props.query_model.connect('complete', self.load_complete)
print("CoverArtBrowser DEBUG - end do_activate")
def load_tmpl (self):
self.path = rb.find_plugin_file (self.plugin, 'tmpl/album-tmpl.html')
self.loading_path = rb.find_plugin_file (self.plugin, 'tmpl/loading.html')
self.album_template = Template (filename = self.path,
module_directory = self.plugin.tempdir)
self.loading_template = Template (filename = self.loading_path,
module_directory = self.plugin.tempdir)
self.styles = self.basepath + '/tmpl/main.css'
def load_tmpl (self):
self.path = rb.find_plugin_file(self.plugin, 'tmpl/lyrics-tmpl.html')
self.loading_path = rb.find_plugin_file (self.plugin, 'tmpl/loading.html')
self.template = Template (filename = self.path,
module_directory = '/tmp/context/')
self.loading_template = Template (filename = self.loading_path,
module_directory = '/tmp/context')
self.styles = self.basepath + '/tmpl/main.css'
def load_tmpl (self):
path = rb.find_plugin_file (self.plugin, 'tmpl/album-tmpl.html')
empty_path = rb.find_plugin_file (self.plugin, 'tmpl/album_empty-tmpl.html')
self.loading_path = rb.find_plugin_file (self.plugin, 'tmpl/loading.html')
self.album_template = Template (filename = path)
self.loading_template = Template (filename = self.loading_path)
self.empty_template = Template (filename = empty_path)
self.styles = self.basepath + '/tmpl/artistmain.css'
def get_loops_file(self):
loops_file = rb.find_plugin_file(self, self.LOOPS_FILENAME)
if loops_file is None:
loops_file = os.path.join(rb.find_plugin_file(self, ''), self.LOOPS_FILENAME)
with open(loops_file, 'w') as f:
data = {}
f.write(json.dumps(data))
return rb.find_plugin_file(self, self.LOOPS_FILENAME)
def load_tmpl(self):
self.path = rb.find_plugin_file(self.plugin, 'tmpl/lyrics-tmpl.html')
self.loading_path = rb.find_plugin_file(self.plugin,
'tmpl/loading.html')
self.template = Template(filename=self.path,
module_directory=self.plugin.tempdir)
self.loading_template = Template(filename=self.loading_path,
module_directory=self.plugin.tempdir)
self.styles = self.basepath + '/tmpl/main.css'
def load_tmpl(self):
self.path = rb.find_plugin_file(self.plugin, 'tmpl/album-tmpl.html')
self.loading_path = rb.find_plugin_file(self.plugin,
'tmpl/loading.html')
self.album_template = Template(filename=self.path,
module_directory='/tmp/context')
self.loading_template = Template(filename=self.loading_path,
module_directory='/tmp/context')
self.styles = self.basepath + '/tmpl/main.css'
def load_tmpl (self):
path = rb.find_plugin_file(self.plugin, 'tmpl/echoartist-tmpl.html')
empty_path = rb.find_plugin_file(self.plugin, 'tmpl/artist_empty-tmpl.html')
loading_path = rb.find_plugin_file (self.plugin, 'tmpl/loading.html')
self.template = Template (filename = path)
self.loading_template = Template (filename = loading_path)
self.empty_template = Template (filename = empty_path)
self.styles = self.basepath + '/tmpl/artistmain.css'
print (lastfm_datasource_link (self.basepath))
def load_tmpl(self):
path = rb.find_plugin_file(self.plugin, 'tmpl/echoartist-tmpl.html')
empty_path = rb.find_plugin_file(self.plugin,
'tmpl/artist_empty-tmpl.html')
loading_path = rb.find_plugin_file(self.plugin, 'tmpl/loading.html')
self.template = Template(filename=path)
self.loading_template = Template(filename=loading_path)
self.empty_template = Template(filename=empty_path)
self.styles = self.basepath + '/tmpl/artistmain.css'
print(lastfm_datasource_link(self.basepath))
def load_tmpl(self):
path = rb.find_plugin_file(self.plugin, 'tmpl/album-tmpl.html')
empty_path = rb.find_plugin_file(self.plugin,
'tmpl/album_empty-tmpl.html')
self.loading_path = rb.find_plugin_file(self.plugin,
'tmpl/loading.html')
self.album_template = Template(filename=path)
self.loading_template = Template(filename=self.loading_path)
self.empty_template = Template(filename=empty_path)
self.styles = self.basepath + '/tmpl/artistmain.css'
def do_activate (self):
ui = Gtk.Builder()
ui.add_from_file(rb.find_plugin_file(self,
'desktop-art.ui'))
window = ui.get_object('window')
window.set_app_paintable(True)
screen = window.get_screen()
visual = screen.get_rgba_visual()
self.composited = window.is_composited()
if visual !=None and self.composited:
window.set_visual(visual)
self.shell = self.object
player = self.shell.props.shell_player
window.stick()
window.set_keep_below(True)
desktop_control = DesktopControl(icons, self.shell, player,
rb.find_plugin_file(self,'configure-art.ui'), self)
cover_manager = CoverManager(player.props.db)
#player.props.db.connect_after("entry-extra-metadata-notify::rb:coverArt-uri", self.notify_metadata)
gc = GConf.Client.get_default()
gc.add_dir(GConf_plugin_path, GConf.ClientPreloadType.PRELOAD_NONE)
window_props = self.get_GConf_window_props(gc)
self.gc_notify_ids = [gc.notify_add(self.GConf_path('window_x'), self.GConf_cb, window_props),
gc.notify_add(self.GConf_path('window_y'), self.GConf_cb, window_props),
gc.notify_add(self.GConf_path('window_w'), self.GConf_cb, window_props),
gc.notify_add(self.GConf_path('window_h'), self.GConf_cb, window_props)]
window.add(desktop_control)
self.player = player
self.cb = player.connect('playing-changed', self.playing_changed, desktop_control, cover_manager)
self.playing_changed(player, player.get_playing(), desktop_control, cover_manager)
self.gc = gc
self.window = window
self.window_props = window_props
self.desktop_control = desktop_control
self.cover_manager = cover_manager
print("Adding timeout")
ret = GObject.timeout_add(POLL_TIMEOUT, self.poll_for_coverart)
print("integer id returned: " + str(ret))
self.position_window(self.window_props)
self.window.show_all()
else:
# We don't have compositing manager
md = Gtk.MessageDialog(type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK,
message_format='You are not running under a composited desktop-environment. The Desktop Art Plugin cannot work without one.')
md.run()
md.destroy()
def load_tmpl(self):
cl = CoverLocale()
# cl.switch_locale(cl.Locale.LOCALE_DOMAIN)
path = rb.find_plugin_file(self.plugin, "tmpl/album-tmpl.html")
empty_path = rb.find_plugin_file(self.plugin, "tmpl/album_empty-tmpl.html")
self.loading_path = rb.find_plugin_file(self.plugin, "tmpl/loading.html")
self.album_template = Template(filename=path)
self.loading_template = Template(filename=self.loading_path)
self.empty_template = Template(filename=empty_path)
self.styles = self.basepath + "/tmpl/artistmain.css"
def load_tmpl(self):
cl = CoverLocale()
cl.switch_locale(cl.Locale.LOCALE_DOMAIN)
path = rb.find_plugin_file(self.plugin, 'tmpl/artist-tmpl.html')
empty_path = rb.find_plugin_file(self.plugin,
'tmpl/artist_empty-tmpl.html')
loading_path = rb.find_plugin_file(self.plugin, 'tmpl/loading.html')
self.template = Template(filename=path)
self.loading_template = Template(filename=loading_path)
self.empty_template = Template(filename=empty_path)
self.styles = self.basepath + '/tmpl/artistmain.css'
def __init__(self, db, player, plugin):
RB.EntryView.__init__(self, db=db, shell_player=player)
self.db = db
self.plugin = plugin
self.pixs = [GdkPixbuf.Pixbuf.new_from_file(rb.find_plugin_file(self.plugin, 'pandora/widgets/star-off.png')),
GdkPixbuf.Pixbuf.new_from_file(rb.find_plugin_file(self.plugin, 'pandora/widgets/star-on.png'))]
player.connect_after('playing-changed', self.playing_changed)
self.load_columns()
def load_tmpl(self):
cl = CoverLocale()
# cl.switch_locale(cl.Locale.LOCALE_DOMAIN)
path = rb.find_plugin_file(self.plugin, "tmpl/echoartist-tmpl.html")
empty_path = rb.find_plugin_file(self.plugin, "tmpl/artist_empty-tmpl.html")
loading_path = rb.find_plugin_file(self.plugin, "tmpl/loading.html")
self.template = Template(filename=path)
self.loading_template = Template(filename=loading_path)
self.empty_template = Template(filename=empty_path)
self.styles = self.basepath + "/tmpl/artistmain.css"
print(lastfm_datasource_link(self.basepath))
def __init__(self, plugin, sprite_name, size=None):
popups = rb.find_plugin_file(plugin, 'img/popups.xml')
root = ET.parse(open(popups)).getroot()
base = 'theme/theme[@folder_name="' + Theme(plugin).current \
+ '"]/spritesheet[@name="' + sprite_name + '"]/'
image = rb.find_plugin_file(plugin, 'img/' + Theme(plugin).current \
+ '/' + root.xpath(base + 'image')[0].text)
icon_width = int(root.xpath(base + 'icon')[0].attrib['width'])
icon_height = int(root.xpath(base + 'icon')[0].attrib['height'])
x_spacing = int(root.xpath(base + 'spacing')[0].attrib['x'])
y_spacing = int(root.xpath(base + 'spacing')[0].attrib['y'])
x_start = int(root.xpath(base + 'start-position')[0].attrib['x'])
y_start = int(root.xpath(base + 'start-position')[0].attrib['y'])
across_dimension = int(
root.xpath(base + 'dimension')[0].attrib['across'])
down_dimension = int(root.xpath(base + 'dimension')[0].attrib['down'])
try:
alpha_color = list(
map(int,
root.xpath(base + 'alpha')[0].text.split(' ')))
except:
alpha_color = None
self.names = []
self.locale_names = {}
cl = CoverLocale()
lang = cl.get_locale()
base = sprite_name + '/' + sprite_name + \
'[@spritesheet="' + sprite_name + '"]'
for elem in root.xpath(base + '[not(@xml:lang)]'):
self.names.append(elem.text)
for elem in root.xpath(base + '[@xml:lang="' + lang + '"]'):
self.locale_names[elem.text] = elem.attrib['name']
if (not self.locale_names) and len(lang) > 2:
for elem in root.xpath(base + '[@xml:lang="' + \
lang[0:2] + '"]'):
self.locale_names[elem.text] = elem.attrib['name']
self._sheet = SpriteSheet(image, icon_width, icon_height, x_spacing,
y_spacing, x_start, y_start,
across_dimension, down_dimension,
alpha_color, size)
self._genre_db = RB.ExtDB(name='cb_genre')
def initialise(self, plugin, callback, sort_order):
'''
set up the images we will use for this widget
'''
self.image_display = sort_order
self.set_tooltip(self.image_display)
if not self.is_initialised:
image1 = Gtk.Image.new_from_file(rb.find_plugin_file(plugin,
'img/arrow_up.png'))
image2 = Gtk.Image.new_from_file(rb.find_plugin_file(plugin,
'img/arrow_down.png'))
super(SortOrderButton, self).initialise(callback,
image1, image2)
def do_activate(self):
print "CoverArtBrowser DEBUG - do_activate"
self.shell = self.object
self.db = self.shell.props.db
try:
entry_type = CoverArtBrowserEntryType()
self.db.register_entry_type(entry_type)
except NotImplementedError:
entry_type = db.entry_register_type("CoverArtBrowserEntryType")
entry_type.category = RB.RhythmDBEntryCategory.NORMAL
# load plugin icon
theme = Gtk.IconTheme.get_default()
rb.append_plugin_source_path(theme, "/icons")
what, width, height = Gtk.icon_size_lookup(Gtk.IconSize.LARGE_TOOLBAR)
pxbf = GdkPixbuf.Pixbuf.new_from_file_at_size(rb.find_plugin_file(self, "covermgr.png"), width, height)
group = RB.DisplayPageGroup.get_by_id ("library")
self.source = GObject.new ( CoverArtBrowserSource,
shell=self.shell,
name=_("CoverArt"),
entry_type=entry_type,
plugin=self,
pixbuf=pxbf)
self.shell.register_entry_type_for_source(self.source, entry_type)
self.shell.append_display_page(self.source, group)
print "CoverArtBrowser DEBUG - end do_activate"
def do_activate(self):
self.shell = self.object
self.sp = self.shell.props.shell_player
self.db = self.shell.get_property('db')
self.file = ""
self.basepath = 'file://' + os.path.split(rb.find_plugin_file(self, "AlbumArtSearch.py"))[0]
self.load_templates()
self.current_artist = None
self.current_album = None
self.current_song = None
self.current_location = None
self.visible = True
self.mode = self.MODE_FOLDER
self.init_gui()
self.connect_signals()
self.action = ('ToggleAlbumArtSearch', Gtk.STOCK_DND_MULTIPLE, _('Toggle album art search pane'),
None, _('Change the visibility of album art search pane'),
self.toggle_visibility, True)
self.action_group = Gtk.ActionGroup('AlbumArtSearchActions')
self.action_group.add_toggle_actions([self.action])
uim = self.shell.props.ui_manager
uim.insert_action_group (self.action_group, -1)
self.ui_id = uim.add_ui_from_string(albumart_search_ui)
uim.ensure_update()
def do_create_configure_widget( self ):
#creamos un builder y agregamos el archivo de gui
builder = Gtk.Builder()
builder.add_from_file( rb.find_plugin_file( self, DIALOG_FILE ) )
if self.settings[Keys.CONNECTED]:
label_text = 'Logged'
button_label = 'Logout'
button_callback = self._logout
else:
label_text = 'Not Logged'
button_label = 'Login'
button_callback = self._login
#obtenemos los componentes del dialog a modificar
label = builder.get_object( LOGIN_LABEL )
button = builder.get_object( LOGIN_BUTTON )
playcount_checkbox = builder.get_object( PLAYCOUNT_CHECKBOX )
loved_checkbox = builder.get_object( LOVED_CHECKBOX )
#preparamos la gui
label.set_text( label_text )
button.set_label( button_label )
self._b_id = button.connect( 'clicked', button_callback, label )
playcount_checkbox.set_active( self.settings[Keys.PLAY_COUNT] )
playcount_checkbox.connect( 'toggled', self._toggle, Keys.PLAY_COUNT )
loved_checkbox.set_active( self.settings[Keys.LOVED] )
loved_checkbox.connect( 'toggled', self._toggle, Keys.LOVED )
return builder.get_object( DIALOG )
def do_create_configure_widget(self):
self.settings = Gio.Settings("org.gnome.rhythmbox.plugins.replaygain")
ui_file = rb.find_plugin_file(self, "replaygain-prefs.ui")
self.builder = Gtk.Builder()
self.builder.add_from_file(ui_file)
content = self.builder.get_object("replaygain-prefs")
combo = self.builder.get_object("replaygainmode")
combo.props.id_column = 1
self.settings.bind("mode", combo, "active-id", Gio.SettingsBindFlags.DEFAULT)
preamp = self.builder.get_object("preamp")
self.settings.bind("preamp", preamp.props.adjustment, "value", Gio.SettingsBindFlags.GET)
preamp.connect("value-changed", self.preamp_changed_cb)
preamp.add_mark(-15.0, Gtk.PositionType.BOTTOM, _("-15.0 dB"))
preamp.add_mark(0.0, Gtk.PositionType.BOTTOM, _("0.0 dB"))
preamp.add_mark(15.0, Gtk.PositionType.BOTTOM, _("15.0 dB"))
limiter = self.builder.get_object("limiter")
self.settings.bind("limiter", limiter, "active", Gio.SettingsBindFlags.DEFAULT)
return content
def do_create_configure_widget(self):
self.ui_file = rb.find_plugin_file(self, 'config.ui')
b = Gtk.Builder()
b.add_from_file(self.ui_file)
self._check_configfile()
self.conf.read(self.configfile)
window = b.get_object("fileorganizer")
b.get_object("closebutton").connect('clicked', lambda x:
window.destroy())
b.get_object("savebutton").connect('clicked', lambda x:
self.save_config(b))
b.get_object("log_path").set_text(self.conf.get(c, "log_path"))
b.get_object("cover_names").set_text(self.conf.get(c, "cover_names"))
if self.conf.get(c, "log_enabled") == "True":
b.get_object("logbutton").set_active(True)
if self.conf.get(c, "cover_enabled") == "True":
b.get_object("coverbutton").set_active(True)
if self.conf.get(c, "cleanup_enabled") == "True":
b.get_object("cleanupbutton").set_active(True)
if self.conf.get(c, "cleanup_empty_folders") == "True":
b.get_object("removebutton").set_active(True)
if self.conf.get(c, "update_tags") == "True":
b.get_object("tagsbutton").set_active(True)
if self.conf.get(c, "preview_mode") == "True":
b.get_object("previewbutton").set_active(True)
window.show_all()
return window
def do_create_configure_widget(self):
self.settings = PandoraSettings(self)
self.builder = Gtk.Builder()
self.builder.add_from_file(
rb.find_plugin_file(self, "data/pandora-prefs.ui"))
self.builder.connect_signals(self)
(username, password) = PandoraAccount.get().get_credentials()
username_entry = self.builder.get_object("username-entry")
username_entry.set_text(username)
password_entry = self.builder.get_object("password-entry")
password_entry.set_text(password)
quality_combobox = self.builder.get_object("audio-quality-combobox")
def quality_to_combobox(quality):
for row in quality_combobox.get_model():
if row[1] == quality:
return row.path[0]
def combobox_to_quality(idx):
return quality_combobox.get_model()[idx][1]
self.settings.bind_with_convert("audio-quality", quality_combobox,
"active", quality_to_combobox,
combobox_to_quality)
return self.builder.get_object("pandora-prefs")
def do_activate(self):
self.shell = self.object
self.sp = self.shell.props.shell_player
self.db = self.shell.get_property('db')
self.file = ""
self.basepath = 'file://' + os.path.split(
rb.find_plugin_file(self, "AlbumArtSearch.py"))[0]
self.load_templates()
self.current_artist = None
self.current_album = None
self.current_song = None
self.current_location = None
self.visible = False
self.mode = self.MODE_FOLDER
self.init_gui()
self.connect_signals()
self.action = ('ToggleAlbumArtSearch', Gtk.STOCK_DND_MULTIPLE,
_('Album Art'), None,
_('Change the visibility of album art search pane'),
self.toggle_visibility, False)
self.action_group = Gtk.ActionGroup('AlbumArtSearchActions')
self.action_group.add_toggle_actions([self.action])
uim = self.shell.props.ui_manager
uim.insert_action_group(self.action_group, -1)
self.ui_id = uim.add_ui_from_string(albumart_search_ui)
uim.ensure_update()
def initialise(self, source):
if self._has_initialised:
return
self._has_initialised = True
self.view_name = "covers_view"
super(CoverIconView,self).initialise(source)
self.shell = source.shell
self.album_manager = source.album_manager
# setup iconview drag&drop support
# first drag and drop on the coverart view to receive coverart
self.enable_model_drag_dest([], Gdk.DragAction.COPY)
self.drag_dest_add_image_targets()
self.drag_dest_add_text_targets()
self.connect('drag-drop', self.on_drag_drop)
self.connect('drag-data-received',
self.on_drag_data_received)
self.source.paned.connect("expanded", self.bottom_expander_expanded_callback)
# lastly support drag-drop from coverart to devices/nautilus etc
self.connect('drag-begin', self.on_drag_begin)
self.enable_model_drag_source(Gdk.ModifierType.BUTTON1_MASK,
[], Gdk.DragAction.COPY)
#targets = Gtk.TargetList.new([Gtk.TargetEntry.new("application/x-rhythmbox-entry", 0, 0),
# Gtk.TargetEntry.new("text/uri-list", 0, 1) ])
targets = Gtk.TargetList.new([Gtk.TargetEntry.new("text/uri-list", 0, 0) ])
# N.B. values taken from rhythmbox v2.97 widgets/rb_entry_view.c
targets.add_uri_targets(1)
self.drag_source_set_target_list(targets)
self.connect("drag-data-get", self.on_drag_data_get)
# set the model to the view
#self.set_pixbuf_column(AlbumsModel.columns['pixbuf'])
self.set_model(self.album_manager.model.store)
# setup view to monitor mouse movements
self.add_events(Gdk.EventMask.POINTER_MOTION_MASK)
self.hover_pixbufs = {
'button_play':None,
'button_play_hover':None,
'button_playpause':None,
'button_playpause_hover':None }
for pixbuf_type in self.hover_pixbufs:
filename = 'img/' + pixbuf_type + '.png'
filename = rb.find_plugin_file(self.plugin, filename)
self.hover_pixbufs[pixbuf_type] = GdkPixbuf.Pixbuf.new_from_file_at_size(filename,
PLAY_SIZE_X, PLAY_SIZE_Y)
self._connect_properties()
self._connect_signals()
self._activate_markup()
self.on_notify_icon_padding()
self.on_notify_icon_spacing()
def do_create_configure_widget(self):
builder = Gtk.Builder()
builder.add_from_file(rb.find_plugin_file(self, "lyrics-prefs.ui"))
self.config = builder.get_object("config")
self.choose_button = builder.get_object("choose_button")
self.path_display = builder.get_object("path_display")
self.choose_button.connect("clicked", self.choose_callback)
engines, self.folder = self.get_prefs()
if self.folder is None:
self.folder = '~/.lyrics'
self.path_display.set_text(self.folder)
# build site list
site_box = builder.get_object("sites")
self.site_checks = {}
for s in lyrics_sites:
site_id = s['id']
checkbutton = Gtk.CheckButton(label=s['name'])
checkbutton.set_active(s['id'] in engines)
checkbutton.connect("toggled", self.set_sites)
self.site_checks[site_id] = checkbutton
site_box.pack_start(checkbutton, True, True, 0)
site_box.show_all()
return self.config
def load_from_file(self, rb2_ui_filename, rb3_ui_filename):
'''
utility function to load the menu structure
:param rb2_ui_filename: `str` RB2.98 and below UI file
:param rb3_ui_filename: `str` RB2.99 and higher UI file
'''
self.builder = Gtk.Builder()
try:
from coverart_browser_prefs import CoverLocale
cl = CoverLocale()
self.builder.set_translation_domain(cl.Locale.LOCALE_DOMAIN)
except:
pass
if is_rb3(self.shell):
ui_filename = rb3_ui_filename
else:
ui_filename = rb2_ui_filename
self.ui_filename = ui_filename
self.builder.add_from_file(
rb.find_plugin_file(self.plugin, ui_filename))
def create_button_image(plugin, icon_name):
'create a pixbuf for the given icon_name sized according to the stock icon size'
path = 'img/'
return create_pixbuf_from_file_at_size(
rb.find_plugin_file(plugin, path + icon_name),
*get_stock_size())
def load_from_file(self, rb2_ui_filename, rb3_ui_filename):
"""
utility function to load the menu structure
:param rb2_ui_filename: `str` RB2.98 and below UI file
:param rb3_ui_filename: `str` RB2.99 and higher UI file
"""
self.builder = Gtk.Builder()
try:
from coverart_browser_prefs import CoverLocale
cl = CoverLocale()
self.builder.set_translation_domain(cl.Locale.LOCALE_DOMAIN)
except:
pass
if is_rb3(self.shell):
ui_filename = rb3_ui_filename
else:
ui_filename = rb2_ui_filename
self.ui_filename = ui_filename
self.builder.add_from_file(rb.find_plugin_file(self.plugin,
ui_filename))
def do_activate(self):
shell = self.object
sp = shell.props.shell_player
self.player_cb_ids = (sp.connect('playing-song-changed',
self.playing_entry_changed),
sp.connect('playing-changed',
self.playing_changed))
self.emitting_uri_notify = False
db = shell.props.db
self.db_cb_ids = (
db.connect_after('entry-extra-metadata-request::rb:coverArt',
self.cover_art_request),
db.connect_after('entry-extra-metadata-notify::rb:coverArt',
self.cover_art_notify),
db.connect_after('entry-extra-metadata-request::rb:coverArt-uri',
self.cover_art_uri_request),
db.connect_after('entry-extra-metadata-notify::rb:coverArt-uri',
self.cover_art_uri_notify),
db.connect_after('entry-extra-metadata-gather',
self.cover_art_uri_gather),
)
self.art_widget = ArtDisplayWidget(
rb.find_plugin_file(self, ART_MISSING_ICON + ".svg"))
self.art_widget.connect('pixbuf-dropped', self.on_set_pixbuf)
self.art_widget.connect('uri-dropped', self.on_set_uri)
self.art_widget.connect('get-max-size', self.get_max_art_size)
self.art_widget.connect('button-press-event', self.on_button_press)
self.art_container = Gtk.VBox()
self.art_container.pack_start(self.art_widget, True, True, 6)
shell.add_widget(self.art_container, RB.ShellUILocation.SIDEBAR, False,
True)
self.art_db = CoverArtDatabase()
self.current_entry, self.current_pixbuf = None, None
self.playing_entry_changed(sp, sp.get_playing_entry())
def on_get_pixbuf_completed(self, entry, pixbuf, uri, tooltip_image, tooltip_text):
# Set the pixbuf for the entry returned from the art db
if rb.entry_equal(entry, self.current_entry):
self.current_pixbuf = pixbuf
if tooltip_image is None:
pb = None
elif tooltip_image.startswith("/"):
pb = GdkPixbuf.Pixbuf.new_from_file(tooltip_image)
else:
f = rb.find_plugin_file (self, tooltip_image)
pb = GdkPixbuf.Pixbuf.new_from_file(f)
self.art_widget.set (entry, pixbuf, uri, pb, tooltip_text, False)
if pixbuf:
# This might be from a playing-changed signal,
# in which case consumers won't be ready yet.
def idle_emit_art():
shell = self.object
db = shell.props.db
db.emit_entry_extra_metadata_notify (entry, "rb:coverArt", pixbuf)
if uri:
self.emitting_uri_notify = True
db.emit_entry_extra_metadata_notify (entry, "rb:coverArt-uri", uri)
self.emitting_uri_notify = False
return False
gobject.idle_add(idle_emit_art)
def do_activate (self):
shell = self.object
sp = shell.props.shell_player
self.player_cb_ids = (
sp.connect ('playing-song-changed', self.playing_entry_changed),
sp.connect ('playing-changed', self.playing_changed)
)
self.emitting_uri_notify = False
db = shell.props.db
self.db_cb_ids = (
db.connect_after ('entry-extra-metadata-request::rb:coverArt', self.cover_art_request),
db.connect_after ('entry-extra-metadata-notify::rb:coverArt', self.cover_art_notify),
db.connect_after ('entry-extra-metadata-request::rb:coverArt-uri', self.cover_art_uri_request),
db.connect_after ('entry-extra-metadata-notify::rb:coverArt-uri', self.cover_art_uri_notify),
db.connect_after ('entry-extra-metadata-gather', self.cover_art_uri_gather),
)
self.art_widget = ArtDisplayWidget (rb.find_plugin_file (self, ART_MISSING_ICON + ".svg"))
self.art_widget.connect ('pixbuf-dropped', self.on_set_pixbuf)
self.art_widget.connect ('uri-dropped', self.on_set_uri)
self.art_widget.connect ('get-max-size', self.get_max_art_size)
self.art_widget.connect ('button-press-event', self.on_button_press)
self.art_container = Gtk.VBox ()
self.art_container.pack_start (self.art_widget, True, True, 6)
shell.add_widget (self.art_container, RB.ShellUILocation.SIDEBAR, False, True)
self.art_db = CoverArtDatabase ()
self.current_entry, self.current_pixbuf = None, None
self.playing_entry_changed (sp, sp.get_playing_entry ())
def do_create_configure_widget(self):
"""
Creates the plugin's preferences dialog
"""
print("DEBUG - create_display_contents")
# create the ui
builder = Gtk.Builder()
builder.add_from_file(
rb.find_plugin_file(self, 'ui/remember_preferences.ui'))
builder.connect_signals(self)
# bind the toggles to the settings
self._playpause_rb = builder.get_object('play_pause_radiobutton')
self._play_rb = builder.get_object('play_radiobutton')
self._pause_rb = builder.get_object('pause_radiobutton')
startup_state = self.settings[KEY_STARTUP_STATE]
if startup_state == 1:
self._playpause_rb.set_active(True)
elif startup_state == 2:
self._pause_rb.set_active(True)
else:
self._play_rb.set_active(True)
self._first_run = False
return builder.get_object('remember_box')
def do_create_configure_widget(self):
builder = Gtk.Builder()
builder.add_from_file(rb.find_plugin_file(self, "lyrics-prefs.ui"))
self.config = builder.get_object("config")
self.choose_button = builder.get_object("choose_button")
self.path_display = builder.get_object("path_display")
self.choose_button.connect("clicked", self.choose_callback)
engines, self.folder = self.get_prefs()
if self.folder is None:
self.folder = '~/.lyrics'
self.path_display.set_text(self.folder)
# build site list
site_box = builder.get_object("sites")
self.site_checks = {}
for s in lyrics_sites:
site_id = s['id']
checkbutton = Gtk.CheckButton(label = s['name'])
checkbutton.set_active(s['id'] in engines)
checkbutton.connect("toggled", self.set_sites)
self.site_checks[site_id] = checkbutton
site_box.pack_start(checkbutton, True, True, 0)
site_box.show_all()
return self.config
def _create_display_contents(self, plugin):
print("DEBUG - create_display_contents")
# create the ui
self._first_run = True
builder = Gtk.Builder()
builder.add_from_file(
rb.find_plugin_file(plugin, 'ui/spectrum_prefs.ui'))
builder.connect_signals(self)
gs = GSetting()
# bind the toggles to the settings
self.position = self.settings[gs.PluginKey.POSITION]
self.sidebar_position_radiobutton = builder.get_object(
'sidebar_position_radiobutton')
self.bottom_position_radiobutton = builder.get_object(
'bottom_position_radiobutton')
if self.position == 1:
self.sidebar_position_radiobutton.set_active(True)
else:
self.bottom_position_radiobutton.set_active(True)
self.builder = builder
# return the dialog
self._first_run = False
print("end create dialog contents")
return builder.get_object('main_grid')
def do_create_configure_widget(self):
self.settings = Gio.Settings("org.gnome.rhythmbox.plugins.replaygain")
ui_file = rb.find_plugin_file(self, "replaygain-prefs.ui")
self.builder = Gtk.Builder()
self.builder.add_from_file(ui_file)
content = self.builder.get_object("replaygain-prefs")
combo = self.builder.get_object("replaygainmode")
combo.props.id_column = 1
self.settings.bind("mode", combo, "active-id",
Gio.SettingsBindFlags.DEFAULT)
preamp = self.builder.get_object("preamp")
self.settings.bind("preamp", preamp.props.adjustment, "value",
Gio.SettingsBindFlags.GET)
preamp.connect("value-changed", self.preamp_changed_cb)
preamp.add_mark(-15.0, Gtk.PositionType.BOTTOM, _("-15.0 dB"))
preamp.add_mark(0.0, Gtk.PositionType.BOTTOM, _("0.0 dB"))
preamp.add_mark(15.0, Gtk.PositionType.BOTTOM, _("15.0 dB"))
limiter = self.builder.get_object("limiter")
self.settings.bind("limiter", limiter, "active",
Gio.SettingsBindFlags.DEFAULT)
return content
def __init__(self, plugin):
path = rb.find_plugin_file(plugin, "data/")
schema_source = Gio.SettingsSchemaSource.new_from_directory(
path, Gio.SettingsSchemaSource.get_default(), False)
schema = schema_source.lookup("org.gnome.rhythmbox.plugins.pandora",
True)
super(PandoraSettings, self).__init__(settings_schema=schema)
def _create_display_contents(self, plugin):
print("DEBUG - create_display_contents")
# create the ui
self._first_run = True
builder = Gtk.Builder()
builder.add_from_file(rb.find_plugin_file(plugin,
'ui/spectrum_prefs.ui'))
builder.connect_signals(self)
gs = GSetting()
# bind the toggles to the settings
self.position = self.settings[gs.PluginKey.POSITION]
self.sidebar_position_radiobutton = builder.get_object('sidebar_position_radiobutton')
self.bottom_position_radiobutton = builder.get_object('bottom_position_radiobutton')
if self.position == 1:
self.sidebar_position_radiobutton.set_active(True)
else:
self.bottom_position_radiobutton.set_active(True)
self.builder = builder
# return the dialog
self._first_run = False
print("end create dialog contents")
return builder.get_object('main_grid')
def do_activate(self):
"""Activate the pandora plugin. Called when checked within the Rhythmbox plugin pane."""
print("Activating pandora plugin.")
shell = self.object
db = shell.props.db
entry_type = PandoraEntryType()
db.register_entry_type(entry_type)
_, width, height = Gtk.icon_size_lookup(Gtk.IconSize.LARGE_TOOLBAR)
pandora_icon = GdkPixbuf.Pixbuf.new_from_file_at_size(rb.find_plugin_file(self, "pandora.png"), width, height)
self.source = GObject.new(
PandoraSource,
shell=shell,
name="Pandora",
plugin=self,
icon=pandora_icon,
entry_type=entry_type)
library_group = RB.DisplayPageGroup.get_by_id("library")
shell.append_display_page(self.source, library_group)
shell.register_entry_type_for_source(self.source, entry_type)
# hack, should be done within gobject constructor
self.source.init();
self.pec_id = shell.props.shell_player.connect_after('playing-song-changed', self.playing_entry_changed)
self.psc_id = shell.props.shell_player.connect_after('playing-source-changed', self.playing_source_changed)
def do_create_configure_widget(self):
"""
Called when the configuration UI button is pressed
"""
print("Creating configuration dialog")
builder = Gtk.Builder()
builder.add_from_file(
rb.find_plugin_file(self, "lastfmplaycount-prefs.ui"))
dialog = builder.get_object('lastfmplaycountsync-preferences')
if self.get_username() is not None:
builder.get_object('username').set_markup('Detected username: '******'update_playcounts').set_active(
self.get_update_playcounts())
builder.get_object('update_ratings').set_active(
self.get_update_ratings())
builder.get_object('loved_rating').set_range(0, 5)
builder.get_object('loved_rating').set_value(5)
builder.get_object('rating_box').set_sensitive(False)
callbacks = {
"update_playcounts_toggled": self._update_playcounts_toggled,
"update_ratings_toggled": self._update_ratings_toggled,
}
builder.connect_signals(callbacks)
return dialog
def on_get_pixbuf_completed(self, entry, pixbuf, uri, tooltip_image,
tooltip_text):
# Set the pixbuf for the entry returned from the art db
if rb.entry_equal(entry, self.current_entry):
self.current_pixbuf = pixbuf
if tooltip_image is None:
pb = None
elif tooltip_image.startswith("/"):
pb = GdkPixbuf.Pixbuf.new_from_file(tooltip_image)
else:
f = rb.find_plugin_file(self, tooltip_image)
pb = GdkPixbuf.Pixbuf.new_from_file(f)
self.art_widget.set(entry, pixbuf, uri, pb, tooltip_text, False)
if pixbuf:
# This might be from a playing-changed signal,
# in which case consumers won't be ready yet.
def idle_emit_art():
shell = self.object
db = shell.props.db
db.emit_entry_extra_metadata_notify(entry, "rb:coverArt",
pixbuf)
if uri:
self.emitting_uri_notify = True
db.emit_entry_extra_metadata_notify(
entry, "rb:coverArt-uri", uri)
self.emitting_uri_notify = False
return False
gobject.idle_add(idle_emit_art)
def create_button_image(plugin, image_filename):
'''
create a pixbuf for the given image_filename sized according to the stock icon size
'''
path = 'img/'
return create_pixbuf_from_file_at_size(
rb.find_plugin_file(plugin, path + image_filename), *get_stock_size())
def init_unknown_cover(cls, plugin):
'''
Classmethod that should be called to initialize the the global Unknown
cover.
'''
if type(cls.UNKNOWN_COVER) is str:
cls.UNKNOWN_COVER = Cover(
rb.find_plugin_file(plugin, cls.UNKNOWN_COVER))
def load_css(self):
cssProvider = Gtk.CssProvider()
css_path = rb.find_plugin_file(self, 'looper.css')
cssProvider.load_from_path(css_path)
screen = Gdk.Screen.get_default()
styleContext = Gtk.StyleContext()
styleContext.add_provider_for_screen(screen, cssProvider,
Gtk.STYLE_PROVIDER_PRIORITY_USER)
def do_create_configure_widget(self):
'''
Creates the plugin's preferences dialog
'''
print("DEBUG - create_display_contents")
# create the ui
self._first_run = True
builder = Gtk.Builder()
builder.add_from_file(rb.find_plugin_file(self,
'ui/altpreferences.ui'))
builder.connect_signals(self)
# bind the toggles to the settings
start_hidden = builder.get_object('start_hidden_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.START_HIDDEN, start_hidden,
'active', Gio.SettingsBindFlags.DEFAULT)
show_compact = builder.get_object('show_compact_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.SHOW_COMPACT, show_compact,
'active', Gio.SettingsBindFlags.DEFAULT)
self.display_type = self.plugin_settings[
self.gs.PluginKey.DISPLAY_TYPE]
self.auto_radiobutton = builder.get_object('auto_radiobutton')
self.headerbar_radiobutton = builder.get_object(
'headerbar_radiobutton')
self.toolbar_radiobutton = builder.get_object('toolbar_radiobutton')
playing_label = builder.get_object('playing_label_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.PLAYING_LABEL,
playing_label, 'active',
Gio.SettingsBindFlags.DEFAULT)
inline_label = builder.get_object('inline_label_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.INLINE_LABEL, inline_label,
'active', Gio.SettingsBindFlags.DEFAULT)
volume_control = builder.get_object('volume_control_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.VOLUME_CONTROL,
volume_control, 'active',
Gio.SettingsBindFlags.DEFAULT)
compact_control = builder.get_object('compact_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.COMPACT_PROGRESSBAR,
compact_control, 'active',
Gio.SettingsBindFlags.DEFAULT)
if self.display_type == 0:
self.auto_radiobutton.set_active(True)
elif self.display_type == 1:
self.headerbar_radiobutton.set_active(True)
else:
self.toolbar_radiobutton.set_active(True)
self._first_run = False
return builder.get_object('preferences_box')
def do_show_entry_popup(self):
if self.__popup is None:
builder = Gtk.Builder()
builder.add_from_file(rb.find_plugin_file(self.props.plugin, "magnatune-popup.ui"))
self.__popup = builder.get_object("magnatune-popup")
menu = Gtk.Menu.new_from_model(self.__popup)
menu.attach_to_widget(self, None)
menu.popup(None, None, None, None, 3, Gtk.get_current_event_time())
def set_pause_circle(self):
self.pause_circle = Gtk.Image()
self.pause_circle_pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
rb.find_plugin_file(self.backend, "img/pause-circle.svg"),
self._albumCoverWidth/4,
self._albumCoverHeight/4
)
self.pause_circle.set_from_pixbuf(self.pause_circle_pixbuf)
self.pause_circle.show_all()
def initialise(self, plugin):
super(AltToolbarShared, self).initialise(plugin)
ui = rb.find_plugin_file(plugin, 'ui/alttoolbar.ui')
builder = Gtk.Builder()
builder.add_from_file(ui)
self.load_builder_content(builder)
self.connect_builder_content(builder)
def do_activate(self):
shell = self.object
self.db = shell.props.db
self.entry_type = MagnatuneEntryType()
self.db.register_entry_type(self.entry_type)
self.settings = Gio.Settings("org.gnome.rhythmbox.plugins.magnatune")
app = Gio.Application.get_default()
action = Gio.SimpleAction(name="magnatune-album-download")
action.connect("activate", self.download_album_action_cb)
app.add_action(action)
action = Gio.SimpleAction(name="magnatune-artist-info")
action.connect("activate", self.artist_info_action_cb)
app.add_action(action)
builder = Gtk.Builder()
builder.add_from_file(rb.find_plugin_file(self,
"magnatune-toolbar.ui"))
toolbar = builder.get_object("magnatune-toolbar")
app.link_shared_menus(toolbar)
group = RB.DisplayPageGroup.get_by_id("stores")
settings = Gio.Settings("org.gnome.rhythmbox.plugins.magnatune")
iconfile = Gio.File.new_for_path(
rb.find_plugin_file(self, "magnatune-symbolic.svg"))
self.source = GObject.new(MagnatuneSource,
shell=shell,
entry_type=self.entry_type,
icon=Gio.FileIcon.new(iconfile),
plugin=self,
settings=settings.get_child("source"),
name=_("Magnatune"),
toolbar_menu=toolbar)
shell.register_entry_type_for_source(self.source, self.entry_type)
shell.append_display_page(self.source, group)
self.pec_id = shell.props.shell_player.connect(
'playing-song-changed', self.playing_entry_changed)
