def get_cfg(option):
    cfg_option = "%s_%s" % (_PLUGIN_ID, option)
    default = _SETTINGS[option][2]

    if option == "threshold":
        return config.getfloat("plugins", cfg_option, default)
    elif option == "ratio":
        return config.getfloat("plugins", cfg_option, default)

def get_cfg(option):
    cfg_option = "%s_%s" % (_PLUGIN_ID, option)
    default = _SETTINGS[option][1]

    if option == "rate":
        return config.getfloat("plugins", cfg_option, default)
    elif option == "tempo":
        return config.getfloat("plugins", cfg_option, default)
    elif option == "pitch":
        return config.getfloat("plugins", cfg_option, default)

 def do_set_property(self, property, v):
     if property.name == 'volume':
         self._volume = v
         if self.song and config.getboolean("player", "replaygain"):
             profiles = filter(None, self.replaygain_profiles)[0]
             fb_gain = config.getfloat("player", "fallback_gain")
             pa_gain = config.getfloat("player", "pre_amp_gain")
             scale = self.song.replay_gain(profiles, pa_gain, fb_gain)
             v = min(10.0, max(0.0, v * scale)) # volume supports 0..10
         if self.bin:
             self._vol_element.set_property('volume', v)
     else:
         raise AttributeError

 def do_set_property(self, property, v):
     if property.name == 'volume':
         self._volume = v
         if self.song and config.getboolean("player", "replaygain"):
             profiles = filter(None, self.replaygain_profiles)[0]
             fb_gain = config.getfloat("player", "fallback_gain")
             pa_gain = config.getfloat("player", "pre_amp_gain")
             scale = self.song.replay_gain(profiles, pa_gain, fb_gain)
             v = max(0.0, v * scale)
         v = min(100, int(v * 100))
         xine_set_param(self._stream, XINE_PARAM_AUDIO_AMP_LEVEL, v)
     else:
         raise AttributeError

 def __refresh_album(self, menuitem, view):
     albums = self.__get_selected_albums()
     mag = config.getfloat("browsers", "covergrid_magnification", 3.)
     scale_factor = self.get_scale_factor() * mag
     for album in albums:
         album.scan_cover(True, scale_factor=scale_factor)
     self._refresh_albums(albums)

def bayesian_average(nums, c=None, m=None):
    """Returns the Bayesian average of an iterable of numbers,
    with parameters defaulting to config specific to ~#rating."""
    m = m or config.RATINGS.default
    c = c or config.getfloat("settings", "bayesian_rating_factor", 0.0)
    ret = float(m * c + sum(nums)) / (c + len(nums))
    return ret

 def test_get(self):
     config.set("foo", "int", "1")
     config.set("foo", "float", "1.25")
     config.set("foo", "str", "foobar")
     config.set("foo", "bool", "True")
     self.failUnlessEqual(config.getint("foo", "int"), 1)
     self.failUnlessEqual(config.getfloat("foo", "float"), 1.25)
     self.failUnlessEqual(config.get("foo", "str"), "foobar")
     self.failUnlessEqual(config.getboolean("foo", "bool"), True)

    def _no_cover(self):
        """Returns a cairo surface representing a missing cover"""

        mag = config.getfloat("browsers", "covergrid_magnification", 3.)

        cover_size = get_cover_size()
        scale_factor = self.get_scale_factor() * mag
        pb = get_no_cover_pixbuf(cover_size, cover_size, scale_factor)
        return get_surface_for_pixbuf(self, pb)

 def update_mag(klass):
     mag = config.getfloat("browsers", "covergrid_magnification", 3.)
     for covergrid in klass.instances():
         covergrid.__cover.set_property('width', get_cover_size() * mag + 8)
         covergrid.__cover.set_property('height',
             get_cover_size() * mag + 8)
         covergrid.view.set_item_width(get_cover_size() * mag + 8)
         covergrid.view.queue_resize()
         covergrid.redraw()

    def __init__(self):
        for (key, text, func) in self.keys:
            val = config.getfloat("plugins", "randomalbum_%s" % key, 0.0)
            self.weights[key] = val

        use = config.getint("plugins", "randomalbum_use_weights", 0)
        self.use_weights = use
        delay = config.getint("plugins", "randomalbum_delay", 0)
        self.delay = delay

    def __init__(self, parent, player, library):
        super(TopBar, self).__init__()

        # play controls
        control_item = Gtk.ToolItem()
        self.insert(control_item, 0)
        t = PlayControls(player, library.librarian)
        self.volume = t.volume

        # only restore the volume in case it is managed locally, otherwise
        # this could affect the system volume
        if not player.has_external_volume:
            player.volume = config.getfloat("memory", "volume")

        connect_destroy(player, "notify::volume", self._on_volume_changed)
        control_item.add(t)

        self.insert(Gtk.SeparatorToolItem(), 1)

        info_item = Gtk.ToolItem()
        self.insert(info_item, 2)
        info_item.set_expand(True)

        box = Gtk.Box(spacing=6)
        info_item.add(box)
        qltk.add_css(self, "GtkToolbar {padding: 3px;}")

        self._pattern_box = Gtk.VBox()

        # song text
        info_pattern_path = os.path.join(quodlibet.get_user_dir(), "songinfo")
        text = SongInfo(library.librarian, player, info_pattern_path)
        self._pattern_box.pack_start(Align(text, border=3), True, True, 0)
        box.pack_start(self._pattern_box, True, True, 0)

        # cover image
        self.image = CoverImage(resize=True)
        connect_destroy(player, 'song-started', self.__new_song)

        # FIXME: makes testing easier
        if app.cover_manager:
            connect_destroy(
                app.cover_manager, 'cover-changed',
                self.__song_art_changed, library)

        box.pack_start(Align(self.image, border=2), False, True, 0)

        # On older Gtk+ (3.4, at least)
        # setting a margin on CoverImage leads to errors and result in the
        # QL window not being visible for some reason.
        assert self.image.props.margin == 0

        for child in self.get_children():
            child.show_all()

        context = self.get_style_context()
        context.add_class("primary-toolbar")

 def mag_changed(mag):
     if self.mag_lock:
         return
     newmag = mag.get_value()
     oldmag = config.getfloat("browsers", "covergrid_magnification", 3.0)
     if newmag == oldmag:
         print_d("Covergrid magnification haven't changed: {0}".format(newmag))
         return
     print_d("Covergrid magnification update from {0} to {1}".format(oldmag, newmag))
     config.set("browsers", "covergrid_magnification", mag.get_value())
     browser.update_mag()

    def test_bayesian_multiple_ratings(s):
        # separated from above to avoid caching
        c, r1, r2 = 5, 1.0, 0.5
        songs = [Fakesong({"~#rating": r1}), Fakesong({"~#rating": r2})]
        album = Album(songs[0])
        album.songs = set(songs)

        config.set("settings", "bayesian_rating_factor", float(c))
        s.failUnlessEqual(config.getfloat("settings", "bayesian_rating_factor"), float(c))
        expected = avg(c * [config.RATINGS.default] + [r1, r2])
        s.failUnlessEqual(album("~#rating:bav"), expected)
        s.failUnlessEqual(album("~#rating"), expected)

    def calc_replaygain_volume(self, volume):
        """Returns a new float volume for the given volume.

        Takes into account the global active replaygain profile list,
        the user specified replaygain settings and the tags available
        for that song.

        Args:
            volume (float): 0.0..1.0
        Returns:
            float: adjusted volume, can be outside of 0.0..0.1
        """

        if self.song and config.getboolean("player", "replaygain"):
            profiles = listfilter(None, self.replaygain_profiles)[0]
            fb_gain = config.getfloat("player", "fallback_gain")
            pa_gain = config.getfloat("player", "pre_amp_gain")
            scale = self.song.replay_gain(profiles, pa_gain, fb_gain)
        else:
            scale = 1
        return volume * scale

    def __init__(self, songs, library):
        super(WeightedPlaylist, self).__init__(songs, library)

        for key,_ in self.options["weights"]:
            val = config.getfloat("plugins", "weightedlibrary_%s" % key, 0.0)
            self.weights[key] = val
        for key,_,min_value,max_value in self.options["values"]:
            val = config.getfloat("plugins", "weightedlibrary_%s" % key, (min_value+max_value)/2.)
            self.weights[key] = val


        for key,val in self.weights.items():
            print "%s = %s" % (key,val)

        rater = ModifiedAveragedRater()
        # Raters are a weighted sum
        rater.add_rater(weight=self.weights["rating"], rater=SongRatingRater())
        rater.add_rater(weight=self.weights["tempo"], rater=BpmRater(target_bpm=self.weights["tempo_target"], spread=self.weights["tempo_spread"])) # Variety is between 0 and 50
        # Modifiers work multiplicatively
        rater.add_modifier(weight=3., rater=RepeaterRater())

        self.rater = rater

    def test_basic(self):
        self.failUnless(config.get("memory", "foobar", None) is None)

        p = x.ConfigRVPaned("memory", "foobar", 0.75)
        p.pack1(Gtk.Button())
        p.pack2(Gtk.Button())

        with visible(p, width=200, height=200) as p:
            self.failUnlessAlmostEqual(p.get_relative(), 0.75, 2)
            p.props.position = 20
            self.failUnlessAlmostEqual(p.get_relative(), 0.10, 2)

        config_value = config.getfloat("memory", "foobar")
        self.failUnlessAlmostEqual(config_value, 0.10, 2)

    def __set_pane_size(self):
        sub = self.__container
        if not isinstance(self.__container, RPaned):
            for child in self.__container.get_children():
                if isinstance(child, RPaned):
                    sub = child

        if isinstance(sub, RPaned):
            try:
                key = "%s_pos" % self.browser.__class__.__name__
                val = config.getfloat("browsers", key)
            except:
                val = 0.4
            sub.set_relative(val)

    def __init__(self, parent, player, library):
        super(TopBar, self).__init__()

        # play controls
        control_item = Gtk.ToolItem()
        self.insert(control_item, 0)
        t = PlayControls(player, library.librarian)
        self.volume = t.volume

        # only restore the volume in case it is managed locally, otherwise
        # this could affect the system volume
        if not player.has_external_volume:
            player.volume = config.getfloat("memory", "volume")

        self.volume.connect("value-changed", self._on_volume_changed)
        control_item.add(t)

        self.insert(Gtk.SeparatorToolItem(), 1)

        info_item = Gtk.ToolItem()
        self.insert(info_item, 2)
        info_item.set_expand(True)

        box = Gtk.Box(spacing=6)
        info_item.add(box)
        qltk.add_css(self, "GtkToolbar {padding: 3px;}")

        # song text
        info_pattern_path = os.path.join(const.USERDIR, "songinfo")
        text = SongInfo(library.librarian, player, info_pattern_path)
        box.pack_start(Align(text, border=3), True, True, 0)

        # cover image
        self.image = CoverImage(resize=True)
        connect_destroy(player, 'song-started', self.__new_song)

        # FIXME: makes testing easier
        if app.cover_manager:
            connect_destroy(
                app.cover_manager, 'cover-changed',
                self.__song_art_changed, library)

        self.image.props.margin = 2
        box.pack_start(self.image, False, True, 0)

        for child in self.get_children():
            child.show_all()

        context = self.get_style_context()
        context.add_class("primary-toolbar")

    def __init__(self, device):
        super(Volume, self).__init__(size=Gtk.IconSize.MENU, use_symbolic=True)

        self.set_relief(Gtk.ReliefStyle.NORMAL)
        self.set_adjustment(Gtk.Adjustment.new(0, 0, 1, 0.05, 0.1, 0))

        self.connect('value-changed', self.__volume_changed, device)
        device.connect('notify::volume', self.__volume_notify)
        self.set_value(config.getfloat("memory", "volume"))

        replaygain_menu = ReplayGainMenu(device)
        replaygain_menu.attach_to_widget(self, None)
        self.connect('popup-menu', self.__popup, replaygain_menu)
        connect_obj(self, 'button-press-event', self.__volume_button_press,
                            replaygain_menu)

    def __init__(self, device):
        super(Volume, self).__init__()

        self.props.size = SUBSIZE
        self.set_relief(gtk.RELIEF_NORMAL)
        self.set_adjustment(gtk.Adjustment(0, 0, 1, 0.05, 0.1, 0))

        self.connect('value-changed', self.__volume_changed, device)
        device.connect('notify::volume', self.__volume_notify)
        self.set_value(config.getfloat("memory", "volume"))

        self.show_all()

        replaygain_menu = ReplayGainMenu(device)
        self.connect('popup-menu', self.__popup, replaygain_menu)
        self.connect_object('button-press-event', self.__volume_button_press,
                            replaygain_menu)