subtk.scale.fade(0)

            else:

                subtk.scale.decrease()

    def draw_sliders(self):

        self.tk_focusFollowsMouse()

        rowcount = -1

        col = 0

        for sub in self.submasters.get_all_subs():

            if col == 0: # make new row

                row = self.make_row()

                rowcount += 1

            current_level = self.current_sub_levels.get(sub.name, 0)

            subtk = self.draw_sub_slider(row, col, sub.name, current_level)

            self.slider_table[(rowcount, col)] = subtk

            self.name_to_subtk[sub.name] = subtk

            col += 1

            col %= 10

            def slider_changed(x, y, z, subtk=subtk):

                subtk.scale.draw_indicator_colors()

                self.send_levels()

            subtk.slider_var.trace('w', slider_changed)

    def make_row(self):

        row = Frame(self, bd=2, bg='black')

        row.pack(expand=1, fill=BOTH)

        self.setup_key_nudgers(row)

        self.rows.append(row)

        return row

    def draw_sub_slider(self, row, col, name, current_level):

        subtk = SubmasterTk(row, name, current_level)

        subtk.place(relx=col * 0.1, rely=0, relwidth=0.1, relheight=1)

        self.setup_key_nudgers(subtk.scale)

        self.slider_vars[name] = subtk.slider_var

        return subtk

    def highlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'red'

    def unhighlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'black'

    def get_levels(self):

        return dict([(name, slidervar.get()) 

            for name, slidervar in self.slider_vars.items()])

    def get_levels_as_sub(self):

        scaledsubs = [self.submasters.get_sub_by_name(sub) * level \

        maxes = sub_maxes(*scaledsubs)

        return maxes

    def save_current_stage(self, subname):

        print "saving current levels as", subname

        sub = self.get_levels_as_sub()

        sub.name = subname

        sub.temporary = 0

        sub.save()

    def save(self):

        pickle.dump(self.get_levels(), 

                    file('.keyboardcomposer.savedlevels', 'w'))

    def send_frequent_updates(self):

        """called when we get a fade -- send events as quickly as possible"""

        if time.time() <= self.stop_frequent_update_time:

            self.send_levels()

            self.after(10, self.send_frequent_updates)

    def refresh(self):

        self.save()

        self.submasters = Submasters()

        self.current_sub_levels = \

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

        for r in self.rows:

            r.destroy()

        self.keyhints.destroy()

        self.buttonframe.destroy()

        self.draw_ui()

    def alltozero(self):

        for name, subtk in self.name_to_subtk.items():

            if subtk.scale.scale_var.get() != 0:

                subtk.scale.fade(value=0.0, length=0)

class LevelServer(xmlrpc.XMLRPC):

    def __init__(self,name_to_subtk):

        self.name_to_subtk = name_to_subtk

    def xmlrpc_fadesub(self,subname,level,secs):

        """submaster will fade to level in secs"""

        try:

            self.name_to_subtk[subname].scale.fade(level,secs)

            ret='ok'

        except Exception,e:

            ret=str(e)

        return ret

from __future__ import division

import os

from light9.TLUtility import dict_scale, dict_max

from light9 import Patch, showconfig

import dispatch.dispatcher as dispatcher

class Submaster:

    "Contain a dictionary of levels, but you didn't need to know that"

    def __init__(self, name, leveldict=None, temporary=0):

        self.name = name

        self.temporary = temporary

        if leveldict:

            self.levels = leveldict

        else:

            self.levels = {}

            self.reload(quiet=True)

    def reload(self, quiet=False):

        if self.temporary:

            return

        try:

            oldlevels = self.levels.copy()

            self.levels.clear()

            subfile = file(showconfig.subFile(self.name))

            for line in subfile.readlines():

                if not line.strip(): # if line is only whitespace

                    continue # "did i say newspace?"

                try:

                    name, val = line.split(':')

                    name = name.strip()

                    self.levels[name] = float(val)

                except ValueError:

                    print "(%s) Error with this line: %s" % (self.name, 

                        line[:-1])

                if (not quiet) and (oldlevels != self.levels):

                    print "sub %s changed" % self.name

        except IOError:

            print "Can't read file for sub: %s" % self.name

    def save(self):

        if self.temporary:

            print "not saving temporary sub named",self.name

            return

        subfile = file(showconfig.subFile(self.name), 'w')

        names = self.levels.keys()

        names.sort()

        for name in names:

            val = self.levels[name]

            subfile.write("%s : %s\n" % (name, val))

    def set_level(self, channelname, level, save=1):

        self.levels[Patch.resolve_name(channelname)] = level

        if save:

            self.save()

    def set_all_levels(self, leveldict):

        self.levels.clear()

        for k, v in leveldict.items():

            self.set_level(k, v, save=0)

        self.save()

    def get_levels(self):

        return self.levels

    def no_nonzero(self):

        return (not self.levels.values()) or not (max(self.levels.values()) > 0)

    def __mul__(self, scalar):