#!/usr/bin/env python

# vi: syntax=python

import run_local

from light9.Submaster import combine_subdict

class circcycle:

    """Like itertools.cycle, but with a prev() method too.  You lose

    all iterator benefits by using this, since it will store the whole

    sequence/iterator in memory.  Also, do not run this on an infinite

    iterator, as it tuple'ifies the input."""

    def __init__(self, sequence):

        self.sequence = tuple(sequence)

        self.index = 0

    def __iter__(self):

        return self

    def change_index(self, delta):

        self.index = (self.index + delta) % len(self.sequence)

    def next(self):

        ret = self.sequence[self.index]

        self._change_index(1)

        return ret

    def prev(self):

        ret = self.sequence[self.index]

        self._change_index(-1)

        return ret

    """Simple controller with minimal input and output:

    Input is 4 directions and 3 buttons.

    Output is an integer and a color and maybe more.

    Left + B1/right + B1: prev/next sub

    Y-axis + B2: set current level

    B3: toggle keep/solo mode

    Double-B3: clear kept levels"""

    def __init__(self, subnames):

        self.subnames = subnames

        self.refresh()

    def refresh(self):

        # reload subs from disk

        self.submasters = Submasters()

        self.all_subs = circcycle(self.subnames)

        self.current_sub = self.all_subs.next()

        self.current_level = 1.0

        self.kept_levels = {} # subname : level [0..1]

        self.keep_solo_mode = 'keep' # either 'keep' or 'solo'

    def clear_kept_levels(self):

        self.kept_levels.clear()

    def next(self):

        if self.keep_solo_mode == 'keep':

            self.kept_levels[self.current_sub] = self.current_level

        self.current_sub = self.submasters.get_sub_by_name(self.all_subs.next())

    def prev(self):

        if self.keep_solo_mode == 'keep':

            self.kept_levels[self.current_sub] = self.current_level

        self.current_sub = self.submasters.get_sub_by_name(self.all_subs.prev())

    def get_levels_as_sub(self):

        if self.keep_solo_mode == 'keep':

            # send all levels in self.kept_levels

        else:

if __name__ == "__main__":

    if 0:

        x = range(20)

        for z in circcycle(x):

            print z

#!/usr/bin/python

from __future__ import division,nested_scopes

import sys, time

from twisted.internet import reactor,tksupport

from twisted.web import xmlrpc, server

from Tix import *

import run_local

from light9.Fadable import Fadable

from light9.Submaster import Submasters, sub_maxes

from light9 import dmxclient, showconfig

from light9.uihelpers import toplevelat

nudge_keys = {

    'up' : list('qwertyuiop'),

    'down' : list('asdfghjkl')

}

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

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

        self.slider_var = DoubleVar()

        self.slider_var.set(current_level)

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

        namelabel = Label(self, text=name, font="Arial 11", bg='black',

            fg='white')

        namelabel.pack(side=TOP)

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

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

        levellabel.pack(side=TOP)

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

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

        self.submasters = submasters

        self.current_sub_levels = {}

        if current_sub_levels:

            self.current_sub_levels = current_sub_levels

        else:

            try:

                self.current_sub_levels = \

                    pickle.load(file('.keyboardcomposer.savedlevels'))

            except IOError:

                pass

        self.draw_ui()

        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.current_sub_levels = \

            pickle.load(file('.keyboardcomposer.savedlevels'))

        for r in self.rows:

            r.destroy()

        self.keyhints.destroy()

        self.buttonframe.destroy()

        self.draw_ui()

class LevelServer(xmlrpc.XMLRPC):

            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.pack(fill=BOTH, expand=1)

    ls = LevelServer(kc.name_to_subtk)

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

    root.bind("<Destroy>",reactor.stop)

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

    reactor.addSystemEventTrigger('after','shutdown',kc.save)

    tksupport.install(root,ms=10)

    reactor.run()