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

        kw.update({'variable' : self.scale_var,

                   'from' : 1, 'to' : 0, 'showvalue' : 0,

                   'sliderlength' : 15, 'res' : 0.01,

                   'width' : 40, 'troughcolor' : 'black', 'bg' : 'grey40',

                   'highlightthickness' : 1, 'bd' : 1,

                   'highlightcolor' : 'red', 'highlightbackground' : 'black',

                   'activebackground' : 'red'})

        Scale.__init__(self, master, *args, **kw)

        Fadable.__init__(self, var=self.scale_var, wheel_step=0.05)

        self.draw_indicator_colors()

    def draw_indicator_colors(self):

        if self.scale_var.get() == 0:

            self['troughcolor'] = 'black'

        else:

            self['troughcolor'] = 'blue'

class SubmasterTk(Frame):

    def __init__(self, master, name, current_level):

        Frame.__init__(self, master, bd=1, relief='raised', bg='black')

        self.name = name

        self.slider_var = DoubleVar()

        self.slider_var.set(current_level)

        self.scale = SubScale(self, variable=self.slider_var, width=20)

        namelabel.pack(side=TOP)

        levellabel.pack(side=TOP)

        self.scale.pack(side=BOTTOM, expand=1, fill=BOTH)

        bindkeys(self, "<Control-Key-l>", self.launch_subcomposer)

    def launch_subcomposer(self, *args):

        subprocess.Popen(["bin/subcomposer", "--no-geometry", self.name])

class KeyboardComposer(Frame, SubClient):

    def __init__(self, root, submasters, current_sub_levels=None,

                 hw_sliders=True):

        Frame.__init__(self, root, bg='black')

        SubClient.__init__(self)

        self.submasters = submasters

        self.name_to_subtk = {}

        self.current_sub_levels = {}

        self.current_row = 0

        if current_sub_levels is not None:

            self.current_sub_levels = current_sub_levels

        else:

            try:

                self.current_sub_levels, self.current_row = \

                    pickle.load(file('.keyboardcomposer.savedlevels'))

            except IOError:

                pass

                    lambda evt, k=k: self.fade(k / 10.0))

            self.bind("<Key-0>", lambda evt: self.fade(1.0))

            self.bind("<grave>", lambda evt: self.fade(0))

            # up / down arrows

            self.bind("<Key-Up>", lambda evt: self.increase())

            self.bind("<Key-Down>", lambda evt: self.decrease())

        if mouse_bindings:

            # right mouse button toggles muting

            self.bind('<3>', lambda evt: self.toggle_mute())

            # not "NOT ANY MORE!" - homer (i.e. it works again)

            # mouse wheel

            self.bind('<4>', lambda evt: self.increase())

            self.bind('<5>', lambda evt: self.decrease())

            # modified mouse wheel

            self.bind('<Shift-4>', lambda evt: self.increase(multiplier=0.2))

            self.bind('<Shift-5>', lambda evt: self.decrease(multiplier=0.2))

            self.bind('<Control-4>', lambda evt: self.increase(length=1))

            self.bind('<Control-5>', lambda evt: self.decrease(length=1))

        self.last_level = None # used for muting

    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.fading = 0 # we stop all fades

        else: # the general case

            self.fade_start_time = time.time()

            self.fade_length = length

            self.fade_start_level = self.fade_var.get()

            self.fade_end_level = value

            self.fade_step_time = step_time

            if not self.fading:

                self.fading = 1

                self.do_fade()

    def do_fade(self):

        """Actually performs the fade for Fadable.fade.  Shouldn't be called

        directly."""

        now = time.time()

        elapsed = now - self.fade_start_time

        complete = elapsed / self.fade_length

        complete = min(1.0, complete)

        diff = self.fade_end_level - self.fade_start_level

        newlevel = (complete * diff) + self.fade_start_level

        if complete < 1:

            self.after(self.fade_step_time, self.do_fade)

        else:

            self.fading = 0

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

        """Increases 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

        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

        newlevel = max(0, newlevel)

        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:

    def toggle_mute(self):

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

        if self.last_level is None:

            self.last_level = self.fade_var.get()

            if self.last_level == 0: # we don't want last_level to be zero,

                                     # since it will make us toggle between 0

                                     # and 0

                newlevel = 1

            else:

                newlevel = 0

        else:

            newlevel = self.last_level

            self.last_level = None

if __name__ == "__main__":

    class SubScale(Scale, Fadable):

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

            self.scale_var = DoubleVar()

            kw['variable'] = self.scale_var

            Scale.__init__(self, master, *args, **kw)

            Fadable.__init__(self, var=self.scale_var)

    root = Tk()

    root.tk_focusFollowsMouse()

    ss = SubScale(root, from_=1, to_=0, res=0.01)

    ss.pack()

    mainloop()

  KC should have a separate window that repeats the names of the subs

  in the current row, numbered as hardware sliders. This would be put

  on the screen where it's always visible, when KC is hidden

  subterms on nonexistent subs are getting lost, but i need those for

  chase and effects

OK  subcomposer should save its geometry

  how to reset the dmx channels on a dimmer pack: [dmx] [erase] [clear]

  make a program to test chases

OK  curvecalc should always start up zoomed-out

  need curve delete button. show on each curve whether it's in use

  anywhere. let me hide a music curve if i'm low on space.

  ascoltami should learn to adjust volumes

  unnamed subterm is serious. i think only the last one created gets

  saved, or something

  curvecalc_all_subterms needs redo

  touched dmx cable; ~/dmxcrash in dmesg; process went to 'D' status; rebooted

  a nice startup would be: take a cd, boot up our OS image, make a new

  show from the cd tracks, UI for naming the channel numbers. 

  bring gaffer's tape