#!/usr/bin/python

"""

todo: curveview should preserve more objects, for speed maybe

"""

from __future__ import division

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

from bisect import bisect_left,bisect,bisect_right

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

    ssv.add_subtermview(stv)

    return term

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

    newname = tk.StringVar()

    def add_cmd():

        newname.set('')

    def reload_subs():

        dispatcher.send('reload all subs')

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

def add_subterms_for_song(graph, song, curveset, subterms, root, ssv):

    for st in graph.objects(song, L9['subterm']):

        add_one_subterm(graph, graph.value(st, L9['sub']), curveset, subterms,

                        root, ssv, graph.value(st, L9['expression']))

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

root=tk.Tk()

root.tk_setPalette("gray50")

toplevelat("curvecalc",root)

root.tk_focusFollowsMouse()

root.title("Curvemaster 3000MX - %s" % graph.label(song))

musicfilename = showconfig.songOnDisk(song)

maxtime = wavelength(musicfilename)

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

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

subterms = []

add_subterms_for_song(graph, song, curveset, subterms, root, ssv)

log.debug("output")

out = Output(subterms, music)

def savekey(*args):

    print "saving",song

    print "saved"

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

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

create_status_lines(root)

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

        self.save_stage_button.pack(side=LEFT)

        self.sub_name = Entry(self.buttonframe, bg='black', fg='white')

        self.sub_name.pack(side=LEFT)

        self.stop_frequent_update_time = 0

    def make_key_hints(self):

        keyhintrow = Frame(self)

        col = 0

        for upkey, downkey in zip(nudge_keys['up'],

    def __init__(self, master, levelboxopts=None, dmxdummy=0, numchannels=68,

        use_persistentlevels=0):

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

        self.dmxdummy = dmxdummy

        self.numchannels = numchannels

        self.levelbox = Levelbox(self, num_channels=numchannels)

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

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

        # the 0 element)

        self.levelbox.setlevels(self.levels)

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

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

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

        def alltozero():

            self.set_levels([0] * self.numchannels)

            dispatcher.send("levelchanged")

    def levelchanged(self, channel=None, newlevel=None):

        if channel is not None and newlevel is not None:

            if channel>len(self.levels):

                return

            self.levels[channel-1]=max(0,min(1,float(newlevel)))

        self.levelbox.setlevels(self.levels)

        leveldict={}

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

            if lev!=0:

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

        s.save()

    def loadsub(self, subname):

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

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

        self.levels[:]=s.get_dmx_list()

        dispatcher.send("levelchanged")

    def sendupdate(self):

        if not self.dmxdummy:

            dmxclient.outputlevels(self.levels)

            self.lastupdate = time.time()

        self.entry.bind("<Return>", self.action)

        tk.Button(self, text=verb, command=self.action).pack(side='left')

    def action(self, *args):

        subname = self.entry.get()

        self.cmd(subname)

    def set(self, text):

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

        self.entry.insert(0, text)

class Submaster:

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

    def __init__(self,

                 name=None,

                 graph=None, sub=None,

        if sub is not None:

            name = graph.label(sub)

        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()

            return

        graph = Graph()

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

        graph.add((subUri, RDFS.label, Literal(self.name)))

        for chan in self.levels.keys():

            lev = BNode()

            graph.add((subUri, L9['lightLevel'], lev))

            graph.add((lev, L9['level'],

                       Literal(self.levels[chan], datatype=XSD['decimal'])))

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

        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():

    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):

        return Submaster("%s*%s" % (self.name, scalar), 

    __rmul__ = __mul__

    def max(self, *othersubs):

        return sub_maxes(self, *othersubs)

    def __repr__(self):

        items = self.levels.items()

        items.sort()

        levels = ' '.join(["%s:%.2f" % item for item in items])

        return "<'%s': [%s]>" % (self.name, levels)

    def get_dmx_list(self):

        leveldict = self.get_levels() # gets levels of sub contents

        for k, v in leveldict.items():

            if v == 0:

                continue

            try:

                dmxchan = Patch.get_dmx_channel(k) - 1

            except ValueError:

                print "error trying to compute dmx levels for submaster %s" % self.name

                raise

            levels[dmxchan] = max(v, levels[dmxchan])

        return levels

    def normalize_patch_names(self):

        """Use only the primary patch names."""

        # possibly busted -- don't use unless you know what you're doing

                                 linear_fade(self.levels.get(k, 0),

                                             otherlevels.get(k, 0),

                                             amount))

        return xfaded_sub

    def __cmp__(self, other):

        return cmp(repr(self), repr(other))

    def __hash__(self):

        return hash(repr(self))

def linear_fade(start, end, amount):

    """Fades between two floats by an amount.  amount is a float between

    0 and 1.  If amount is 0, it will return the start value.  If it is 1,

    the end value will be returned."""

    return level

def sub_maxes(*subs):

    nonzero_subs = [s for s in subs if not s.no_nonzero()]

    name = "max(%s)" % ", ".join([repr(s) for s in nonzero_subs])

    return Submaster(name,

                     temporary=1)

def combine_subdict(subdict, name=None, permanent=False):

    """A subdict is { Submaster objects : levels }.  We combine all

    submasters first by multiplying the submasters by their corresponding

    levels and then max()ing them together.  Returns a new Submaster

        for filename in files:

            # we don't want these files

            if filename.startswith('.') or filename.endswith('~') or \

               filename.startswith('CVS'):

                continue

            self.submasters[filename] = Submaster(filename)

    def get_all_subs(self):

        "All Submaster objects"

        l = self.submasters.items()

        l.sort()

        l = [x[1] for x in l]

        songs = []

class Curveview(tk.Canvas):

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

        self.curve=curve

        self._time = 0

        tk.Canvas.__init__(self,master,width=10,height=10,

                           relief='sunken',bd=1,

                           closeenough=5,takefocus=1, **kw)

        self.selected_points=[] # idx of points being dragged

        self.update_curve()

        # self.bind("<Enter>",self.focus)

     return col

class Onelevel(tk.Frame):

    """a name/level pair"""

    def __init__(self, parent, channelnum):

        """channelnum is 1..68, like the real dmx"""

        self.channelnum=channelnum

        self.currentlevel=0 # the level we're displaying, 0..1

        # 3 widgets, left-to-right:

                               padx=0, pady=0, bd=0, 

                 height=1, bg='black', fg='white')

        self.desc_lab.pack(side='left')

        # current level of channel, shows intensity with color

        self.level_lab = tk.Label(self, width=3, bg='lightBlue',

                                  anchor='e', 

                                  padx=1, pady=0, bd=0, height=1)

        self.level_lab.pack(side='left')

        self.setlevel(0)

        self.setupmousebindings()

    def setupmousebindings(self):

        def b1down(ev):

        dispatcher.send("levelchanged",channel=self.channelnum,newlevel=newlev)

class Levelbox(tk.Frame):

    def __init__(self, parent, num_channels=68):

        tk.Frame.__init__(self,parent)

        global stdfont

        self.levels = [] # Onelevel objects

        rows = 48

        frames = [make_frame(self) for x in range((num_channels // rows) + 1)]

        for channel in range(1, num_channels+1):

            # frame for this channel

            f = Onelevel(frames[channel // rows],channel)

            self.levels.append(f)

            f.pack(side='top')

        #dispatcher.connect(setalevel,"setlevel")