def __init__(self):
        builder = Gtk.Builder()
        builder.add_from_file(xdg.get_data_path('ui', 'splash.ui'))

        image = builder.get_object('splash_image')
        image.set_from_file(xdg.get_data_path('images', 'splash.png'))

        self.window = builder.get_object('SplashScreen')

 def get_rating_html(self, rating):
     html=''
     star = xdg.get_data_path("images", "star.png")
     bstar = xdg.get_data_path("images", "emptystar.png")
     maximum = settings.get_option("rating/maximum", 5)
     for i in range(rating):
         html+='<a href="rate://%d"><img src="file://%s"/></a>' % (i+1, star)
     for i in range(maximum-rating):
         html+='<a href="rate://%d"><img src="file://%s"/></a>' % (rating+i+1, bstar)
     return html

    def __init__(self, parent=None):
        builder = gtk.Builder()
        builder.add_from_file(xdg.get_data_path('ui', 'about_dialog.ui'))

        self.dialog = builder.get_object('AboutDialog')
        self.dialog.set_transient_for(parent)
        logo = gtk.gdk.pixbuf_new_from_file(
            xdg.get_data_path('images', 'exailelogo.png'))
        self.dialog.set_logo(logo)
        from xl.main import __version__
        self.dialog.set_version('\n%s' % __version__)
        self.dialog.connect('response', lambda dialog, response: dialog.destroy())

    def __init__(self):
        self.icon_theme = Gtk.IconTheme.get_default()
        self.icon_factory = Gtk.IconFactory()
        self.icon_factory.add_default()
        # Any arbitrary widget is fine
        self.render_widget = Gtk.Button()
        self.system_visual = Gdk.Visual.get_system()
        # TODO: Make svg actually recognized
        self._sizes = [16, 22, 24, 32, 48, 128, 'scalable']
        self._cache = {}

        self.rating_active_pixbuf = extended_pixbuf_new_from_file(
            xdg.get_data_path('images', 'star.png'))
        self.rating_inactive_pixbuf = extended_pixbuf_new_from_file(
            xdg.get_data_path('images', 'emptystar.png'))

    def __init__(self, parent, collection):
        """
            Initializes the dialog
        """
        self.parent = parent
        self.collection = collection
        builder = gtk.Builder()
        builder.add_from_file(xdg.get_data_path(
            'ui', 'collection_manager.ui'))
        self.dialog = builder.get_object('CollectionManager')
        self.dialog.set_transient_for(self.parent)
        self.view = builder.get_object('view')
        self.model = builder.get_object('model')
        self.remove_button = builder.get_object('remove_button')
        self.message = dialogs.MessageBar(
            parent=builder.get_object('content_area'),
            buttons=gtk.BUTTONS_CLOSE
        )

        builder.connect_signals(self)

        selection = self.view.get_selection()
        selection.connect('changed', self.on_selection_changed)

        for location, library in collection.libraries.iteritems():
            self.model.append([location, library.monitored, library.startup_scan])

    def __init__(self, all_button=True):
        gtk.HBox.__init__(self, homogeneous=False, spacing=5)

        self.parent_row = None
        self.all_func = None
        self.update_func = None
        # Prevents the update function from being called, make 
        # sure you do that manually after the batch update
        self.batch_update = False

        self.pixbuf = None
        self.info = CoverImage(None, None, None, None)
        self.default_type = 3
        self.mime_info = {
            'image/jpeg': {
                # Title for display
                'title': _('JPEG image'),
                # Type and options for GDK Pixbuf saving
                'type': 'jpeg',
                'options': {'quality': '90'}
            },
            'image/png': {
                'title': _('PNG image'),
                'type': 'png',
                'options': {}
            },
            'image/': {
                'title': _('Image'),
                # Store unknown images as JPEG
                'type': 'jpeg',
                'options': {'quality': '90'}
            },
            # TODO: Handle linked images
            '-->': {
                'title': _('Linked image')
            }
        }

        builder = gtk.Builder()
        builder.add_from_file(xdg.get_data_path('ui', 'trackproperties_dialog_cover_row.ui'))
        builder.connect_signals(self)
        cover_row = builder.get_object('cover_row')
        cover_row.reparent(self)

        button = builder.get_object('button')
        button.drag_dest_set(gtk.DEST_DEFAULT_ALL, [], gtk.gdk.ACTION_COPY)
        button.drag_dest_add_uri_targets()

        self.image = builder.get_object('image')
        self.info_label = builder.get_object('info_label')
        self.type_model = builder.get_object('type_model')
        self.type_selection = builder.get_object('type_selection')
        self.type_selection.set_sensitive(False)
        self.description_entry = builder.get_object('description_entry')
        self.description_entry.set_sensitive(False)

        self.all_button = None
        if all_button:
            self.all_button = AllButton(self)
            self.pack_start(self.all_button, expand=False, fill=False)

 def show_about_dialog(self, *e):
     """
         Displays the about dialog
     """
     import xl.main as xlmain
     builder = gtk.Builder()
     builder.add_from_file(xdg.get_data_path('ui/about_dialog.ui'))
     dialog = builder.get_object('AboutDialog')
     logo = gtk.gdk.pixbuf_new_from_file(
         xdg.get_data_path('images/exailelogo.png'))
     dialog.set_logo(logo)
     dialog.set_program_name('Exaile')
     dialog.set_version("\n" + str(xlmain.__version__))
     dialog.set_transient_for(self.main.window)
     dialog.connect('response', lambda d, r: d.destroy())
     dialog.show()

    def __init__(self, parent, track, search=None):
        """
            Expects the parent control, a track, an an optional search string
        """
        gobject.GObject.__init__(self)
        self.parent = parent
        self.builder = gtk.Builder()
        self.builder.add_from_file(xdg.get_data_path("ui/coverchooser.ui"))
        self.builder.connect_signals(self)
        self.window = self.builder.get_object("CoverChooser")

        self.window.set_title(
            _("Cover options for %(artist)s - %(album)s")
            % {"artist": track.get_tag_display("artist"), "album": track.get_tag_display("album")}
        )
        self.window.set_transient_for(parent)

        self.message = dialogs.MessageBar(parent=self.builder.get_object("main_container"), buttons=gtk.BUTTONS_CLOSE)
        self.message.connect("response", self.on_message_response)

        self.track = track
        self.covers = []
        self.current = 0

        self.cover = guiutil.ScalableImageWidget()
        self.cover.set_image_size(350, 350)

        self.cover_image_box = self.builder.get_object("cover_image_box")

        self.loading_indicator = gtk.Alignment()
        self.loading_indicator.props.xalign = 0.5
        self.loading_indicator.props.yalign = 0.5
        self.loading_indicator.set_size_request(350, 350)
        self.cover_image_box.pack_start(self.loading_indicator)

        try:
            spinner = gtk.Spinner()
            spinner.set_size_request(100, 100)
            spinner.start()
            self.loading_indicator.add(spinner)
        except AttributeError:  # Older than GTK 2.20 and PyGTK 2.22
            self.loading_indicator.add(gtk.Label(_("Loading...")))

        self.size_label = self.builder.get_object("size_label")
        self.source_label = self.builder.get_object("source_label")

        self.covers_model = self.builder.get_object("covers_model")
        self.previews_box = self.builder.get_object("previews_box")
        self.previews_box.set_no_show_all(True)
        self.previews_box.hide()
        self.previews_box.set_model(None)

        self.set_button = self.builder.get_object("set_button")
        self.set_button.set_sensitive(False)

        self.window.show_all()

        self.stopper = threading.Event()
        self.fetcher_thread = threading.Thread(target=self.fetch_cover, name="Coverfetcher")
        self.fetcher_thread.start()

    def __init__(self, location):
        """
            :param location: The directory to load and store data in.
        """
        providers.ProviderHandler.__init__(self, "covers")
        self.__cache = Cacher(os.path.join(location, 'cache'))
        self.location = location
        self.methods = {}
        self.order = settings.get_option(
                'covers/preferred_order', [])
        self.db = {}
        self.load()
        for method in self.get_providers():
            self.on_provider_added(method)

        default_cover_file = open(xdg.get_data_path('images', 'nocover.png'), 'rb')
        self.default_cover_data = default_cover_file.read()
        default_cover_file.close()

        self.tag_fetcher = TagCoverFetcher()
        self.localfile_fetcher = LocalFileCoverFetcher()

        if settings.get_option('covers/use_tags', True):
            providers.register('covers', self.tag_fetcher)
        if settings.get_option('covers/use_localfile', True):
            providers.register('covers', self.localfile_fetcher)

        event.add_callback(self._on_option_set, 'covers_option_set')

def __setup_context_page():
    '''Some of these icons may not exist'''
    
    ContextPage.TRACK_ICO_PATH = xdg.get_data_path('images/16x16/audio-x-generic.png')
    ContextPage.ARTIST_ICO_PATH = xdg.get_data_path("images/16x16/artist.png")
    
    ContextPage.SEARCH_ICO_PATH = None
    search_icon = gtk.icon_theme_get_default().lookup_icon(gtk.STOCK_FIND,
        gtk.ICON_SIZE_SMALL_TOOLBAR, gtk.ICON_LOOKUP_NO_SVG)
    if search_icon is not None:
        ContextPage.SEARCH_ICON_PATH = search_icon.get_filename()
        
    ContextPage.ALBUM_ICO_PATH = None
    album_icon = gtk.icon_theme_get_default().lookup_icon(gtk.STOCK_CDROM,
        gtk.ICON_SIZE_SMALL_TOOLBAR, gtk.ICON_LOOKUP_NO_SVG)
    if album_icon is not None:
        ContextPage.ALBUM_ICO_PATH = album_icon.get_filename()

def get_image_data(data, size):
    imbuff = ImageBuffer()
    try:
        im = Image.open(StringIO(data))
    except Exception:
        im = Image.open(xdg.get_data_path('images/nocover.png'))
    im = im.resize(size, Image.ANTIALIAS)
    im.save(imbuff, "PNG")
    return 'data:image/png;base64,%s' % imbuff.get_base64()

def initialize_from_xml(this, other=None):
    '''
        DEPRECATED. Use GtkComposite, GtkCallback, and GtkChild instead
    
        Initializes the widgets and signals from a GtkBuilder XML file. Looks 
        for the following attributes in the instance you pass:
        
        ui_filename = builder filename -- either an absolute path, or a tuple
                      with the path relative to the xdg data directory.
        ui_widgets = [list of widget names]
        ui_signals = [list of function names to connect to a signal]
        
        For each widget in ui_widgets, it will be retrieved from the builder
        object and set as an attribute on the object you pass in.
        
        other is a list of widgets to also initialize with the same file
        
        Returns the builder object when done
    '''
    builder = Gtk.Builder()
    
    if isinstance(this.ui_filename, basestring) and os.path.exists(this.ui_filename):
        builder.add_from_file(this.ui_filename)
    else:
        builder.add_from_file(xdg.get_data_path(*this.ui_filename))
    
    objects = [this]
    if other is not None:
        objects.extend(other)
    
    for obj in objects:
        if hasattr(obj, 'ui_widgets') and obj.ui_widgets is not None:
            for widget_name in obj.ui_widgets:
                widget = builder.get_object(widget_name)
                if widget is None:
                    raise RuntimeError("Widget '%s' is not present in '%s'" % (widget_name, this.ui_filename))
                setattr(obj, widget_name, widget)
    
    signals = None
    
    for obj in objects:
        if hasattr(obj, 'ui_signals') and obj.ui_signals is not None:
            if signals is None:
                signals = {}
            for signal_name in obj.ui_signals:
                if not hasattr(obj, signal_name):
                    raise RuntimeError("Function '%s' is not present in '%s'" % (signal_name, obj))
                signals[signal_name] = getattr(obj, signal_name)
            
    if signals is not None:
        missing = builder.connect_signals(signals)
        if missing is not None:
            err = 'The following signals were found in %s but have no assigned handler: %s' % (this.ui_filename, str(missing))
            raise RuntimeError(err)
    
    return builder

    def __init__(self, parent, pixbuf, album=None, savedir=None):
        """Initializes and shows the cover

        :param parent: Parent window to attach to
        :type parent: Gtk.Window
        :param pixbuf: Pixbuf of the cover image
        :type pixbuf: GdkPixbuf.Pixbuf
        :param album: Album title
        :type album: basestring
        :param savedir: Initial directory for the Save As functionality
        :type savedir: basestring
        """
        self.builder = Gtk.Builder()
        self.builder.add_from_file(xdg.get_data_path('ui', 'coverwindow.ui'))
        self.builder.connect_signals(self)

        self.cover_window = self.builder.get_object('CoverWindow')
        self.layout = self.builder.get_object('layout')
        self.toolbar = self.builder.get_object('toolbar')
        self.save_as_button = self.builder.get_object('save_as_button')
        self.zoom_in_button = self.builder.get_object('zoom_in_button')
        self.zoom_out_button = self.builder.get_object('zoom_out_button')
        self.zoom_100_button = self.builder.get_object('zoom_100_button')
        self.zoom_fit_button = self.builder.get_object('zoom_fit_button')
        self.close_button = self.builder.get_object('close_button')
        self.image = self.builder.get_object('image')
        self.statusbar = self.builder.get_object('statusbar')
        self.scrolledwindow = self.builder.get_object('scrolledwindow')
        self.scrolledwindow.set_hadjustment(self.layout.get_hadjustment())
        self.scrolledwindow.set_vadjustment(self.layout.get_vadjustment())

        if album:
            title = _('Cover for %s') % album
        else:
            title = _('Cover')
        self.savedir = savedir

        self.cover_window.set_title(title)
        self.cover_window.set_transient_for(parent)
        self.cover_window_width = 500
        tb_min_height, tb_natural_height = self.toolbar.get_preferred_height()
        sb_min_height, sb_natural_height = self.statusbar.get_preferred_height()
        self.cover_window_height = 500 + tb_natural_height + sb_natural_height
        self.cover_window.set_default_size(self.cover_window_width, \
                                           self.cover_window_height)

        self.image_original_pixbuf = pixbuf
        self.image_pixbuf = self.image_original_pixbuf
        self.min_percent = 1
        self.max_percent = 500
        self.ratio = 1.5
        self.image_interp = GdkPixbuf.InterpType.BILINEAR
        self.image_fitted = True
        self.set_ratio_to_fit()
        self.update_widgets()

def show_splash(show=True):
    """
        Show a splash screen

        @param show: [bool] show the splash screen
    """
    if not show: return
    image = gtk.Image()
    image.set_from_file(xdg.get_data_path("images/splash.png"))
    builder = gtk.Builder()
    builder.add_from_file(xdg.get_data_path("ui/splash.ui"))
    splash_screen = builder.get_object('SplashScreen')
    box = builder.get_object('splash_box')
    box.pack_start(image, True, True)
    splash_screen.set_transient_for(None)
    splash_screen.show_all()

    #ensure that the splash gets completely drawn before we move on
    while gtk.events_pending():
        gtk.main_iteration()

    return splash_screen

    def __init__(self, parent, main):
        self.main = main
        self.parent = parent
        self.device_manager = self.main.exaile.devices
        self.builder = gtk.Builder()
        self.builder.add_from_file(xdg.get_data_path('ui/device_manager.ui'))
        self.window = self.builder.get_object('device_manager')
        self.window.set_transient_for(self.parent)
        self.window.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
        self.window.connect('delete-event', self.on_close)

        self.builder.connect_signals({
            'on_btn_connect_clicked': self.on_connect,
            'on_btn_disconnect_clicked': self.on_disconnect,
            'on_btn_edit_clicked': self.on_edit,
            'on_btn_add_clicked': self.on_add,
            'on_btn_remove_clicked': self.on_remove,
            'on_btn_close_clicked': self.on_close,
            })

        # TODO: make these actually work.  For now, they are hidden
        for item in ('add', 'edit', 'remove'):
            self.builder.get_object('btn_%s' % item).destroy()

        # object should really be devices.Device, but it doesnt work :/
        self.model = gtk.ListStore(object, gtk.gdk.Pixbuf, str, str)
        self.tree = self.builder.get_object('tree_devices')
        self.tree.set_model(self.model)

        render = gtk.CellRendererPixbuf()
        col = gtk.TreeViewColumn(_("Icon"), render)
        col.add_attribute(render, "pixbuf", 1)
        self.tree.append_column(col)

        render = gtk.CellRendererText()
        col = gtk.TreeViewColumn(_("Device"), render)
        col.set_expand(True)
        col.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
        col.add_attribute(render, "text", 2)
        self.tree.append_column(col)

        render = gtk.CellRendererText()
        col = gtk.TreeViewColumn(_("Driver"), render)
        col.add_attribute(render, "text", 3)
        self.tree.append_column(col)

        self.populate_tree()
        event.add_callback(self.populate_tree, 'device_added')
        event.add_callback(self.populate_tree, 'device_removed')

def ui_path(*path, **kwargs):
    '''
        Returns absolute path to a UI file. Each arg will be concatenated
        to construct the final path.

        :param relto: If keyword arg 'relto' is specified, path will be
                      relative to this. Otherwise, it will be relative to
                      the Exaile data directory

        .. versionadded:: 3.5.0
    '''

    relto = kwargs.pop('relto', None)
    if len(kwargs):
        raise ValueError("Only 'relto' is allowed as a keyword argument")

    if relto is None:
        return xdg.get_data_path(*path)
    else:
        return os.path.abspath(os.path.join(os.path.dirname(relto), *path))

    def __init__(self, player):
        Gtk.Bin.__init__(self)
        self.__player = player

        builder = Gtk.Builder()
        builder.add_from_file(xdg.get_data_path('ui', 'widgets', 'track_info.ui'))

        info_box = builder.get_object('info_box')
        info_box.reparent(self)

        self.__auto_update = False
        self.__display_progress = False
        self.__formatter = formatter.TrackFormatter(
            _(
                '<span size="x-large" weight="bold">$title</span>\n'
                'by $artist\n'
                'from $album'
            )
        )
        self.__formatter.connect('notify::format', self.on_notify_format)
        self.__default_text = '<span size="x-large" ' 'weight="bold">%s</span>\n\n' % _(
            'Not Playing'
        )
        self.__cover_size = None
        self.__timer = None
        self.__track = None

        self.info_label = builder.get_object('info_label')
        self.action_area = builder.get_object('action_area')
        self.progress_box = builder.get_object('progress_box')
        self.playback_image = builder.get_object('playback_image')
        self.progressbar = PlaybackProgressBar(player)
        guiutil.gtk_widget_replace(builder.get_object('progressbar'), self.progressbar)

        self.cover = cover.CoverWidget(builder.get_object('cover_image'))
        self.cover.hide()
        self.cover.set_no_show_all(True)

        self.clear()
        self.__update_widget_state()

    def __init__(self, parent, name, label=None):
        """
            Intializes the panel

            @param controller: the main gui controller
            @param name: the name of the panel. should be unique.
            @param label: text of the label displayed to the user 
        """
        gobject.GObject.__init__(self)
        self.name = name        # panel id
        self.label = label      # label to be displayed
        self.parent = parent

        # if the UI designer file starts with file:// use the full path minus
        # file://, otherwise check in the data directories
        ui_file = self.ui_info[0]
        if not os.path.isabs(ui_file):
            ui_file = xdg.get_data_path('ui', 'panel', ui_file)

        self.builder = gtk.Builder()
        self.builder.add_from_file(ui_file)
        self._child = None

    def __init__(self, player):
        self.__volume_setting = '%s/volume' % player._name
        gtk.Alignment.__init__(self, xalign=1)

        self.restore_volume = settings.get_option(self.__volume_setting, 1)
        self.icon_names = ['low', 'medium', 'high']

        builder = gtk.Builder()
        builder.add_from_file(xdg.get_data_path('ui', 'widgets',
            'volume_control.ui'))
        builder.connect_signals(self)

        box = builder.get_object('volume_control')
        box.reparent(self)

        self.button = builder.get_object('button')
        self.button.add_events(gtk.gdk.KEY_PRESS_MASK)
        self.button_image = builder.get_object('button_image')
        self.slider = builder.get_object('slider')
        self.slider_adjustment = builder.get_object('slider_adjustment')
        self.__update(self.restore_volume)

        event.add_callback(self.on_option_set, '%s_option_set' % player._name)

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.


from xlgui.preferences import widgets
from xl.nls import gettext as _
from xl import xdg

name = _('Lyrics Viewer')
ui = xdg.get_data_path('ui', 'preferences', 'lyrics.ui')


DEFAULT_FONT = None


class LyricsFontPreference(widgets.FontButtonPreference):
    default = None
    name = 'plugin/lyricsviewer/lyrics_font'

    def __init__(self, preferences, widget):
        self.default = DEFAULT_FONT
        widgets.FontButtonPreference.__init__(self, preferences, widget)


class LyricsFontResetButtonPreference(widgets.FontResetButtonPreference):