pass

    def reopen(self):

        pass

class SubScale(tk.Scale, Fadable):

    def __init__(self, master, *args, **kw):

        self.scale_var = kw.get('variable') or tk.DoubleVar()

        kw.update({

            'variable': self.scale_var,

            'showvalue': 0,

            'sliderlength': 15,

            'res': 0.001,

            'width': 40,

            'troughcolor': 'black',

            'bg': 'grey40',

            'highlightthickness': 1,

            'bd': 1,

            'highlightcolor': 'red',

            'highlightbackground': 'black',

            'activebackground': 'red'

        })

        self.last_level = None  # used for muting

    def set_var_rounded(self, value):

        """use this instead of just self.fade_var.set(value) so we can

        control the precision"""

        # this was just to make the display not look so weird, but it

        # could actually affect the speed of really slow fades. If

        # that's a problem, do a real trace_write hook for the

        # variable's display instead of using Label(textvariable=var)

        # and format it there.

        self.fade_var.set(round(value, 7))

    def fade(self, value, length=0.5, step_time=10):

        """Fade to value in length seconds with steps every step_time

        milliseconds"""

        if length == 0:  # 0 seconds fades happen right away and prevents

            # and prevents us from entering the fade loop,

            # which would cause a divide by zero

            self.set_var_rounded(value)

            self.fading = 0  # we stop all fades

        else:  # the general case

            self.fade_start_time = time.time()

            self.fade_length = length

            newlevel = self.fade_var.get() + amount

        newlevel = min(100, newlevel)

        self.set_volume(newlevel, length)

    def decrease(self, multiplier=1, length=0.3):

        """Descreases the volume by multiplier * wheel_step.  If use_fades

        is true, it do this as a fade over length time."""

        amount = self.wheel_step * multiplier

        if self.fading:

            newlevel = self.fade_end_level - amount

        else:

            newlevel = self.fade_var.get() - amount

        self.set_volume(newlevel, length)

    def set_volume(self, newlevel, length=0.3):

        """Sets the volume to newlevel, performing a fade of length if

        use_fades is true."""

        if self.use_fades:

            self.fade(newlevel, length=length)

        else:

            self.set_var_rounded(newlevel)

    def toggle_mute(self):

        """Toggles whether the volume is being muted."""

        if self.last_level is None:

            self.last_level = self.fade_var.get()

                # since it will make us toggle between 0

                # and 0

            else:

        else:

            newlevel = self.last_level

            self.last_level = None

        self.set_var_rounded(newlevel)