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 __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)