'''Baby, there won't be no next time'''

class NextTime:

    def __init__(self, nextclock, interval=None)

        self.nextclock = nextclock

        self.interval = interval

    def cylic(self):

        return interval is not None

class DMX(list):

    """the signal that goes on a real-life dmx wire. it's up to 512

    un-named channels each with a 8-bit value on each channel. this type

    is useful for a DMXOut node or DMXLevelDisplay node. the channels are

    stored in a python list where the first channel is at index 0. the

    first channel in dmx terminology would be called channel 1."""

    def __init__(self,dmxlevels):

        if len(dmxlevels)>512:

            raise TypeError("DMX objects can't have more than 512 channels")

        list.extend(dmxlevels) # list.__init__ did't work right

    def append(self,level):

        if len(self)==512:

            raise TypeError("DMX objects can't have more than 512 channels")

        list.append(self,level)

    def extend(self,levels):

        if len(self)+len(levels)>512:

            raise TypeError("DMX objects can't have more than 512 channels")

        list.extend(self,levels)

    def __setslice__(self,i,j,seq):

        newlength = len(self)-(max(0,j)-max(0,i))+len(seq)

        # we could check if newlength>512, but any length-changing slice is

        # probably wrong for this datatype

        if newlength!=len(self):

            raise NotImplementedError("Different-length setslice would disturb DMX channels")

        list.__setslice__(self,i,j,seq)

###

"""

Snippet 0x93.2b: example of outputting a special type

class DMXLevel(float):

  def __init__(self,f):

    self.value = min(max(0,f),255)

  ...

  def __get__(...) # maybe

output.dmxlevel = DMXLevel(300)

>>> print output.dmxlevel

    255

dmxlevel = DMXLevel(3)

dmxlevel += 800

d = d + 800

There's yer problem:

http://python.org/doc/current/ref/numeric-types.html#l2h-152

"""

'''Internal class for StateManager'''

# warning: pseduocode

class NodeInstance:

    ip_addr?

    get_this_nodes_url()

    type = the node type (a subclass of Node)

        ops (get from type)

    input,output = the ports that are created for the node instance

    state = associated state

"""each node descends from this base class"""

class NodeType:

    def __init__(self):

        """TBD"""

        self.ops = Ops()

        ''' maybe

        self.iports = []

        self.oports = []

        self.params = []

        '''

    def get_state(self, stateaccess):

        """This is similar to the pickle.__getstate__ method, except

        we need this alternate version in order to give the node

        (which holds no state) access to its instance's state.

        If your node keeps some transient items in its state dict

        (such as a buffer of recently received inputs), it may want to

        return a copy of the state dict without those items. set_state

        should restore them properly (if they're missing from the

        current state, which they might not be).

        get_state might be called at any time, and it's certainly not

        guaranteed that the node instance is going out of service.

        get_state might get called to checkpoint the nodes for a

        backup, for example. set_state might also get called anytime.

        """

        return stateaccess

    def set_state(self, stateaccess, dict):

        """dict (named after the pickle.__setstate__ argument) is

        always a value that was previously returned from

        get_state. Don't adjust the current nodetype's state, of course;

        use dict to update stateaccess.  If there were elements

        missing from dict (see the note in get_state for why this

        might be the case), you should restore them here as

        appropriate.

        """        

        stateaccess.update(dict)

    def get_default_params(self):

        '''Returns dictionary of param names and DataType instances.  DataTypes 

        can be given values'''

        return {}

    def get_default_ports(self):

        '''Returns pinless port objects'''

        return {}

"""delay node outputs the input a fixed time later"""

class DelayOps(Ops):

    def clocked(self, input, output, stateaccess):

        stateaccess.buffer

class Delay(Node):

    def __init__(self):

        Node.__init__(self)

    def getnodeparams(self):

        return {'delay':State.Time}

class ops(Ops):

    def changed(self, input, output, stateaccess):

        input.dmx

class DMXOut(Node):

    def get_default_ports(self):

        return {'dmx':InputPort(DMX,required=1,maxpins=1)}

    def get_default_params(self):

        return {'outputrefresh':NextTime,'outputdevice':DMXDevice}

"""node that performs a simple gamma (exp) function on its input"""

class GammaOps(Ops):

    def started(self, input, output, stateaccess):

        self.startmeup(stateaccess)

    def changed(self, input, output, stateaccess):

        port.output = port.input ** stateaccess.gamma + stateaccess.offset

        stateaccess.lastvalue = State.FloatingPoint(port.input)

        output = gamma(input)

    # no timed function

    def startmeup(self, stateaccess):

        # whatever

        pass

class Gamma(Node):

    def __init__(self):

        Node.__init__(self)

        self.node_params = {'gamma':State.FloatingPoint,'offset':State.FloatingPoint}

        self.ops = GammaOps()

    def getnodeparams(self):

        return self.node_params

    def getports(self):

        return (Port('a', optional=1),

                Port('b'))

    def __str__(self):

        return "3"

world.register_node(Gamma)

"""node that generates a sine wave"""

class SineGenerator(Node):

    def op(self, input, output, stateaccess):

        # input and output have names

        output.sin = stateaccess.magnitude * math.sin(stateaccess.phase+input.time)

        """

        # dict-style access for names with spaces

        output['sin'] = input['ti me']

        # underscore magic for accessing names with spaces-- the port object makes

        # this work

        output.sin=input.ti_me

        input.time = input.money

        """

    def getports(self):

        return OutputPort('sin'), InputPort('time'), InputPort('money')

"""each node type has an Op within it"""

class Op:

    """nodes can have several versions of their operation function.

    ops don't return anything! 

    """

    def __init__(self):

        """This should not be overridden without being called."""

        pass

    def inputschanged(self, input, output, stateaccess):

        """If you only define one op function body, make it this one. """

        pass

    def created(self, input, output, stateaccess):

        """This is called one time when the node is newly created. It's

        not called when the node instance is pickled/unpickled. Use this

        version to initialize state."""

        # an extra call to changed() should help the outputs get set

        # correctly before any real inputs-changed events come around

        # (assuming this method doesn't get overridden with a

        # specialized version)

        self.inputschanged(input, output, stateaccess)        

    def statechanged(self, input, output, stateaccess):

        '''State might have been changed by a user dragging a parameter or by

        a state being hcanged otherwise.'''

        self.inputschanged(input, output, stateaccess)        

    def clocked(self, input, output, stateaccess):

        self.inputschanged(input, output, stateaccess)        

from nodetypes import DiscoType

ANY = -1

class Port:

    def __setattr__(self, key, value):

        '''Alias for __setitem___'''

        self[key] = value

    def __setitem__(self, key, value):

        pass

    def __getattr__(self, key):

        '''Alias for __getitem___'''

        return self[key]

    def __getitem__(self, key):

        pass

class InputPort(Port):

    def __init__(self, allowedtype, required=1, maxpins=ANY):

        self.pins = []

class OutputPort(Port):

    def __init__(self):

        self.pins = []

class Pin:

    def __init__(self, connection, value=DiscoType):

        pass

'''

Snippet Pi=3: RFC 2: New port semantics

# an example of the max node's op

def changed(self, inputs):

    # note how this function does not use stateaccess, as it doesn't use state

    return max(inputs.values())

# so, how the heck does this work?

# we check the function to get the names of kw args in the function.

# we always pass self, but everything else is optional

# the node asked for inputs, which looks like this:

# inputs = {'portname' : PortObj, 'portname2', PortObj}

# somehow, the PortObjs are max'ible.

# the node has only one output so it can just return the value to set the 

# output.  (maybe)

# alteratively, if we decide that you always return a new dict of outputs:

# return {'outputportname' : max(inputs.values())}

# which isn't horrible, but not great

# another example: an adder.  the node has ports A and B, and an output C:

# C also gets capped at stateaccess[min].

def changed(self, a, b, c, stateaccess):

    c.set(max(stateaccess['min'], a + b))

    return {}

# or:

def changed(self, a, b, stateaccess):

    c = max(stateaccess['min'], a + b)

    return {'c' : c}

# which i think is clearer.  doing all port changes at the end has some

# book-keeping advantages (we can detect easily which ports are changed)

# the counter node could work this way:

def changed(self, someoutput):

    return {'someoutput' : someoutput + 1}

'''

'''

type 1: a, b, d, e

type 2: b, c, d, f

conversion maps:

a -> [ ]

b -> b

d -> d

e -> f

'''

''' Database of NodeInstances, part of the Core '''

# this will be hard to write until NodeInstances are written, but I'll try

# anyway

__version__ = "$Id: StateManager.py,v 1.1 2002/07/04 00:21:35 drewp Exp $"

class StateManager:

    '''StateManager is the second of the core to be built.  It should be 

       after the network, then the scheduler.

       After StateManager is constructed, you probably want to do load_state().

       All of the above is taken care of by the Core module.

       Also, in general, 'name' indicates the name of a node, in NRL

       (like URL) syntax:

       node:group/innergroup/node

       or

       node:node

       if node is in the top level group (the root, or universe, or whatever

        you want to call it

    '''

    def __init__(self, network):

        '''Sets up some dicts, maybe'''

        # need some storage locations, etc.

        self.network = network

    def save_state(self):

        '''Save state to disk'''

        pass

    def load_state(self):

        '''Load state from disk'''

        pass

    def get_input_names(self, name):

        '''Get the names of the nodes which are inputs to a node'''

        pass

    def get_output_names(self, name):

        '''Get the names of the nodes which are outputs to a node'''

        pass

# taken from SnackMix -- now that's reusable code

from Tix import *

import time

class Fadable:

    """Fading mixin: must mix in with a Tk widget (or something that has

    'after' at least) This is currently used by VolumeBox and MixerTk.

    It's probably too specialized to be used elsewhere, but could possibly

    work with an Entry or a Meter, I guess.

    var is a Tk variable that should be used to set and get the levels.

    If use_fades is true, it will use fades to move between levels.

    If key_bindings is true, it will install these keybindings:

    Press a number to fade to that amount (e.g. '5' = 50%).  Also,

    '`' (grave) will fade to 0 and '0' will fade to 100%.

    If mouse_bindings is true, the following mouse bindings will be

    installed: Right clicking toggles muting.  The mouse wheel will

    raise or lower the volume.  Shift-mouse wheeling will cause a more

    precise volume adjustment.  Control-mouse wheeling will cause a

    longer fade."""

    def __init__(self, var, wheel_step=5, use_fades=1, key_bindings=1,

                 mouse_bindings=1):

        self.use_fades = use_fades # whether increase and decrease should fade

        self.wheel_step = wheel_step # amount that increase and descrease should

                                     # change volume (by default)

        self.fade_start_level = 0

        self.fade_end_level = 0

        self.fade_start_time = 0

        self.fade_length = 1

        self.fade_step_time = 10

        self.fade_var = var

        self.fading = 0 # whether a fade is in progress

        if key_bindings:

            for k in range(1, 10):

                self.bind("<Key-%d>" % k,

                    lambda evt, k=k: self.fade(k / 10.0))

            self.bind("<Key-0>", lambda evt: self.fade(100))

            self.bind("<grave>", lambda evt: self.fade(0))

            # up / down arrows

            self.bind("<Key-Up>", lambda evt: self.increase())

            self.bind("<Key-Down>", lambda evt: self.decrease())

        if mouse_bindings:

            # right mouse button toggles muting

            # self.bind('<3>', lambda evt: self.toggle_mute())

            # "NOT ANY MORE!" - homer

            # mouse wheel

            self.bind('<4>', lambda evt: self.increase())

            self.bind('<5>', lambda evt: self.decrease())

            # modified mouse wheel

            self.bind('<Shift-4>', lambda evt: self.increase(multiplier=0.2))

            self.bind('<Shift-5>', lambda evt: self.decrease(multiplier=0.2))

            self.bind('<Control-4>', lambda evt: self.increase(length=1))

            self.bind('<Control-5>', lambda evt: self.decrease(length=1))

        self.last_level = 0 # used for muting

    def fade(self, value, length=0.5, step_time=10):

        """Fade to value in length seconds with steps every step_time

        seconds"""

        self.fade_start_time = time.time()

        self.fade_length = length

        self.fade_start_level = self.fade_var.get()

        self.fade_end_level = value

        self.fade_step_time = step_time

        if not self.fading:

            self.fading = 1

            self.do_fade()

    def do_fade(self):

        """Actually performs the fade for Fadable.fade.  Shouldn't be called

        directly."""

        now = time.time()

        elapsed = now - self.fade_start_time

        complete = elapsed / self.fade_length

        complete = min(1.0, complete)

        diff = self.fade_end_level - self.fade_start_level

        newlevel = (complete * diff) + self.fade_start_level

        self.fade_var.set(newlevel)

        if complete < 1:

            self.after(self.fade_step_time, self.do_fade)

        else:

            self.fading = 0

    def increase(self, multiplier=1, length=0.3):

        """Increases the volume by multiplier * wheel_step.  If use_fades is

        true, it do this as a fade over length time."""

        amount = self.wheel_step * multiplier

        if self.fading:

            newlevel = self.fade_end_level + amount

        else:

            newlevel = self.fade_var.get() + amount

        newlevel = min(100, newlevel)

        self.set_volume(newlevel, length)

    def decrease(self, multiplier=1, length=0.3):

        """Descreases the volume by multiplier * wheel_step.  If use_fades

        is true, it do this as a fade over length time."""

        amount = self.wheel_step * multiplier

        if self.fading:

            newlevel = self.fade_end_level - amount

        else:

            newlevel = self.fade_var.get() - amount

        newlevel = max(0, newlevel)

        self.set_volume(newlevel, length)

    def set_volume(self, newlevel, length=0.3):

        """Sets the volume to newlevel, performing a fade of length if

        use_fades is true."""

        if self.use_fades:

            self.fade(newlevel, length=length)

        else:

            self.fade_var.set(newlevel)

    def toggle_mute(self):

        """Toggles whether the volume is being muted."""

        curlevel = self.fade_var.get()

        if curlevel:

            newlevel = 0

            self.last_level = curlevel

            self['bg'] = 'red' # TODO: let them choose these colors

        else:

            newlevel = self.last_level

            self['bg'] = 'lightGray'

        self.fade_var.set(newlevel)

if __name__ == "__main__":

    class SubScale(Scale, Fadable):

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

            self.scale_var = DoubleVar()

            kw['variable'] = self.scale_var

            Scale.__init__(self, master, *args, **kw)

            Fadable.__init__(self, var=self.scale_var)

    root = Tk()

    root.tk_focusFollowsMouse()

    ss = SubScale(root, from_=100, to_=0,)

    ss.pack()

    mainloop()

from Tix import *

from time import time,sleep

from __future__ import division

class Mass:

    def __init__(self):

        self.x=0 # position

        self.xgoal=0 # position goal

        self.v=0 # velocity

        self.maxspeed = .8 # maximum speed, in position/second

        self.maxaccel = 3 # maximum acceleration, in position/second^2

        self.eps = .03 # epsilon - numbers within this much are considered the same

        self._lastupdate=time()

        self._stopped=1

    def equal(self,a,b):

        return abs(a-b)<self.eps

    def stop(self):

        self.v=0

        self.xgoal=self.x

        self._stopped=1

    def update(self):

        t0 = self._lastupdate

        tnow = time()

        self._lastupdate = tnow

        dt = tnow-t0

        self.x += self.v*dt

        # hitting the ends stops the slider

        if self.x>1: self.v=max(self.v,0); self.x=1

        if self.x<0: self.v=min(self.v,0); self.x=0

        if self.equal(self.x,self.xgoal):

            self.x=self.xgoal # clean up value

            self.stop()

            return

        self._stopped=0

        dir = (-1.0,1,0)[self.xgoal>self.x]

        if abs(self.xgoal-self.x) < abs(self.v*5*dt):

            # apply the brakes on the last 5 steps

            dir *= -.5

        self.v += dir*self.maxaccel*dt # velocity changes with acceleration in the right direction

        self.v = min(max(self.v,-self.maxspeed),self.maxspeed) # clamp velocity

        #print "x=%+.03f v=%+.03f a=%+.03f %f" % (self.x,self.v,self.maxaccel,self.xgoal)

    def goto(self,newx):

        self.xgoal=newx

    def ismoving(self):

        return not self._stopped

class FlyingFader(Frame):

    def __init__(self, master, variable, label, fadedur=1.5, font=('Arial', 8), labelwidth=12,

                 **kw):

        Frame.__init__(self, master)

        self.name = label

        self.variable = variable

        self.mass = Mass()

        self.config({'bd':1, 'relief':'raised'})

        scaleopts = {'variable' : variable, 'showvalue' : 0, 'from' : 1.0,

                     'to' : 0, 'res' : 0.001, 'width' : 20, 'length' : 200, 'orient':'vert'}

        scaleopts.update(kw)

        if scaleopts['orient']=='vert':

            side1=TOP

            side2=BOTTOM

        else:

            side1=RIGHT

            side2=LEFT

        self.scale = Scale(self, **scaleopts)

        self.vlabel = Label(self, text="0.0", width=6, font=font)

        self.label = Label(self, text=label, font=font, anchor='w',width=labelwidth) #wraplength=40, )

        self.oldtrough = self.scale['troughcolor']

        self.scale.pack(side=side2, expand=1, fill=BOTH, anchor='c')

        self.vlabel.pack(side=side2, expand=0, fill=X)

        self.label.pack(side=side2, expand=0, fill=X)

        for k in range(1, 10):

            self.scale.bind("<Key-%d>" % k, 

                lambda evt, k=k: self.newfade(k / 10.0, evt))

        self.scale.bind("<Key-0>", lambda evt: self.newfade(1.0, evt))

        self.scale.bind("<grave>", lambda evt: self.newfade(0, evt))

        self.scale.bind("<1>", self.cancelfade)

        self.scale.bind("<2>", self.cancelfade)

        self.scale.bind("<3>", self.mousefade)

        self.trace_ret = self.variable.trace('w', self.updatelabel)

        self.bind("<Destroy>",self.ondestroy)

    def ondestroy(self,*ev):

        self.variable.trace_vdelete('w',self.trace_ret)

    def cancelfade(self, evt):

        self.fadegoal = self.variable.get()

        self.fadevel = self.fadeacc = 0

        self.scale['troughcolor'] = self.oldtrough

    def mousefade(self, evt):

        target = float(self.tk.call(self.scale, 'get', evt.x, evt.y))

        self.newfade(target, evt)

    def ismoving(self):

        return self.fadevel!=0 or self.fadeacc!=0

    def newfade(self, newlevel, evt=None, length=None):

        # these are currently unused-- Mass needs to accept a speed input

        mult = 1

        if evt.state & 8 and evt.state & 4: mult = 0.25 # both

        elif evt.state & 8: mult = 0.5 # alt

        elif evt.state & 4: mult = 2   # control

        self.mass.x = self.variable.get()

        self.mass.goto(newlevel)

        self.gofade()

    def gofade(self):

        self.mass.update()

        self.variable.set(self.mass.x)

        if not self.mass.ismoving():

            self.scale['troughcolor'] = self.oldtrough

            return

        # blink the trough while the thing's moving

        if time()%.4>.2:

            # self.scale.config(troughcolor=self.oldtrough)

            self.scale.config(troughcolor='orange')

        else:

            # self.scale.config(troughcolor='white')

            self.scale.config(troughcolor='yellow')

#        colorfade(self.scale, percent)

        self.after(30, self.gofade)

    def updatelabel(self, *args):

        if self.variable:

            self.vlabel['text'] = "%.3f" % self.variable.get()

#        if self.fadetimes[1] == 0: # no fade

#            self.vlabel['fg'] = 'black'

#        elif self.curfade[1] > self.curfade[0]:

#            self.vlabel['fg'] = 'red'

#        else:

#            self.vlabel['fg'] = 'blue'

    def get(self):

        return self.scale.get()

    def set(self, val):

        self.scale.set(val)

def colorfade(scale, lev):

    low = (255, 255, 255)

    high = (0, 0, 0)

    out = [int(l+lev*(h-l)) for h, l in zip(high,low)]

    col="#%02X%02X%02X" % tuple(out)

    scale.config(troughcolor=col)

if __name__ == '__main__':

    root = Tk()

    root.tk_focusFollowsMouse()

    FlyingFader(root, variable=DoubleVar(), label="suck").pack(side=LEFT, 

        expand=1, fill=BOTH)

    FlyingFader(root, variable=DoubleVar(), label="moof").pack(side=LEFT,

        expand=1, fill=BOTH)

    FlyingFader(root, variable=DoubleVar(), label="zarf").pack(side=LEFT,

        expand=1, fill=BOTH)

    FlyingFader(root, variable=DoubleVar(), 

        label="long name goes here.  got it?").pack(side=LEFT, expand=1, 

        fill=BOTH)

    root.mainloop()

'''

        up

        |\________

       / \_      /\

      /    \   /   \

   d1        d2    d3

   up has a single output that outputs {d1 : .8, d2:0.1}

'''

DM DP Name

-1 -1 Nodiverse

-0 -1 Nodity or "Hardcore Nodity"

+0 -1 Noditivity

-1 +0 Lightland

+0 +1 everything's under control (EVAC would be a funny abbrev, but it doesn't

            work - maybe EVerything's Unda Control)

+0 -1 Nodeworks

-1 +0 OpenNode, FreeNode, etc.

      OpenDMX (for DMXd maybe)