"""

    def __init__(self, master, sub, session):

        self.sub = sub

        self.session = session

        bg = sub.graph.value(sub.uri, L9.color, default='#000000')

        rgb = webcolors.hex_to_rgb(bg)

        hsv = colorsys.rgb_to_hsv(*[x/255 for x in rgb])

        darkBg = webcolors.rgb_to_hex(tuple([x * 255 for x in colorsys.hsv_to_rgb(

            hsv[0], hsv[1], .3)]))

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

        self.name = sub.name

        self.slider_var = DoubleVar()

        self.pauseTrace = False

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

        self.namelabel = Label(self, font="Arial 7", bg=darkBg,

            fg='white', pady=0)

        self.sub.graph.addHandler(self.updateName)

        self.namelabel.pack(side=TOP)

        levellabel = Label(self, textvariable=self.slider_var, font="Arial 7",

            bg='black', fg='white', pady=0)

        levellabel.pack(side=TOP)

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

        for w in [self, self.namelabel, levellabel]:

            dragSourceRegister(w, 'copy', 'text/uri-list', sub.uri)

        self._slider_var_trace = self.slider_var.trace('w', self.slider_changed)

        sub.graph.addHandler(self.updateLevelFromGraph)

        # initial position

#        self.send_to_hw(sub.name, col + 1) # needs fix

    def cleanup(self):

        self.slider_var.trace_vdelete('w', self._slider_var_trace)

    def slider_changed(self, *args):

        self.scale.draw_indicator_colors()

        if self.pauseTrace:

            return

        self.updateGraphWithLevel(self.sub.uri, self.slider_var.get())

        # dispatcher.send("level changed") # in progress

        ###self.send_levels() # use dispatcher?

        # needs fixing: plan is to use dispatcher or a method call to tell a hardware-mapping object who changed, and then it can make io if that's a current hw slider

                                    subject=self.session,

                                    predicate=L9['subSetting'],

                                    nodeClass=L9['SubSetting'],

                                    keyPred=L9['sub'], newKey=uri,

                                    valuePred=L9['level'], newValue=Literal(level))

    def updateLevelFromGraph(self):

        """read rdf level, write it to subbox.slider_var"""

        # move this to syncedgraph readMapping

        graph = self.sub.graph

        for setting in graph.objects(self.session, L9['subSetting']):

            if graph.value(setting, L9['sub']) == self.sub.uri:

                self.pauseTrace = True # don't bounce this update back to server

                try:

                    self.slider_var.set(graph.value(setting, L9['level']))

                finally:

                    self.pauseTrace = False

    def updateName(self):

        def shortUri(u):

            return '.../' + u.split('/')[-1]

        self.namelabel.config(text=self.sub.graph.label(self.sub.uri) or shortUri(self.sub.uri))

class KeyboardComposer(Frame, SubClient):

    def __init__(self, root, graph, session,

                 hw_sliders=True):

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

        SubClient.__init__(self)

        self.graph = graph

        self.session = session

        self.submasters = Submasters(graph)

        self.subbox = {} # sub uri : SubmasterBox

        self.slider_table = {} # coords : SubmasterBox

        self.rows = [] # this holds Tk Frames for each row

        self.current_row = 0 # should come from session graph

        self.use_hw_sliders = hw_sliders

        self.connect_to_hw(hw_sliders)

        self.make_key_hints()

        self.make_buttons()

        self.graph.addHandler(self.redraw_sliders)

        self.send_levels_loop()

        self.graph.addHandler(self.rowFromGraph)

            if slider_var.get() == 1:

                slider_var.set(0)

            else:

                slider_var.set(1)

        elif name.startswith("button-corner"):

            button_num = int(name[13:]) - 1

            if button_num == 1:

                diff = -1

            elif button_num == 3:

                diff = 1

            else:

                return

            kc.change_row(kc.current_row + diff)

            self.valueOut(name, 0)

def launch(opts, root, graph, session):

    tl = toplevelat("Keyboard Composer - %s" % opts.session,

                    existingtoplevel=root, graph=graph, session=session)

    kc = KeyboardComposer(tl, graph, session,

                          hw_sliders=not opts.no_sliders)

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

        tk.Label(root,text=helpline, font="Helvetica -12 italic",

                 anchor='w').pack(side='top',fill='x')

if __name__ == "__main__":

    parser = OptionParser()

    parser.add_option('--no-sliders', action='store_true',

                      help="don't attach to hardware sliders")

    clientsession.add_option(parser)

    parser.add_option('-v', action='store_true', help="log info level")

    opts, args = parser.parse_args()

    log.setLevel(logging.INFO if opts.v else logging.WARN)

    graph = SyncedGraph("keyboardcomposer")

    # i think this also needs delayed start (like subcomposer has), to have a valid graph

    # before setting any stuff from the ui

    root = Tk()

    initTkdnd(root.tk, 'tkdnd/trunk/')

    session = clientsession.getUri('keyboardcomposer', opts)

    graph.initiallySynced.addCallback(