songlist = buildsonglist(root, graph, songs, player)

    songlist.pack(fill='both',exp=1)

    seeker = Seeker(root, player)

    goRow = tk.Frame(root)

    tk.Label(goRow, text="Go button action",

             font='arial 9', **appstyle).pack(side='left', fill='both')

    goStatus = tk.Label(goRow, font='arial 12 bold', **appstyle)

    goStatus.config(bg='#800000', fg='white', relief='ridge')

    goStatus.pack(side='left', expand=True, fill='x')

    buts = ControlButtons(root, go, player, root)

    songlist.pack(fill='both', expand=True)

    buts.pack(side='top', fill='x')

    seeker.pack(side='top', fill='x')

    goRow.pack(side='top', fill='x')

    player.state.trace_variable('w', buts.update_state_buttons)

    buts.update_state_buttons()

    tksupport.install(root,ms=10)

"""

from __future__ import division

import xmlrpclib,time,socket,sys,textwrap,math,glob,random,os,optparse

from bisect import bisect_left,bisect,bisect_right

import Tkinter as tk

try:

    from dispatch import dispatcher

except ImportError:

    import louie as dispatcher 

from twisted.internet import reactor,tksupport

import twisted

from twisted.web.xmlrpc import Proxy

import logging

log = logging.getLogger()

logging.basicConfig(format="%(asctime)s %(levelname)-5s %(name)s %(filename)s:%(lineno)d: %(message)s")

log.setLevel(logging.DEBUG)

import run_local

from light9 import Submaster, dmxclient, networking, showconfig

from light9.TLUtility import make_attributes_from_args, dict_subset

from light9.zoomcontrol import Zoomcontrol

from light9.curve import Curve, Curveview, Curveset, Curvesetview

from light9.wavelength import wavelength

from light9.uihelpers import toplevelat

import light9.Effects

fx_dict = light9.Effects.__dict__

all_fx = fx_dict['__all__']

expr_helpers = dict_subset(fx_dict, all_fx)

del fx_dict

del all_fx

class Music:

    def __init__(self):

        self.player=None # xmlrpc Proxy to player

        self.recenttime=0

        self.cur_row = 0

        self.cur_col = 0

        self.ncols = 2

    def add_subtermview(self, stv):

        stv.grid(row=self.cur_row, column=self.cur_col, sticky='news')

        self.columnconfigure(self.cur_col, weight=1)

        self.cur_col += 1

        self.cur_col %= self.ncols

        if self.cur_col == 0:

            self.cur_row += 1

    if expr is None:

        expr = '%s(t)' % subname

    subterms.append(term)

    stv=Subtermview(ssv,term)

    # stv.pack(side='top',fill='x')

    ssv.add_subtermview(stv)

    return term

def sub_commands_tk(master, curveset, subterms, root, ssv):

    f=tk.Frame(master,relief='raised',bd=1)

    newname = tk.StringVar()

    def reload_subs():

        dispatcher.send('reload all subs')

    tk.Button(f, text="reload subs (C-r)", 

        command=reload_subs).pack(side='left')

    tk.Label(f, text="new subterm named:").pack(side='left')

    entry = tk.Entry(f, textvariable=newname)

    entry.pack(side='left', fill='x', exp=1)

    entry.bind("<Key-Return>", lambda evt: add_cmd())

    return f

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

root=tk.Tk()

root.tk_setPalette("gray50")

toplevelat("curvecalc",root)

root.tk_focusFollowsMouse()

parser = optparse.OptionParser()

options,args = parser.parse_args()

try:

except IndexError:

    raise SystemExit("song name is required, e.g. '05-mix'")

log.debug("music")

music=Music()

zc = Zoomcontrol(root)

zc.pack(side='top',fill='x')

curveset = Curveset()

csv = Curvesetview(root,curveset)

csv.pack(side='top',fill='both',exp=1)

ssv = SubtermSetView(root)

ssv.pack(side='top', fill='x')

maxtime = wavelength(musicfilename)

dispatcher.send("max time",maxtime=maxtime)

dispatcher.connect(lambda: maxtime, "get max time",weak=0)

curveset.load(basename=os.path.join(showconfig.curvesDir(),song))

subterms = []

sub_commands_tk(root, curveset, subterms, root, ssv).pack(side='top',fill='x')

log.debug("output")

out = Output(subterms, music)

def savekey(*args):

    print "saving",song

    savesubterms(showconfig.subtermsForSong(song),subterms)

    curveset.save(basename=os.path.join(showconfig.curvesDir(),song))

    print "saved"

root.bind("<Control-Key-s>",savekey)

root.bind("<Control-Key-r>", lambda evt: dispatcher.send('reload all subs'))

from rdflib.Graph import Graph

from rdflib import RDFS, Literal, BNode

from light9.namespaces import L9, XSD

from light9.TLUtility import dict_scale, dict_max

from light9 import Patch, showconfig

try:

    import dispatch.dispatcher as dispatcher

except ImportError:

    from louie import dispatcher

class Submaster:

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

        self.name = name

        self.temporary = temporary

        if leveldict:

            self.levels = leveldict

        else:

            self.levels = {}

            self.reload(quiet=True)

        if not self.temporary:

            dispatcher.connect(self.reload, 'reload all subs')

    def reload(self, quiet=False):

        if self.temporary:

            return

        try:

            oldlevels = self.levels.copy()

            self.levels.clear()

            patchGraph = showconfig.getGraph()

            graph = Graph()

            graph.parse(showconfig.subFile(self.name), format="nt")

            subUri = L9['sub/%s' % self.name]

            for lev in graph.objects(subUri, L9['lightLevel']):

                chan = graph.value(lev, L9['channel'])

                val = graph.value(lev, L9['level'])

            return

        levels = list(levels) + [0]

        # if levels[14] > 0: levels[14] = 100 # non-dim

        self.parport.outstart()

        for p in range(1, self.dimmers + 2):

            self.parport.outbyte(levels[p-1]*255 / 100)

class UsbDMX(BaseIO):

    dimmers = 512

    def __init__(self):

        BaseIO.__init__(self)

        sys.path.append("/home/drewp/dmx_usb_module")

        from dmx import Dmx

        self.out = Dmx()

    def sendlevels(self, levels):

        if self.dummy:

            return

        packet = ''.join([chr(int(lev * 255 / 100)) for lev in levels]) + "\x55"

        self.out.write(packet)

class SerialPots(BaseIO):

    """

# my intent was to pull these from a file in the LIGHT9_SHOW/ directory

def dmxServerUrl():

    #host = os.getenv('DMXHOST', 'localhost')

    #url = "http://%s:8030" % host

    return "http://localhost:%s" % dmxServerPort()

def dmxServerPort():

    return 8030

def musicUrl():

def musicPort():

    return 8040

def mpdServer():

    """servername, port"""

    return os.getenv('LIGHT9_MPD_SERVER', 'dash'),6600

def kcPort():

    return 8050

def kcServer():