def rowFromGraph(self):

        self.change_row(int(self.graph.value(self.session, L9['currentRow'], default=0)), fromGraph=True)

    def change_row(self, row, fromGraph=False):

        old_row = self.current_row

        self.current_row = row

        self.current_row = max(0, self.current_row)

        self.current_row = min(len(self.rows) - 1, self.current_row)

        try:

            row = self.rows[self.current_row]

        except IndexError:

            # needs to be brought back in

            if fromGraph:

                return

            raise

        self.unhighlight_row(old_row)

        self.highlight_row(self.current_row)

        self.keyhints.pack_configure(before=row)

        if not fromGraph:

            self.graph.patchObject(self.session, self.session, L9['currentRow'],

                                   Literal(self.current_row))

    clientsession.add_option(parser)

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

    opts, args = parser.parse_args()

    logging.basicConfig(level=logging.INFO if opts.v else logging.WARN)

    log = logging.getLogger('keyboardcomposer')

    graph = SyncedGraph("keyboardcomposer")

    root = Tk()

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

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

                    existingtoplevel=root)

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

    kc = KeyboardComposer(tl, graph, session,

                          hw_sliders=not opts.no_sliders)

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

    for helpline in ["Bindings: B3 mute; C-l edit levels in subcomposer"]:

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

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

from __future__ import division, nested_scopes

from optparse import OptionParser

import Tkinter as tk

import louie as dispatcher

from twisted.internet import reactor, tksupport, task

import run_local

from light9.dmxchanedit import Levelbox

from light9 import dmxclient, Patch, Submaster, showconfig, prof

from light9.uihelpers import toplevelat

from light9.rdfdb.syncedgraph import SyncedGraph

class Subcomposer(tk.Frame):

        tk.Frame.__init__(self, master, bg='black')

        self.graph = graph

        self.levelbox = Levelbox(self, graph)

        self.levelbox.pack(side='top')

        self.savebox = EntryCommand(self, cmd=self.savenewsub)

        self.savebox.pack(side='top')

        self.loadbox = EntryCommand(self, verb="Load", cmd=self.loadsub)

        self.loadbox.pack(side='top')

        def alltozero():

            for lev in self.levelbox.levels:

                lev.setlevel(0)

        tk.Button(self, text="all to zero", command=alltozero).pack(side='top')

        dispatcher.connect(self.sendupdate, "levelchanged")

    def fill_both_boxes(self, subname):

        for box in [self.savebox, self.loadbox]:

            box.set(subname)

    def savenewsub(self, subname):

        leveldict={}

        for i,lev in zip(range(len(self.levels)),self.levels):

            if lev!=0:

                leveldict[Patch.get_channel_name(i+1)]=lev

        s=Submaster.Submaster(subname,leveldict=leveldict)

        s.save()

    def loadsub(self, subname):

        """puts a sub into the levels, replacing old level values"""

        s=Submaster.Submasters(showconfig.getGraph()).get_sub_by_name(subname)

        self.set_levels(s.get_dmx_list())

        dispatcher.send("levelchanged")

    def toDmxLevels(self):

        # the dmx levels we edit and output, range is 0..1 (dmx chan 1 is

        # the 0 element)

        out = {}

        for lev in self.levelbox.levels:

            out[lev.channelnum] = lev.currentlevel

    def set(self, text):

        self.entry.delete(0, 'end')

        self.entry.insert(0, text)

#############################

if __name__ == "__main__":

    parser = OptionParser(usage="%prog [subname]")

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

                      help="don't save/restore window geometry")

    opts, args = parser.parse_args()

    root=tk.Tk()

    root.config(bg='black')

    root.tk_setPalette("#004633")

    if not opts.no_geometry:

    graph = SyncedGraph("subcomposer")

    sc.pack()

    tk.Label(root,text="Bindings: B1 adjust level; B2 set full; B3 instant bump",

             font="Helvetica -12 italic",anchor='w').pack(side='top',fill='x')

    if len(args) == 1:

        root.config(bg='green') # trying to make these look distinctive

        sc.loadsub(args[0])

        sc.fill_both_boxes(args[0])

    task.LoopingCall(sc.sendupdate).start(1)

    tksupport.install(root,ms=10)

    prof.run(reactor.run, profile=False)