#!/usr/bin/python

import sys, time

from twisted.web import xmlrpc, server

from Tix import *

import pickle

import run_local

from light9.Fadable import Fadable

from light9.Submaster import Submasters, sub_maxes

from light9.subclient import SubClient

from light9 import dmxclient, showconfig

from light9.uihelpers import toplevelat

nudge_keys = {

    'up' : list('qwertyuiop'),

    'down' : list('asdfghjkl')

}

nudge_keys['down'].append('semicolon')

class SubScale(Scale, Fadable):

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

        self.scale_var = kw.get('variable') or DoubleVar()

        kw.update({'variable' : self.scale_var,

                   'from' : 1, 'to' : 0, 'showvalue' : 0,

                   'sliderlength' : 15, 'res' : 0.01,

                   'width' : 40, 'troughcolor' : 'black', 'bg' : 'grey40',

            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 \

            for sub, level in self.get_levels().items()]

        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.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

if __name__ == "__main__":

    s = Submasters()

    root = Tk()

    tl = toplevelat("Keyboard Composer", existingtoplevel=root)

    kc = KeyboardComposer(tl, s)

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

    ls = LevelServer(kc.name_to_subtk)

    reactor.listenTCP(8050, server.Site(ls))

    root.protocol('WM_DELETE_WINDOW', reactor.stop)

    tksupport.install(root,ms=10)

    reactor.run()