Added pynxc

211 files changed, 17987 insertions, 0 deletions

diff --git a/pynxc/MyDefs.h b/pynxc/MyDefs.h
new file mode 100644
index 0000000..ebbdca6
--- /dev/null
+++ b/pynxc/MyDefs.h
@@ -0,0 +1,69 @@
+#define ULTRASONIC 1
+#define EYES 1
+#define LIGHT 2
+#define SOUND 3
+#define MIC 3
+#define TOUCH 4
+
+#define None 0
+
+
+int SensorTypes[]={0,0,0,0};
+
+
+
+inline int SensorVal(int s_) {
+    
+    s_=s_-1;
+    int t_ = SensorTypes[s_];
+    
+    if (t_==None) {
+        return -1;
+    } else if (t_==ULTRASONIC) {
+        Wait(100);
+        return SensorUS(s_);
+    } else {
+        return Sensor(s_); 
+    }
+    
+}
+
+
+
+void DefineSensors(int s1,int s2,int s3,int s4) {
+    
+    int sa[];
+    int i;
+    
+    ArrayInit(sa,0,4);
+    sa[0]=s1;
+    sa[1]=s2;
+    sa[2]=s3;
+    sa[3]=s4;
+    
+    for (i=0; i<4; i++) {
+    
+        if (sa[i]==None) {
+            SensorTypes[i]=None;
+        } else if (sa[i]==ULTRASONIC) {
+            SetSensorLowspeed(i);
+            SensorTypes[i]=ULTRASONIC;
+        } else if (sa[i]==LIGHT) {
+            SetSensorLight(i);
+            SensorTypes[i]=LIGHT;
+        } else if (sa[i]==SOUND) {
+            SetSensorSound(i);
+            SensorTypes[i]=SOUND;
+        } else if (sa[i]==TOUCH) {
+            SetSensor(i,SENSOR_TOUCH);
+            SensorTypes[i]=TOUCH;
+        }
+
+        
+    
+    
+    }
+    
+    
+}
+    
diff --git a/pynxc/ast_template.py b/pynxc/ast_template.py
new file mode 100644
index 0000000..d5af4d8
--- /dev/null
+++ b/pynxc/ast_template.py
@@ -0,0 +1,372 @@
+#!/usr/bin/env python
+__author__  = ''
+__version__ = (0,0)
+
+import sys
+import compiler.ast
+from compiler.visitor import ASTVisitor
+from compiler import parse, walk
+from compiler.consts import *
+
+class Visitor(ASTVisitor): 
+    def __init__(self,stream=sys.stdout,debug=False):
+        self.v = lambda tree, visitor=self: walk(tree, visitor)
+        self.stream = stream
+        self.strcode = ""
+        self.debug=debug
+        self.indents = 0
+        ASTVisitor.__init__(self)
+
+    def __str__(self):
+        return self.strcode
+    
+    def DEDENT(self):
+        self.indents -=1
+        self.NEWLINE()
+            
+    def INDENT(self):
+        self.indents += 1
+        self.NEWLINE()
+
+    def NEWLINE(self):
+        self.write('\n')
+        self.write(' ' * 4 * self.indents )
+
+    def write(self, data):
+        if self.stream:
+            self.stream.write(data)
+        self.strcode += data
+        
+    def visitBlock(self, block):
+        if self.debug:
+            print 'visitBlock'
+
+    def visitAdd(self, node):
+        if self.debug:
+            print 'visitAdd'
+
+    def visitAnd(self, node):
+        if self.debug:
+            print 'visitAnd'
+
+    def visitAssAttr(self, node):
+        if self.debug:
+            print 'visitAssAttr'
+
+    def visitAssList(self, node):
+        if self.debug:
+            print 'visitAssList'
+
+    def visitAssName(self, node):
+        if self.debug:
+            print 'visitAssName'
+            if node.flags == OP_DELETE:
+                print "del ",
+            print node.name
+        
+
+    def visitAssTuple(self, node):
+        if self.debug:
+            print 'visitAssTuple'
+
+    def visitAssert(self, node):
+        if self.debug:
+            print 'visitAssert'
+
+    def visitAssign(self, node):
+        if self.debug:
+            print 'visitAssign'
+        for i in range(len(node.nodes)):
+            n = node.nodes[i]
+            if self.debug:
+                print "  Node ",n
+            self.v(n)
+        self.v(node.expr)
+
+    def visitAugAssign(self, node):
+        if self.debug:
+            print 'visitAugAssign'
+        self.v(node.node)
+        self.v(node.expr)
+
+    def visitBackquote(self, node):
+        if self.debug:
+            print 'visitBackquote'
+
+    def visitBitand(self, node):
+        if self.debug:
+            print 'visitBitand'
+
+    def visitBitor(self, node):
+        if self.debug:
+            print 'visitBitor'
+
+    def visitBitxor(self, node):
+        if self.debug:
+            print 'visitBitxor'
+
+    def visitBreak(self, node):
+        if self.debug:
+            print 'visitBreak'
+
+    def visitCallFunc(self, node):
+        if self.debug:
+            print 'visitCallFunc'
+            print 'funcname: ',node.node.name
+            
+            
+        self.v(node.node)
+        for i in range(len(node.args)):
+            self.v(node.args[i])
+
+            
+            
+            
+    def visitClass(self, node):
+        if self.debug:
+            print 'visitClass'
+
+    def visitCompare(self, node):
+        if self.debug:
+            print 'visitCompare'
+        self.v(node.expr)
+        for operator, operand in node.ops:
+            self.v(operand)
+
+    def visitConst(self, node):
+        if self.debug:
+            print 'visitConst'
+            print "Const",repr(node.value)
+
+    def visitContinue(self, node):
+        if self.debug:
+            print 'visitContinue'
+
+    def visitDecorators(self, node):
+        if self.debug:
+            print 'visitDecorators'
+
+    def visitDict(self, node):
+        if self.debug:
+            print 'visitDict'
+
+    def visitDiscard(self, node):
+        if self.debug:
+            print 'visitDiscard'
+        self.v(node.expr)
+
+    def visitDiv(self, node):
+        if self.debug:
+            print 'visitDiv'
+
+    def visitFloorDiv(self, node):
+        if self.debug:
+            print 'visitFloorDiv'
+
+    def visitEllipsis(self, node):
+        if self.debug:
+            print 'visitEllipsis'
+
+    def visitExec(self, node):
+        if self.debug:
+            print 'visitExec'
+
+    def visitFor(self, node):
+        if self.debug:
+            print 'visitFor'
+
+    def visitFrom(self, node):
+        if self.debug:
+            print 'visitFrom'
+
+    def visitFunction(self, node):
+        if self.debug:
+            print 'visitFunction'
+        self.v(node.code)
+
+    def visitGenExpr(self, node):
+        if self.debug:
+            print 'visitGenExpr'
+
+    def visitGenExprFor(self, node):
+        if self.debug:
+            print 'visitGenExprFor'
+
+    def visitGetattr(self, node):
+        if self.debug:
+            print 'visitGetattr'
+
+    def visitGlobal(self, node):
+        if self.debug:
+            print 'visitGlobal'
+
+    def visitIf(self, node):
+        if self.debug:
+            print 'visitIf'
+            
+        (c, b) = node.tests[0]
+        self.v(c)
+        self.v(b)
+    
+        for c, b in node.tests[1:]:
+            self.v(c)
+            self.v(b)
+        if node.else_:
+            self.v(node.else_)
+
+    def visitImport(self, node):
+        if self.debug:
+            print 'visitImport'
+
+    def visitInvert(self, node):
+        if self.debug:
+            print 'visitInvert'
+
+    def visitKeyword(self, node):
+        if self.debug:
+            print 'visitKeyword'
+        self.v(node.expr)
+
+    def visitLambda(self, node):
+        if self.debug:
+            print 'visitLambda'
+
+    def visitLeftShift(self, node):
+        if self.debug:
+            print 'visitLeftShift'
+
+    def visitList(self, node):
+        if self.debug:
+            print 'visitList'
+
+    def visitListComp(self, node):
+        if self.debug:
+            print 'visitListComp'
+
+    def visitListCompFor(self, node):
+        if self.debug:
+            print 'visitListCompFor'
+
+    def visitListCompIf(self, node):
+        if self.debug:
+            print 'visitListCompIf'
+
+    def visitMod(self, node):
+        if self.debug:
+            print 'visitMod'
+
+    def visitModule(self, node):
+        if self.debug:
+            print 'visitModule'
+        self.v(node.node)
+
+    def visitMul(self, node):
+        if self.debug:
+            print 'visitMul'
+
+    def visitName(self, node):
+        if self.debug:
+            print 'visitName'
+            print "Name",node.name
+
+    def visitNot(self, node):
+        if self.debug:
+            print 'visitNot'
+
+    def visitOr(self, node):
+        if self.debug:
+            print 'visitOr'
+
+    def visitPass(self, node):
+        if self.debug:
+            print 'visitPass'
+
+    def visitPower(self, node):
+        if self.debug:
+            print 'visitPower'
+
+    def visitPrint(self, node):
+        if self.debug:
+            print 'visitPrint'
+
+    def visitPrintnl(self, node):
+        if self.debug:
+            print 'visitPrintnl'
+
+    def visitRaise(self, node):
+        if self.debug:
+            print 'visitRaise'
+
+    def visitReturn(self, node):
+        if self.debug:
+            print 'visitReturn'
+
+    def visitRightShift(self, node):
+        if self.debug:
+            print 'visitRightShift'
+
+    def visitSlice(self, node):
+        if self.debug:
+            print 'visitSlice'
+
+    def visitStmt(self, node):
+        if self.debug:
+            print 'visitStmt'
+        for n in node.nodes:
+            self.v(n)
+
+    def visitSub(self, node):
+        if self.debug:
+            print 'visitSub'
+
+    def visitSubscript(self, node):
+        if self.debug:
+            print 'visitSubscript'
+
+    def visitTryExcept(self, node):
+        if self.debug:
+            print 'visitTryExcept'
+
+    def visitTryFinally(self, node):
+        if self.debug:
+            print 'visitTryFinally'
+
+    def visitTuple(self, node):
+        if self.debug:
+            print 'visitTuple'
+
+    def visitUnaryAdd(self, node):
+        if self.debug:
+            print 'visitUnaryAdd'
+
+    def visitUnarySub(self, node):
+        if self.debug:
+            print 'visitUnarySub'
+
+    def visitWhile(self, node):
+        if self.debug:
+            print 'visitWhile'
+        self.v(node.test)
+        self.v(node.body)
+        if node.else_:
+            self.v(node.else_)
+
+    def visitYield(self, node):
+        if self.debug:
+            print 'visitYield'
+
+
+        
+def ast2py(ast,debug=True):
+    v = Visitor(debug)
+    v.v(ast)
+    return str(v)
+
+def main():
+    filename = 'test.py'
+    ast = parse(open(filename).read())
+    s = ast2py(ast)
+    return s
+
+if __name__ == "__main__":
+    print main()
diff --git a/pynxc/nxc/.DS_Store b/pynxc/nxc/.DS_Store
new file mode 100644
index 0000000..6e54a94
--- /dev/null
+++ b/pynxc/nxc/.DS_Store
diff --git a/pynxc/nxc/README b/pynxc/nxc/README
new file mode 100644
index 0000000..f17ebad
--- /dev/null
+++ b/pynxc/nxc/README
@@ -0,0 +1,10 @@
+Latest source of NXC can be found here:
+
+http://bricxcc.svn.sourceforge.net/viewvc/bricxcc/
+
+under the MOZILLA PUBLIC LICENSE Version 1.1 (http://bricxcc.svn.sourceforge.net/viewvc/bricxcc/LICENSE)
+
+Latest binaries can be found here:
+
+http://bricxcc.sourceforge.net/nbc/
+
diff --git a/pynxc/nxc/darwin/.DS_Store b/pynxc/nxc/darwin/.DS_Store
new file mode 100644
index 0000000..9789e1c
--- /dev/null
+++ b/pynxc/nxc/darwin/.DS_Store
diff --git a/pynxc/nxc/darwin/nbc b/pynxc/nxc/darwin/nbc
new file mode 100755
index 0000000..2268506
--- /dev/null
+++ b/pynxc/nxc/darwin/nbc
diff --git a/pynxc/nxc/darwin/nxtcom b/pynxc/nxc/darwin/nxtcom
new file mode 100755
index 0000000..da43f95
--- /dev/null
+++ b/pynxc/nxc/darwin/nxtcom
diff --git a/pynxc/nxc/darwin/place_nbc_and_nxtcom_here.txt b/pynxc/nxc/darwin/place_nbc_and_nxtcom_here.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pynxc/nxc/darwin/place_nbc_and_nxtcom_here.txt
diff --git a/pynxc/nxc/linux2/.DS_Store b/pynxc/nxc/linux2/.DS_Store
new file mode 100644
index 0000000..fd25488
--- /dev/null
+++ b/pynxc/nxc/linux2/.DS_Store
diff --git a/pynxc/nxc/linux2/nbc b/pynxc/nxc/linux2/nbc
new file mode 100755
index 0000000..0141c4e
--- /dev/null
+++ b/pynxc/nxc/linux2/nbc
diff --git a/pynxc/nxc/win32/nbc.exe b/pynxc/nxc/win32/nbc.exe
new file mode 100755
index 0000000..0c7962e
--- /dev/null
+++ b/pynxc/nxc/win32/nbc.exe
diff --git a/pynxc/nxc/win32/place_nbc_exe_here.txt b/pynxc/nxc/win32/place_nbc_exe_here.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pynxc/nxc/win32/place_nbc_exe_here.txt
diff --git a/pynxc/pynxc.pyw b/pynxc/pynxc.pyw
new file mode 100755
index 0000000..820fb2a
--- /dev/null
+++ b/pynxc/pynxc.pyw
@@ -0,0 +1,1392 @@
+#!/usr/bin/env python
+from __future__ import with_statement
+
+__author__  = 'Brian Blais <bblais@bryant.edu>'
+__version__ = (0,1,6)
+
+
+import ast_template
+import sys
+from compiler import parse, walk
+from compiler.consts import *
+from waxy import *
+import os
+import subprocess
+from optparse import OptionParser
+import re
+import yaml
+
+
+pynxc_root,junk=os.path.split(sys.argv[0])
+#pynxc_root=os.getcwd()
+
+
+class MyObject(object):
+    
+    def __init__(self,name,type='default'):
+        
+        self.name=name
+        self.type=type
+        self.datatype=None
+        self.value=None
+
+
+        self.variables=[]
+
+    def __repr__(self):
+        return self.type+" "+self.name+" of datatype "+self.datatype.__repr__()+" with value "+self.value.__repr__()
+
+
+class Variable(MyObject):
+    
+    def __init__(self,name,datatype='default'):
+        
+        
+        super(Variable,self).__init__(name,'variable')
+        self.datatype=datatype
+    
+        
+class Function(MyObject):
+
+    def __init__(self,name,variables=[]):
+        
+        
+        super(Function,self).__init__(name,'function')
+        self.variables=variables
+        
+    
+    
+    
+file_lines=[]
+
+class SecondPassVisitor(ast_template.Visitor):
+    """This object goes through and output the code"""
+
+    def __init__(self,fv,stream=sys.stdout,debug=False):
+
+        ast_template.Visitor.__init__(self,stream,debug)
+    
+        
+        self.fv=fv  # first-pass visitor
+        self.stream=stream
+        self.erase_assign=False
+        self.buffer=[]
+        self.semicolon=True
+
+        self.writef('#include "NXCDefs.h"\n')
+        self.writef(open(os.path.join(pynxc_root,"MyDefs.h"),'rt').read())
+            
+        
+        for d in fv.defines:
+            self.writef('#define %s %s\n' % (d[0],d[1]))
+        
+        self.print_structure_definitions(fv.struct_types)
+        
+        self.print_typedefs(fv.typedefs)
+
+        if self.debug:
+            print "Module Variables Printing "
+        
+        self.print_variable_definitions(fv.functions['module'].variables)
+        self.scope=['module']
+        
+        
+    def type2str(self,datatype):
+        if datatype=='Integer':
+            return 'int'
+        elif datatype=='IntegerPtr':
+            return 'int&'
+        elif datatype=='Word':
+            return 'word'
+        elif datatype=='Long':
+            return 'long'
+        elif datatype=='Byte':
+            return 'byte'
+        elif datatype=='Short':
+            return 'short'
+        elif datatype=='String':
+            return 'string'
+        elif datatype=='Mutex':
+            return 'mutex'
+        elif datatype in self.fv.struct_types:
+            return datatype
+        else:
+            return 'int'
+
+    def print_typedefs(self,typedefs):
+        
+        for types in typedefs:
+            self.write('typedef %s %s;' % (typedefs[types],types))
+            self.NEWLINE()
+            self.flush()
+            
+    def print_structure_definitions(self,struct_types):
+        
+        for key in struct_types:
+            self.write('struct %s ' % key)
+            self.INDENT()
+            variables=struct_types[key]
+            for var in variables:
+                self.write(self.type2str(variables[var].datatype))
+                self.write(' %s' % variables[var].name)
+                self.write(';')
+                self.NEWLINE()
+            self.DEDENT()
+            self.write(';')
+            self.NEWLINE()
+        
+        
+    def print_variable_definitions(self,variables):
+        for var in variables:
+            
+            
+            if self.debug:
+                print "  Variable ",variables[var]
+            
+            self.write(self.type2str(variables[var].datatype))
+
+            self.write(' %s' % variables[var].name)
+                
+            if not variables[var].value is None:
+                if isinstance(variables[var].value,list):
+                    self.write('[]')
+                    if not variables[var].value==[]:
+                        self.write('={')
+                        for v in variables[var].value:
+                            self.write(v.__repr__())
+                            if not v == variables[var].value[-1]:
+                                self.write(',')
+                        self.write('}')
+                                
+                            
+                        
+                else:
+                    val=variables[var].value.__repr__()
+                    self.write('= %s' % val.replace("'",'"'))
+            self.write(';')
+            self.NEWLINE()
+            
+            if variables[var].datatype in self.fv.struct_types:
+                variables2=self.fv.struct_types[variables[var].datatype]
+                for var2 in variables2:
+                    if variables2[var2].value:
+                        val2=variables2[var2].value.__repr__()
+                        
+                        self.write('%s.%s' % (var,variables2[var2].name))
+                        self.write('= %s' % val2.replace("'",'"'))
+                        self.write(';')
+                        self.NEWLINE()
+                
+            
+            
+        self.flush()
+        
+        
+    def flush(self):
+        
+        if self.buffer:
+            for s in self.buffer:
+                s=s.replace("'",'"')
+                self.stream.write(s)
+        
+        self.buffer=[]
+            
+    def DEDENT(self,with_semicolon=False):
+        self.indents -=1
+        self.NEWLINE()
+        self.write('}')
+        if with_semicolon:
+            self.write(';')
+        self.NEWLINE()
+
+    def INDENT(self):
+        self.indents += 1
+        self.write(' {')
+        self.NEWLINE()
+
+    def NEWLINE(self):
+        self.write('\n')
+        self.write(' ' * 4 * self.indents )
+        
+    def write(self, data):
+        self.buffer.append(data)
+            
+
+    def writef(self, data):
+        self.write(data)
+        self.flush()
+
+        
+    def visitBlock(self, block):
+        self.INDENT()
+        self.v(block)
+        self.DEDENT()
+
+    def visitAdd(self, node):
+        self.write("(")
+        self.v(node.left)
+        self.write(" + ")
+        self.v(node.right)
+        self.write(")")
+
+    def visitAnd(self, node):
+        self.write("(")
+        for i in range(len(node.nodes)):
+            self.write("(")
+            self.v(node.nodes[i])
+            self.write(")")
+            if i < (len(node.nodes) - 1):
+                self.write(" && ")
+        self.write(")")
+
+    def visitAssAttr(self, node):
+        if self.debug:
+            print 'visitSecondVisitorAssAttr'
+        self.v(node.expr, self)
+        self.write(".%s" % node.attrname)
+
+    def visitAssName(self, node):
+        self.write(node.name)
+
+    def visitAssign(self, node):
+        self.flush()
+        self.erase_assign=False
+        n=node.nodes[0]
+
+
+        if self.scope[-1]=='module':
+            return
+
+#        try:
+#            if (n.name == n.name.upper()) and (len(n.name)>2):  # a definition
+#                return
+#        except AttributeError:
+#            pass   # probably a subscript?
+            
+        for i in range(len(node.nodes)):
+            n = node.nodes[i]
+            self.v(n)
+            if i < len(node.nodes):
+                self.write(" = ")
+        self.v(node.expr)
+        
+        self.write("; ")
+        self.NEWLINE()
+
+        
+        if self.erase_assign:
+            self.buffer=[]
+
+        self.flush()
+        
+        
+    def visitAugAssign(self, node):
+        self.v(node.node)
+        self.write(" %s " % node.op)
+        self.v(node.expr)
+        self.write("; ")
+        self.NEWLINE()
+
+
+    def visitBitand(self, node):
+        for i in range(len(node.nodes)):
+            self.v(node.nodes[i])
+            if i < (len(node.nodes) - 1):
+                self.write(" & ")
+
+    def visitBitor(self, node):
+        for i in range(len(node.nodes)):
+            self.v(node.nodes[i])
+            if i < (len(node.nodes) - 1):
+                self.write(" | ")
+
+    def visitBitxor(self, node):
+        for i in range(len(node.nodes)):
+            self.v(node.nodes[i])
+            if i < (len(node.nodes) - 1):
+                self.write(" ^ ")        
+
+    def visitBreak(self, node):
+        self.write("break; ")
+        self.NEWLINE()
+        
+    def visitFunction(self, node):
+        self.scope.append('function')
+    
+        hasvar = haskw = hasone = hasboth = False
+
+        ndefaults = len(node.defaults)
+
+        if node.flags & CO_VARARGS:
+            hasone = hasvar = True
+        if node.flags & CO_VARKEYWORDS:
+            hasone = haskw = True
+        hasboth = hasvar and haskw
+
+        kwarg = None
+        vararg = None
+        defargs = []
+        newargs = node.argnames[:]
+
+        if ndefaults:
+            for i in range(ndefaults):
+                defargs.append((newargs.pop(), node.defaults.pop()))
+            defargs.reverse()
+
+        func_type=self.fv.functions[node.name].datatype
+        if not func_type:
+            func_type='void'
+            
+        if func_type=='default':
+            func_type='int'
+            
+        if node.name=='main':
+            self.write("task %s(" % node.name)
+        elif node.name.find('task_')==0:
+            self.write("task %s(" % node.name)
+        elif node.name.find('sub_')==0:
+            self.write("sub %s(" % node.name)
+        elif node.name.find('inline_')==0:
+            self.write("inline %s %s(" % (func_type,node.name.replace('inline_','')))
+        else: 
+            self.write("%s %s(" % (func_type,node.name))
+        
+
+        for i in range(len(newargs)):
+            if isinstance(newargs[i], tuple):
+                self.write("(%s, %s)" % newargs[i])
+            else:
+                self.write("int "+newargs[i])
+            if i < len(newargs) - 1:
+                self.write(", ")
+        if defargs and len(newargs):
+            self.write(", ")
+
+        for i in range(len(defargs)):
+            name, default = defargs[i]
+            typename=default.node.name
+            
+            
+            
+            self.write("%s %s" % (self.type2str(typename),name))
+            #self.v(default)
+            if i < len(defargs) - 1:
+                self.write(", ")
+        
+        if vararg:
+            if (newargs or defargs):
+                self.write(", ")
+            self.write(vararg)
+        if kwarg:
+            if (newargs or defargs or vararg):
+                self.write(", ")
+            self.write(kwarg)
+
+        self.write(") ")
+        self.INDENT()
+        
+        self.print_variable_definitions(self.fv.functions[node.name].variables)
+        
+        self.v(node.code)
+        self.DEDENT()
+        
+        self.flush()
+        self.scope.pop()
+            
+        
+    def visitCallFunc(self, node):
+        
+        name=node.node.name
+        
+        if name=="ASM":  # raw ASM
+            s=node.args[0].value
+            
+            self.write("asm{%s}" % s)
+            
+            return
+        
+        if name=="NXC":
+            s=node.args[0].value
+            
+            self.write("%s" % s)
+            
+            return
+        
+        if name=="DEFINE":
+            s=node.args[1].value
+            d=node.args[0].value
+
+            self.write("#define %s %s" %(d,s))
+            self.NEWLINE()
+            self.semicolon=False
+            return
+        
+        self.v(node.node)
+        self.write("(")
+        for i in range(len(node.args)):
+            self.v(node.args[i])
+            if i < (len(node.args) - 1):
+                self.write(", ")
+        if node.star_args:
+            if len(node.args):
+                self.write(", ")
+            self.write("*")
+            self.v(node.star_args)
+        if node.dstar_args:
+            if node.args or node.star_args:
+                self.write(", ")
+            self.write("**")
+            self.v(node.dstar_args)
+        self.write(")")
+
+        if name in self.fv.types:
+            self.erase_assign=True
+        
+        
+    def visitClass(self, node):
+        self.scope.append('class')
+
+        self.flush()
+        for i in range(len(node.bases)):
+            self.v(node.bases[i])
+        self.INDENT()
+        self.v(node.code)
+        self.DEDENT()
+        
+        self.buffer=[]  # get rid of all of the stuff in a class def
+        self.scope.pop()
+        
+        
+    def visitCompare(self, node):
+        self.write("(")
+        self.v(node.expr)
+        
+        for operator, operand in node.ops:
+            self.write(" %s " % operator)
+            self.v(operand)
+        self.write(")")
+
+    def visitConst(self, node):
+        self.write(repr(node.value))
+
+    def visitContinue(self, node):
+        self.write("continue; ")
+
+    def visitDiscard(self, node):
+        self.semicolon=True
+
+        # deal with empty statements, so it doesn't print None
+        try:
+            if node.expr.value is None:
+                pass
+            else:
+                self.v(node.expr)
+                if self.semicolon:
+                    self.write(";")
+                self.NEWLINE()
+        except AttributeError:
+            self.v(node.expr)
+            if self.semicolon:
+                self.write(";")
+            self.NEWLINE()
+
+    def visitDiv(self, node):
+        self.v(node.left)
+        self.write(" / ")
+        self.v(node.right)
+
+
+    def visitFor(self, node):
+        
+        
+        children=node.list.getChildNodes()
+        start='0'
+        end='1'
+        step='1'
+        
+        if self.debug:
+            print node.assign.name
+            print dir(node.assign)
+            
+            print node.list
+            print dir(node.list)
+    
+            print node.list.getChildren()
+
+            print children
+            
+        if children[0].name=='range':
+            vals=[v.asList()[0] for v in children[1:]]
+            if node.assign.name=='repeat':  # keyword repeat
+                if len(vals)==1:
+                    end=vals[0]
+                else:
+                    raise ValueError,"Bad for-loop construction"
+                
+                self.write("repeat(%s) " % (end))
+                
+            else:
+                if len(vals)==1:
+                    end=vals[0]
+                elif len(vals)==2:
+                    start=vals[0]
+                    end=vals[1]
+                elif len(vals)==3:
+                    start=vals[0]
+                    end=vals[1]
+                    step=vals[2]
+                else:
+                    raise ValueError,"Bad for-loop construction"
+                
+                varname=node.assign.name
+                self.write("for (%s=%s; %s<%s; %s+=%s) " % (varname,start,
+                                                            varname,end,
+                                                            varname,step))
+
+            self.INDENT()
+            self.v(node.body)
+            self.DEDENT()
+        else:
+            raise ValueError,"For-loop construction not implemented"
+            
+        
+        
+        
+    def visitGenExpr(self, node):
+        self.write("(")
+        self.v(node.code)
+        self.write(")")
+
+    def visitGetattr(self, node):
+        self.v(node.expr)
+        self.write(".%s" % node.attrname)
+
+    def visitIf(self, node):
+        flag=False
+        for c, b in node.tests:
+            if not flag:
+                self.write("if (")
+            else:
+                self.write("else if (")
+            self.v(c)
+            self.write(') ')
+            self.INDENT()
+            self.v(b)
+            self.DEDENT()
+            flag=True
+        if node.else_:
+            self.write("else ")
+            self.INDENT()
+            self.v(node.else_)
+            self.DEDENT()
+            
+    def visitKeyword(self, node):
+        self.write(node.name)
+        self.write("=")
+        self.v(node.expr)
+
+
+    def visitInvert(self, node):
+        self.write("~")
+        self.v(node.expr)
+
+    def visitLeftShift(self, node):
+        self.v(node.left)
+        self.write(" << ")
+        self.v(node.right)
+
+    def visitMod(self, node):
+        self.v(node.left)
+        self.write(" % ")
+        self.v(node.right)
+
+    def visitMul(self, node):
+        self.v(node.left)
+        self.write(" * ")
+        self.v(node.right)
+
+    def visitName(self, node):
+        
+        if node.name=='False':
+            self.write("false")
+        elif node.name=='True':
+            self.write("true")
+        else:
+            self.write(node.name.replace('inline_',''))
+
+    def visitNot(self, node):
+        self.write(" !(")
+        self.v(node.expr)
+        self.write(")")
+        
+    def visitOr(self, node):
+        self.write("(")
+        for i in range(len(node.nodes)):
+            self.write("(")
+            self.v(node.nodes[i])
+            self.write(")")
+            if i < len(node.nodes) - 1:
+                self.write(" || ")
+        self.write(")")
+
+                
+    def visitPass(self, node):
+        self.write("// pass ")
+
+    def visitReturn(self, node):
+        try:
+            if node.value.value is None:
+                self.write('return;')
+            else:
+                self.write('return(%s);' % node.value.value.__repr__())
+                
+        except TypeError:
+            pass
+        except AttributeError:
+                
+            self.write("return(")
+            self.v(node.value)
+            self.write(");")
+
+    def visitRightShift(self, node):
+        self.v(node.left)
+        self.write(" >> ")
+        self.v(node.right)
+
+    def visitSubscript(self, node):
+        isdel = False
+        if node.flags == OP_DELETE: isdel = True
+        isdel and self.write("del ")
+        self.v(node.expr)
+        self.write("[")
+        for i in range(len(node.subs)):
+            self.v(node.subs[i])
+            if i == len(node.subs) - 1:
+                self.write("]")
+        node.flags == OP_DELETE and self.NEWLINE()
+
+    def visitSub(self, node):
+        self.write("(")
+        self.v(node.left)
+        self.write(" - ")
+        self.v(node.right)
+        self.write(")")
+
+    def visitUnaryAdd(self, node):
+        self.write("+")
+        self.v(node.expr)
+
+    def visitUnarySub(self, node):
+        self.write("-")
+        self.v(node.expr)
+
+    def visitWhile(self, node):
+        self.write("while (")
+        self.v(node.test)
+        self.write(") ")
+        self.INDENT()
+        self.v(node.body)
+        if node.else_:
+            self.DEDENT()
+            self.write("else:")
+            self.INDENT()
+            self.v(node.else_)
+        self.DEDENT()
+        
+        
+        
+        
+        
+        
+class FirstPassVisitor(ast_template.Visitor):
+    """This object goes through and gets all of the variables.  
+    The second pass will output the code"""
+    
+    def __init__(self,stream=sys.stdout,debug=False):
+
+        ast_template.Visitor.__init__(self,stream,debug)
+        self.variables={}
+
+        self.return_datatype=None
+        self.types=['Byte','Short','Word','String','Mutex','Integer','Long','Struct']
+        self.struct_types={}
+        self.functions={}
+        self.functions['module']=Function('module',self.variables)
+        
+        self.variables_assign=[]
+        self.kwassign=[]
+        self.use_kwassign=False
+        
+        self.typedefs={}
+        
+        self.scope=['module']
+        
+        self.use_typedef=False
+        
+    def visitClass(self, node):
+        self.scope.append('class')
+        
+        variables={}
+        old_self_variables=self.variables
+        self.variables=variables
+        
+        if self.debug:
+            print "myvisitClass"
+            print node.name
+        
+        basename=node.bases[0].name
+        for i in range(len(node.bases)):
+            self.v(node.bases[i])
+            
+            
+        self.use_typedef=False
+        self.v(node.code)
+
+        if self.use_typedef:
+            self.typedefs[node.name]=basename
+            self.types.append(node.name)
+        else:
+            self.struct_types[node.name]=variables
+            self.types.append(node.name)
+            self.variables=old_self_variables
+        self.scope.pop()
+        
+        
+        
+    def visitPass(self, node):
+        if self.scope[-1]=='class':
+            self.use_typedef=True
+        
+    def visitBlock(self, block):
+        if self.debug:
+            print "myvisitBlock"
+        self.v(block)
+
+    def visitAssName(self, node):
+        if self.debug:
+            print 'visitAssName'
+            if node.flags == OP_DELETE:
+                print "del ",
+            print node.name
+        
+        n=node
+        
+        self.variables_assign.append(n.name)
+        
+        if n.name not in self.variables:
+            self.variables[n.name]=Variable(n.name)
+            if self.debug:
+                print "MyAddVar",n.name
+        
+    def visitReturn(self, node):
+        #self.write("return ")
+        #self.v(node.value)
+        try:
+            if node.value.value is None:
+                self.return_datatype='void'
+            else:
+                if isinstance(node.value.value,int):
+                    self.return_datatype='int'
+                else:
+                    raise TypeError,"Unknown type for "+str(node.value.value)
+                
+        except TypeError:
+            pass
+        except AttributeError:  # a name?
+            name=node.value.name
+            if name in self.variables:
+                self.return_datatype=self.variables[name].datatype
+            else:
+                raise NameError, "Name"+name+"not found"
+            
+    def visitFor(self, node):
+        if self.debug:
+            print 'myvisitFor'
+
+        if node.assign.name!='repeat':  # keyword repeat
+            self.v(node.assign)
+            
+        self.v(node.body)
+        
+        
+    
+    def visitAssign(self, node):
+        if self.debug:
+            print 'MyvisitAssign'
+            
+        self.variables_assign=[]
+        for i in range(len(node.nodes)):
+            n = node.nodes[i]
+            if self.debug:
+                print "  Node ",n
+            self.v(n)
+            
+        if self.debug:
+            print "varassign ",self.variables_assign
+            a=node.expr.asList()[0]
+            print "varassign expr",node.expr,node.expr.asList()[0],type(a)
+        
+        if self.scope[-1]=='module':
+            if self.debug:
+                print "Module Variables"
+            for name in self.variables_assign:
+                val=node.expr.asList()[0]
+                self.variables[name].value=val
+                if isinstance(val,str):
+                    self.variables[name].datatype='String'
+                if self.debug:
+                    print "  ",self.variables[name]
+                
+                
+        self.v(node.expr)
+
+        
+    def visitKeyword(self, node):
+        if self.debug:
+            print 'myvisitKeyword'
+
+        if not self.use_kwassign:
+            self.v(node.expr)
+            return
+        
+        
+        
+    def visitCallFunc(self, node):
+        if self.debug:
+            print 'myvisitCallFunc'
+            print 'funcname: ',node.node.name
+            
+        name=node.node.name
+        
+        
+        if not name in self.types:
+            self.v(node.node)
+            for i in range(len(node.args)):
+                self.v(node.args[i])
+
+            return
+            
+        for v in self.variables_assign:
+            if (name=='Byte' or name=='Word' or name=='Short' or 
+                name=='String' or name=='Integer' or name=='Long' or
+                name=='Mutex'):
+                    
+                self.variables[v].datatype=name
+                try:
+                    self.variables[v].value=node.args[0].value
+                except IndexError:
+                    self.variables[v].value=None # to fix the mutex problem
+                    # was:  pass  # use the default value
+                except AttributeError:  # list? or mutex
+                    nodelist=node.args[0].asList()
+                    vallist=[]
+                    for l in nodelist:
+                        vallist.append(l.value)
+                    
+                    self.variables[v].value=vallist
+            elif name=='Struct':
+                    
+                
+                self.use_kwassign=True
+
+                
+                struct_name=node.args[0].value
+                
+                if not struct_name in self.struct_types:
+                    self.struct_types.append(struct_name)
+                    
+                    for i in range(1,len(node.args)):
+                        if self.debug:
+                            print node.args[i]
+                            print dir(node.args[i])
+                        fun=node.args[i].name
+                        #self.v(node.args[i])
+                        if self.debug:
+                            print "  fun",fun
+            elif name in self.types:
+                self.variables[v].datatype=name
+                try:
+                    self.variables[v].value=node.args[0].value
+                except IndexError:
+                    pass  # use the default value
+                except AttributeError:  # list?
+                    self.variables[v].value=[]
+                
+            
+    def visitFunction(self, node):
+        self.scope.append('function')
+        self.return_datatype=None
+        
+        variables={}
+        old_self_variables=self.variables
+        self.variables=variables
+        
+        if self.debug:
+            print "myvisitFunction"
+            print node.name
+        hasvar = haskw = hasone = hasboth = False
+
+        ndefaults = len(node.defaults)
+
+        if node.flags & CO_VARARGS:
+            hasone = hasvar = True
+        if node.flags & CO_VARKEYWORDS:
+            hasone = haskw = True
+        hasboth = hasvar and haskw
+
+        kwarg = None
+        vararg = None
+        defargs = []
+        newargs = node.argnames[:]
+
+
+        self.v(node.code)
+                
+        self.functions[node.name]=Function(node.name,variables)
+        self.functions[node.name].datatype=self.return_datatype
+        self.variables=old_self_variables
+        self.scope.pop()
+                    
+        
+        # remove those variables that are global
+        remove_var=[]
+        for var in self.functions[node.name].variables:
+            if (var in self.variables and 
+                self.functions[node.name].variables[var].datatype=='default'):
+                
+                remove_var.append(var)
+                    
+        for r in remove_var:
+            self.functions[node.name].variables.pop(r)
+        
+ 
+def python_to_nxc(pyfile,nxcfile=None,debug=False):
+    global file_lines
+    
+    filename = pyfile
+    
+    f = open(filename, 'U')
+    codestring = f.read()
+    f.close()
+    if codestring and codestring[-1] != '\n':
+        codestring = codestring + '\n'
+        
+    file_lines=open(filename).readlines()
+    filestr=codestring
+    
+    
+    defines=re.findall('\s*DEFINE (.*?)=(.*)',filestr)
+    filestr=re.sub('\s*DEFINE (.*?)=(.*)',"",filestr)
+    
+    
+    if debug:
+        print "Filestr"
+        print filestr
+    
+    ast = parse(filestr)
+    v = FirstPassVisitor(debug=debug)
+    v.v(ast)
+    
+    v.defines=defines
+    
+    if nxcfile:
+        fid=open(nxcfile,'wt')
+    else:
+        fid=sys.stdout
+        
+    v2 = SecondPassVisitor(v,debug=debug,stream=fid)
+    v2.v(ast)
+    v2.flush()
+    
+    if not fid==sys.stdout:
+        fid.close()
+    
+def readconfig(fname):
+    config={'firmware':'105'}
+    
+    if os.path.exists(fname):
+        data=yaml.load(open(fname))        
+        config.update(data)
+    
+    return config
+    
+def main():
+
+    config=readconfig('pynxc.yaml')
+    nxc=os.path.join("nxc",sys.platform,'nbc')
+    if not os.path.exists(nxc):
+        nxc = 'nbc' # expect 'nbc' in the binary PATH
+
+    usage="usage: %prog [options] [filename]"
+    parser = OptionParser(usage=usage)
+
+    parser.add_option('-c', '--compile', dest="compile",
+                      help='compile to nxc code only',default=False,
+                      action="store_true")
+    parser.add_option('--debug', dest="debug",
+                      help='show debug messages',default=False,
+                      action="store_true")
+    parser.add_option('--show_nxc', dest="show_nxc",
+                      help='show the nxc code',default=False,
+                      action="store_true")
+    parser.add_option('-d', '--download', dest="download",
+                      help='download program',default=False,
+                      action="store_true")
+    parser.add_option('-B', '--bluetooth', dest="bluetooth",
+                    help='enable bluetooth',default=False,
+                    action="store_true")
+    parser.add_option('--firmware', dest="firmware",
+                      help='firmware version (105, 107, or 128)',default=config['firmware'])
+    parser.add_option('--command',  dest="nxc",
+                      help='what is the nxc/nqc command',default=nxc,
+                      metavar="<command>")
+                      
+                      
+    options, args = parser.parse_args()
+    if len(args) < 1:
+        parser.print_help()
+        raise SystemExit
+    
+    options.firmware=config['firmware']
+
+    # sanity check on the options
+    
+    if (options.download) and (options.compile):
+        print "conflicting options"
+        parser.print_help()
+        raise SystemExit
+        
+    
+    nxc_root,nxc=os.path.split(options.nxc)
+    s=nxc.lower()
+
+    filename = args[0]
+
+    for filename in args:
+
+        root,ext=os.path.splitext(filename)
+        
+        nxc_filename=root+".nxc"
+        rxe_filename=root+".rxe"
+        
+        python_to_nxc(filename,nxc_filename,debug=options.debug)
+        print "Wrote %s." % (nxc_filename)
+
+        if options.show_nxc:
+            fid=open(nxc_filename)
+            print fid.read()
+            fid.close()
+            
+        if not options.compile:
+        
+            cmd=options.nxc+" "
+            if options.bluetooth:
+                cmd+=' -BT '
+                
+            cmd=cmd+ "'%s'" % nxc_filename+ " -I='%s' -I=%s/ -v=%s -O='%s'" % (nxc_root,
+                                                           pynxc_root,
+                                                           options.firmware,
+                                                           rxe_filename)
+            print cmd
+            a=os.system(cmd)
+    
+            if options.download:
+                print "Downloading...",
+                cmd=options.nxc+" "
+                cmd=cmd+ nxc_filename+ " -I='%s/' -I='%s/' v=%s -d" % (nxc_root,
+                                                          pynxc_root,
+                                                          options.firmware)
+                a=os.system(cmd)
+                nxtcom=os.path.join(nxc_root,'nxtcom')
+                print nxtcom
+                if os.path.exists(nxtcom):
+                    cmd='%s %s' % (nxtcom,rxe_filename)
+                    a=os.system(cmd)
+
+                print "done."
+        
+            
+    return
+
+
+class MainFrame(Frame):
+
+    def Body(self):
+        self.ReadConfig()
+    
+        self.nxc=os.path.join("nxc",sys.platform,'nbc')
+        if not os.path.exists(self.nxc):
+            nxc = 'nbc' # expect 'nbc' in the binary PATH
+
+        self.prog=None
+
+        self.CreateMenu()
+        
+        self.textbox = TextBox(self, multiline=1, readonly=1,
+                       Font=Font("Courier New", 10), Size=(650,500),
+                       Value='PyNXC Version '+str(__version__)+"\n" + 
+                       "Firmware Version "+self.firmware_version+"\n")
+        self.AddComponent(self.textbox, expand='both')
+
+        self.Pack()
+        self.CenterOnScreen()
+        
+        cmdlist=[self.nxc]
+        self.DoCmd(cmdlist)
+        
+        self.ResetTitle()
+        
+    def ReadConfig(self):
+    
+        config=readconfig('pynxc.yaml')
+        self.firmware_version=str(config['firmware'])
+            
+    def UpdateConfig(self):
+    
+        config={'firmware':self.firmware_version}
+        with open("pynxc.yaml",'w') as fid:
+            yaml.dump(config,fid,default_flow_style=False)
+    
+    def CreateMenu(self):
+    
+        
+        menubar = MenuBar()
+        
+        menu1 = Menu(self)
+        menu1.Append("L&oad Program File", self.Load, "Load a .py file",hotkey="Ctrl+O")
+        menu1.Append("&Quit", self.Quit, "Quit",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        menu1 = Menu(self)
+        menu1.Append("Con&vert", self.OnlyConvert)
+        menu1.Append("&Compile", self.Compile,hotkey="Ctrl+C")
+        menu1.Append("Compile and &Download", self.Download,hotkey="Ctrl+D")
+        menubar.Append(menu1, "&Program")
+        self.menubar=menubar
+
+        self.nxt_menu = Menu(self)
+        self.nxt_menu.Append("&Info", self.NXT_Info)
+        self.bluetooth_menu=self.nxt_menu.Append("Enable &Bluetooth", type='check')
+        
+        submenu=Menu(self)
+        self.firmware_menus=[
+            submenu.Append("Version 105",type='radio',event=self.FirmwareVersion),
+            submenu.Append("Version 107",type='radio',event=self.FirmwareVersion),
+            submenu.Append("Version 128",type='radio',event=self.FirmwareVersion),
+        ]
+        if self.firmware_version=='107':
+            self.firmware_menus[1].Check(True)
+        elif self.firmware_version=='128':
+            self.firmware_menus[2].Check(True)
+        else:
+            self.firmware_menus[0].Check(True)
+            self.firmware_version='105'
+            self.UpdateConfig()
+            
+        self.nxt_menu.AppendMenu("Firmware",submenu)
+        
+        self.menubar.Append(self.nxt_menu, "&NXT")
+            
+            
+        self.SetMenuBar(menubar)
+
+        
+    def FirmwareVersion(self,event):
+        versions={'Version 105':'105',
+        'Version 107':'107',
+        'Version 128':'128',
+        }
+    
+        for menu in self.firmware_menus:
+            if menu.IsChecked():
+                self.firmware_version=versions[menu.Label]
+                self.UpdateConfig()
+                
+        
+        
+    def Load(self,event=None):
+        dlg = FileDialog(self, 'Select a Program File',default_dir=os.getcwd(),wildcard='*.py',open=1)
+        try:
+            result = dlg.ShowModal()
+            if result == 'ok':
+                self.prog = dlg.GetPaths()[0]
+                self.ResetTitle()
+        finally:
+            dlg.Destroy()
+    
+    def ResetTitle(self,event=None):
+        if self.prog:
+            junk,fname=os.path.split(self.prog)
+            s='PyNXC: %s' % fname
+        else:
+            s='PyNXC'
+            
+        self.SetTitle(s)
+        
+            
+    def NXT_Info(self,event=None):
+        pass
+    
+    def Quit(self,event=None):
+        self.Close()
+
+    def DoCmd(self,cmdlist):
+        
+        S=self.textbox.GetValue()
+        S=S+"#-> "+" ".join(cmdlist)+"\n"
+        self.textbox.SetValue(S)
+        
+        try:
+
+            if sys.platform=='win32':
+                output=subprocess.Popen(
+                    cmdlist,stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,stderr=subprocess.PIPE)
+            else:
+                output=subprocess.Popen(
+                    cmdlist,stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,stderr=subprocess.PIPE,close_fds=True)
+
+            try: # there might be non-ASCII chars in the output
+                S += output.stdout.read() + output.stderr.read()
+            except UnicodeDecodeError:
+                S += (output.stdout.read() + output.stderr.read()
+                     ).decode('utf-8', 'replace')
+            
+            self.textbox.SetValue(S)
+                
+        except OSError:
+            
+            s=sys.exc_info()
+            S=S+"Error with NXC Executable: "+str(s[1])
+            self.textbox.SetValue(S)
+            return
+                
+                
+            
+    def Convert(self):
+        filename=self.prog
+
+#        path,fname=os.path.split(filename)
+        root,ext=os.path.splitext(filename)
+        
+        nxc_filename=root+".nxc"
+        
+        S=self.textbox.GetValue()
+        
+        S=S+"Writing %s..." % (nxc_filename)
+        self.textbox.SetValue(S)
+        
+        python_to_nxc(filename,nxc_filename)
+        
+        
+        S=S+".done\n"
+        self.textbox.SetValue(S)
+        
+        return nxc_filename
+
+    
+    def OnlyConvert(self,event=None):
+        self.textbox.SetValue("")
+        
+        if not self.prog:
+            self.Load()
+            
+        if not self.prog:
+            dlg = MessageDialog(self, "Error","No Program File Selected")
+            dlg.ShowModal()
+            dlg.Destroy()
+            return
+            
+        try:
+            nxc_filename=self.Convert()
+        except:
+            s=sys.exc_info()
+            str1="Error in "+self.prog +": "+str(s[1])
+            self.textbox.SetValue(str1)
+            return
+
+    def Compile(self,event=None):
+        self.textbox.SetValue("")
+        
+        if not self.prog:
+            self.Load()
+            
+        if not self.prog:
+            dlg = MessageDialog(self, "Error","No Program File Selected")
+            dlg.ShowModal()
+            dlg.Destroy()
+            return
+            
+        try:
+            nxc_filename=self.Convert()
+        except:
+            s=sys.exc_info()
+            str1="Error in "+self.prog +": "+str(s[1])
+            self.textbox.SetValue(str1)
+            return
+
+
+        root,ext=os.path.splitext(nxc_filename)
+        rxe_filename=root+".rxe"
+        
+        
+        
+        cmdlist=[self.nxc,nxc_filename," -v=%s" % self.firmware_version," -O=%s" % rxe_filename]
+        
+        self.DoCmd(cmdlist)
+            
+
+   
+    def Download(self,event=None):
+        
+        self.textbox.SetValue("")
+        
+        if not self.prog:
+            self.Load()
+            
+        if not self.prog:
+            dlg = MessageDialog(self, "Error","No Program File Selected")
+            dlg.ShowModal()
+            dlg.Destroy()
+            return
+            
+        try:
+            nxc_filename=self.Convert()
+        except:
+            s=sys.exc_info()
+            str1="Error in "+self.prog +": "+str(s[1])
+            self.textbox.SetValue(str1)
+            return
+
+        flags=['-d','-S=usb','-v=%s' % self.firmware_version]
+        if self.bluetooth_menu.IsChecked():
+            flags.append('-BT')
+            
+        root,ext=os.path.splitext(nxc_filename)
+        rxe_filename=root+".rxe"
+        cmdlist=[self.nxc]
+        cmdlist.extend(flags)
+        cmdlist.append(nxc_filename)
+        
+        self.DoCmd(cmdlist)
+
+        root,ext=os.path.split(self.nxc)
+        nxtcom=os.path.join(root,'nxtcom_scripts/nxtcom')
+        print nxtcom
+        if os.path.exists(nxtcom):
+            print "Downloading...",
+            cmd='%s %s' % (nxtcom,rxe_filename)
+            a=os.system(cmd)
+            print "done."
+        
+        
+if __name__ == "__main__":
+
+    
+    if len(sys.argv)<2:  # no args given, launch gui
+        app = Application(MainFrame, title="PyNXC")
+        app.Run()
+    else:
+        sys.exit(main())
+    
diff --git a/pynxc/pynxc.yaml b/pynxc/pynxc.yaml
new file mode 100644
index 0000000..7600055
--- /dev/null
+++ b/pynxc/pynxc.yaml
@@ -0,0 +1 @@
+firmware: '105'
diff --git a/pynxc/tutorial_samples/10_mutex.py b/pynxc/tutorial_samples/10_mutex.py
new file mode 100644
index 0000000..25994b4
--- /dev/null
+++ b/pynxc/tutorial_samples/10_mutex.py
@@ -0,0 +1,25 @@
+moveMutex=Mutex()
+
+def task_move_square():
+
+    while True:
+        Acquire(moveMutex)
+        OnFwd(OUT_AC, 75); Wait(1000)
+        OnRev(OUT_C, 75); Wait(850)
+        Release(moveMutex)
+
+def task_check_sensors():
+
+    while True:
+        if SENSOR_1 == 1:
+        
+            Acquire(moveMutex)
+            OnRev(OUT_AC, 75); Wait(500)
+            OnFwd(OUT_A, 75); Wait(850)
+            Release(moveMutex)
+            
+def main():
+    SetSensor(IN_1,SENSOR_TOUCH)
+    Precedes(task_check_sensors, task_move_square)
+
+
diff --git a/pynxc/tutorial_samples/10_semaphore.py b/pynxc/tutorial_samples/10_semaphore.py
new file mode 100644
index 0000000..3b6a765
--- /dev/null
+++ b/pynxc/tutorial_samples/10_semaphore.py
@@ -0,0 +1,41 @@
+sem=0  # make sure this one is global
+
+def task_move_square():
+    while True:
+        while (sem == 1):
+            pass
+        sem = 1
+        OnFwd(OUT_AC, 75)
+        sem = 0
+        Wait(1000)
+        
+        while sem==1:
+            pass
+        
+        sem = 1
+        
+        
+        OnRev(OUT_C, 75)
+        sem = 0
+        Wait(850)
+
+def task_submain():
+
+    SetSensor(IN_1, SENSOR_TOUCH)
+    while True:
+
+        if SENSOR_1 == 1:
+            while (sem == 1):
+                pass
+            sem = 1
+            OnRev(OUT_AC, 75); Wait(500)
+            OnFwd(OUT_A, 75); Wait(850)
+            sem = 0
+
+def main():
+
+    sem = 0
+    Precedes(task_move_square, task_submain)
+
+
+
diff --git a/pynxc/tutorial_samples/11_DC_master.py b/pynxc/tutorial_samples/11_DC_master.py
new file mode 100644
index 0000000..28f85bf
--- /dev/null
+++ b/pynxc/tutorial_samples/11_DC_master.py
@@ -0,0 +1,37 @@
+#MASTER
+
+DEFINE BT_CONN=1
+
+def sub_BTCheck(conn):
+    if (BluetoothStatus(conn)!=NO_ERR):
+        TextOut(5,LCD_LINE2,"Error")
+        Wait(1000)
+        Stop(True)
+        
+DEFINE('MOTOR(p,s)',"""RemoteSetOutputState(BT_CONN, p, s, \\
+                       OUT_MODE_MOTORON+OUT_MODE_BRAKE+OUT_MODE_REGULATED, \\
+                       OUT_REGMODE_SPEED, 0, OUT_RUNSTATE_RUNNING, 0)""")
+
+def main():
+    sub_BTCheck(BT_CONN)
+    RemotePlayTone(BT_CONN, 4000, 100)
+    
+    while (BluetoothStatus(BT_CONN)!=NO_ERR):
+        pass
+    
+    Wait(110)
+    RemotePlaySoundFile(BT_CONN, "! Click.rso", false)
+
+    while (BluetoothStatus(BT_CONN)!=NO_ERR):
+        pass
+    
+    #Wait(500)
+    RemoteResetMotorPosition(BT_CONN,OUT_A,true)
+
+    while (BluetoothStatus(BT_CONN)!=NO_ERR):
+        pass
+    
+    MOTOR(OUT_A,100)
+    Wait(1000)
+    MOTOR(OUT_A,0)
+
diff --git a/pynxc/tutorial_samples/11_ack_master.py b/pynxc/tutorial_samples/11_ack_master.py
new file mode 100644
index 0000000..3104f3d
--- /dev/null
+++ b/pynxc/tutorial_samples/11_ack_master.py
@@ -0,0 +1,30 @@
+#MASTER
+
+DEFINE BT_CONN=1
+DEFINE OUTBOX=5
+DEFINE INBOX=1
+
+def sub_BTCheck(conn):
+    if (BluetoothStatus(conn)!=NO_ERR):
+        TextOut(5,LCD_LINE2,"Error")
+        Wait(1000)
+        Stop(True)
+        
+def main():
+    sub_BTCheck(BT_CONN)
+    TextOut(10,LCD_LINE1,"Master sending")
+    while True:
+        i = Random(512);
+        TextOut(0,LCD_LINE3,"                   ")
+        NumOut(5,LCD_LINE3,i)
+        ack = 0
+        SendRemoteNumber(BT_CONN,OUTBOX,i)
+        
+        while (ack!=0xFF):
+            pass
+        
+        while (ReceiveRemoteNumber(INBOX,true,ack) != NO_ERR):
+            pass
+        
+      
+        Wait(250)
diff --git a/pynxc/tutorial_samples/11_ack_slave.py b/pynxc/tutorial_samples/11_ack_slave.py
new file mode 100644
index 0000000..9e8c619
--- /dev/null
+++ b/pynxc/tutorial_samples/11_ack_slave.py
@@ -0,0 +1,26 @@
+#SLAVE
+
+DEFINE BT_CONN=1
+DEFINE OUTBOX=5
+DEFINE INBOX=1
+
+def sub_BTCheck(conn):
+    if (BluetoothStatus(conn)!=NO_ERR):
+        TextOut(5,LCD_LINE2,"Error")
+        Wait(1000)
+        Stop(True)
+        
+
+def main():
+    numin=Integer()
+    
+    sub_BTCheck(0)
+    TextOut(5,LCD_LINE1,"Slave receiving")
+    SendResponseNumber(OUTBOX,0xFF) #unblock master
+    while True:
+        if (ReceiveRemoteNumber(INBOX,true,numin) != STAT_MSG_EMPTY_MAILBOX):
+            TextOut(0,LCD_LINE3,"                   ");
+            NumOut(5,LCD_LINE3,numin);
+            SendResponseNumber(OUTBOX,0xFF);
+     
+        Wait(10); #take breath (optional)
diff --git a/pynxc/tutorial_samples/11_msg_master.py b/pynxc/tutorial_samples/11_msg_master.py
new file mode 100644
index 0000000..65cb3fd
--- /dev/null
+++ b/pynxc/tutorial_samples/11_msg_master.py
@@ -0,0 +1,32 @@
+#MASTER
+
+DEFINE BT_CONN=1
+DEFINE OUTBOX=5
+DEFINE INBOX=1
+
+def sub_BTCheck(conn):
+    if (BluetoothStatus(conn)!=NO_ERR):
+        TextOut(5,LCD_LINE2,"Error")
+        Wait(1000)
+        Stop(True)
+
+def main():
+    instr=String()
+    outstr=String()
+    iStr=String()
+    
+    i=Integer(0)
+    
+    sub_BTCheck(BT_CONN)  #check slave connection
+    while True:
+        iStr = NumToStr(i)
+        outstr = StrCat("M",iStr)
+        TextOut(10,LCD_LINE1,"Master Test")
+        TextOut(0,LCD_LINE2,"IN:")
+        TextOut(0,LCD_LINE4,"OUT:")
+        ReceiveRemoteString(INBOX, True,instr)
+        #  SendRemoteString(BT_CONN,OUTBOX,outstr)  # for some reason, this line doesn't work!  
+        TextOut(10,LCD_LINE3,instr)
+        TextOut(10,LCD_LINE5,outstr)
+        Wait(100)
+        i+=1
diff --git a/pynxc/tutorial_samples/11_msg_slave.py b/pynxc/tutorial_samples/11_msg_slave.py
new file mode 100644
index 0000000..34c6c27
--- /dev/null
+++ b/pynxc/tutorial_samples/11_msg_slave.py
@@ -0,0 +1,31 @@
+DEFINE BT_CONN=1
+DEFINE INBOX=5
+DEFINE OUTBOX=1
+
+
+def sub_BTCheck(conn):
+    
+    if (BluetoothStatus(conn)!=NO_ERR):
+        TextOut(5,LCD_LINE2,"Error")
+        Wait(1000)
+        Stop(True)
+
+def main():
+    instr=String('')
+    outstr=String('')
+    iStr=String('')
+    
+    i=Integer(0)
+    sub_BTCheck(0)                #check master connection
+    while True:
+        iStr = NumToStr(i)
+        outstr = StrCat("S",iStr)
+        TextOut(10,LCD_LINE1,"Slave Test")
+        TextOut(0,LCD_LINE2,"IN:")
+        TextOut(0,LCD_LINE4,"OUT:")
+        ReceiveRemoteString(INBOX, True, instr)
+        SendResponseString(OUTBOX,outstr)
+        TextOut(10,LCD_LINE3,instr)
+        TextOut(10,LCD_LINE5,outstr)
+        Wait(100)
+        i+=1
diff --git a/pynxc/tutorial_samples/12_ASCII.py b/pynxc/tutorial_samples/12_ASCII.py
new file mode 100644
index 0000000..68ae25d
--- /dev/null
+++ b/pynxc/tutorial_samples/12_ASCII.py
@@ -0,0 +1,16 @@
+def main():
+    handle=Byte()
+    i=Integer()
+    slen=Integer()
+    s=String()
+    
+    if (CreateFile("ASCII.txt", 2048, handle) == NO_ERR):
+
+        for i in range(256):
+            s=NumToStr(i)
+            slen = StrLen(s)
+            WriteString(handle, s, slen)
+            WriteLn(handle, i)
+       
+        CloseFile(handle)
+
diff --git a/pynxc/tutorial_samples/12_ReadStr.py b/pynxc/tutorial_samples/12_ReadStr.py
new file mode 100644
index 0000000..5e45145
--- /dev/null
+++ b/pynxc/tutorial_samples/12_ReadStr.py
@@ -0,0 +1,40 @@
+DEFINE FILE_LINES=10
+
+def sub_CreateRandomFile(fname=String(), lines=Integer()):
+    handle=Byte()
+    s=String()
+    n=bytesWritten=Integer()
+    DeleteFile(fname)
+    fsize=Integer()
+    fsize = lines*5
+    # create file with random data
+    if (CreateFile(fname, fsize, handle) == NO_ERR):
+        for repeat in range(FILE_LINES):
+            n = Random(0xFF)
+            s = NumToStr(n)
+            WriteLnString(handle,s,bytesWritten)
+      
+        CloseFile(handle)
+
+
+def main():
+    handle=Byte()
+    buf=String()
+    fsize=Integer()
+    blah = Integer(0)
+    
+    
+
+    sub_CreateRandomFile("rand.txt",FILE_LINES)
+    if (OpenFileRead("rand.txt", fsize, handle) == NO_ERR):
+        TextOut(10,LCD_LINE2,"Filesize:")
+        NumOut(65,LCD_LINE2,fsize)
+        Wait(600)
+        while (not eof): # read the text file till the end
+            pass 
+        if (ReadLnString(handle,buf) != NO_ERR):
+            eof = true
+        TextOut(20,LCD_LINE3,buf)
+        Wait(500)
+    CloseFile(handle)
+
diff --git a/pynxc/tutorial_samples/12_WriteStr.py b/pynxc/tutorial_samples/12_WriteStr.py
new file mode 100644
index 0000000..1dcc155
--- /dev/null
+++ b/pynxc/tutorial_samples/12_WriteStr.py
@@ -0,0 +1,27 @@
+DEFINE OK=LDR_SUCCESS
+
+
+def main():
+    
+    fileHandle=Byte()
+    fileSize=Short()
+    bytesWritten=Short()
+    
+    read=String()
+    write=String()
+    error=String()
+    
+    tmp=String()
+    
+    DeleteFile("Danny.txt")
+    DeleteFile("DannySays.txt")
+    CreateFile("Danny.txt", 512, fileHandle)
+    for i in range(2,10):
+        write = "NXT is cool "
+        tmp = NumToStr(i)
+        write = StrCat(write,tmp," times!")
+        WriteLnString(fileHandle,write, bytesWritten)
+    
+    CloseFile(fileHandle)
+    RenameFile("Danny.txt","DannySays.txt")
+
diff --git a/pynxc/tutorial_samples/12_fs_numbers_int.py b/pynxc/tutorial_samples/12_fs_numbers_int.py
new file mode 100644
index 0000000..249c142
--- /dev/null
+++ b/pynxc/tutorial_samples/12_fs_numbers_int.py
@@ -0,0 +1,20 @@
+def main():
+   handle=time=Byte(0)
+   i=fsize=numin=Integer()
+   
+   DeleteFile("int.txt")
+   CreateFile("int.txt",4096,handle)
+   
+   for i in range(1000,10000,1000):
+       WriteLn(handle,i)
+       
+   CloseFile(handle)
+   OpenFileRead("int.txt",fsize,handle);
+   
+   while (ReadLn(handle,numin)==NO_ERR):
+       ClearScreen()
+       NumOut(30,LCD_LINE5,numin)
+       Wait(500)
+   
+   CloseFile(handle)
+
diff --git a/pynxc/tutorial_samples/12_fs_numbers_long.py b/pynxc/tutorial_samples/12_fs_numbers_long.py
new file mode 100644
index 0000000..c23d47f
--- /dev/null
+++ b/pynxc/tutorial_samples/12_fs_numbers_long.py
@@ -0,0 +1,21 @@
+def main():
+   handle=time=Byte(0)
+   i=fsize=numin=Integer()
+   numin=Long()
+   
+   DeleteFile("long.txt")
+   CreateFile("long.txt",4096,handle)
+   
+   for i in range(100000,1000000,50000):
+       WriteLn(handle,i)
+       
+   CloseFile(handle)
+   OpenFileRead("long.txt",fsize,handle);
+   
+   while (ReadLn(handle,numin)==NO_ERR):
+       ClearScreen()
+       NumOut(30,LCD_LINE5,numin)
+       Wait(500)
+   
+   CloseFile(handle)
+
diff --git a/pynxc/tutorial_samples/12_graphics.py b/pynxc/tutorial_samples/12_graphics.py
new file mode 100644
index 0000000..c80c90f
--- /dev/null
+++ b/pynxc/tutorial_samples/12_graphics.py
@@ -0,0 +1,30 @@
+DEFINE X_MAX=99
+DEFINE Y_MAX=63
+DEFINE X_MID=(X_MAX+1)/2
+DEFINE Y_MID=(Y_MAX+1)/2
+
+def main():
+    i=1234
+    
+    TextOut(15,LCD_LINE1,"Display")
+    NumOut(60,LCD_LINE1, i)
+    PointOut(1,Y_MAX-1)
+    PointOut(X_MAX-1,Y_MAX-1)
+    PointOut(1,1)
+    PointOut(X_MAX-1,1)
+    Wait(200)
+    RectOut(5,5,90,50)
+    Wait(200)
+    LineOut(5,5,95,55)
+    Wait(200)
+    LineOut(5,55,95,5)
+    Wait(200)
+    CircleOut(X_MID,Y_MID-2,20)
+    Wait(800)
+    ClearScreen()
+    GraphicOut(30,10,"faceclosed.ric")
+    Wait(500)
+    ClearScreen()
+    GraphicOut(30,10,"faceopen.ric")
+    Wait(1000)
+
diff --git a/pynxc/tutorial_samples/12_timers.py b/pynxc/tutorial_samples/12_timers.py
new file mode 100644
index 0000000..e024c1c
--- /dev/null
+++ b/pynxc/tutorial_samples/12_timers.py
@@ -0,0 +1,14 @@
+def main():
+    t0 = CurrentTick()
+    time=0
+    
+    while time<10000:
+        time = CurrentTick()-t0
+        OnFwd(OUT_AC, 75)
+        Wait(Random(1000))
+        OnRev(OUT_C, 75)
+        Wait(Random(1000))
+  
+    
+    Off(OUT_AC);
+
diff --git a/pynxc/tutorial_samples/12_wait.py b/pynxc/tutorial_samples/12_wait.py
new file mode 100644
index 0000000..87b9b6f
--- /dev/null
+++ b/pynxc/tutorial_samples/12_wait.py
@@ -0,0 +1,12 @@
+def main():
+
+    SetSensor(IN_1,SENSOR_TOUCH)
+    t3 = CurrentTick()
+    OnFwd(OUT_AC, 75)
+    
+    while (SENSOR_1 != 1) and ((CurrentTick()-t3) <= 1000):
+        pass
+    
+    Off(OUT_AC);
+
+
diff --git a/pynxc/tutorial_samples/1_errors.py b/pynxc/tutorial_samples/1_errors.py
new file mode 100644
index 0000000..77640bf
--- /dev/null
+++ b/pynxc/tutorial_samples/1_errors.py
@@ -0,0 +1,8 @@
+def main():
+    OnFwd(OUT_D, 75)
+    OnFwd(OUT_C, 75)
+    Wait(4000)
+    OnRev(OUT_AC, 75)
+    Wait(4000)
+    Of(OUT_AC)
+
diff --git a/pynxc/tutorial_samples/1_simple.nxc b/pynxc/tutorial_samples/1_simple.nxc
new file mode 100644
index 0000000..f425424
--- /dev/null
+++ b/pynxc/tutorial_samples/1_simple.nxc
@@ -0,0 +1,79 @@
+#include "NXCDefs.h"
+#define ULTRASONIC 1
+#define EYES 1
+#define LIGHT 2
+#define SOUND 3
+#define MIC 3
+#define TOUCH 4
+
+#define None 0
+
+
+int SensorTypes[]={0,0,0,0};
+
+
+
+inline int SensorVal(int s_) {
+    
+    s_=s_-1;
+    int t_ = SensorTypes[s_];
+    
+    if (t_==None) {
+        return -1;
+    } else if (t_==ULTRASONIC) {
+        Wait(100);
+        return SensorUS(s_);
+    } else {
+        return Sensor(s_); 
+    }
+    
+}
+
+
+
+void DefineSensors(int s1,int s2,int s3,int s4) {
+    
+    int sa[];
+    int i;
+    
+    ArrayInit(sa,0,4);
+    sa[0]=s1;
+    sa[1]=s2;
+    sa[2]=s3;
+    sa[3]=s4;
+    
+    for (i=0; i<4; i++) {
+    
+        if (sa[i]==None) {
+            SensorTypes[i]=None;
+        } else if (sa[i]==ULTRASONIC) {
+            SetSensorLowspeed(i);
+            SensorTypes[i]=ULTRASONIC;
+        } else if (sa[i]==LIGHT) {
+            SetSensorLight(i);
+            SensorTypes[i]=LIGHT;
+        } else if (sa[i]==SOUND) {
+            SetSensorSound(i);
+            SensorTypes[i]=SOUND;
+        } else if (sa[i]==TOUCH) {
+            SetSensor(i,SENSOR_TOUCH);
+            SensorTypes[i]=TOUCH;
+        }
+
+        
+    
+    
+    }
+    
+    
+}
+    
+task main()  {
+    OnFwd(OUT_A, 75);
+    OnFwd(OUT_B, 75);
+    Wait(4000);
+    OnRev(OUT_AB, 75);
+    Wait(4000);
+    Off(OUT_AB);
+    
+}
diff --git a/pynxc/tutorial_samples/1_simple.py b/pynxc/tutorial_samples/1_simple.py
new file mode 100644
index 0000000..eed7ecf
--- /dev/null
+++ b/pynxc/tutorial_samples/1_simple.py
@@ -0,0 +1,9 @@
+def main():
+    
+    OnFwd(OUT_A, 75)
+    OnFwd(OUT_B, 75)
+    Wait(4000)
+    OnRev(OUT_AB, 75)
+    Wait(4000)
+    Off(OUT_AB)
+    
diff --git a/pynxc/tutorial_samples/2_repeat_a.py b/pynxc/tutorial_samples/2_repeat_a.py
new file mode 100644
index 0000000..b7c5c99
--- /dev/null
+++ b/pynxc/tutorial_samples/2_repeat_a.py
@@ -0,0 +1,15 @@
+DEFINE MOVE_TIME=500
+DEFINE TURN_TIME=360
+
+def main():
+
+    a=5
+    
+    for repeat in range(a):
+        OnFwd(OUT_AC, 75)
+        Wait(MOVE_TIME)
+        OnRev(OUT_C, 75)
+        Wait(TURN_TIME)
+
+    Off(OUT_AC)
+
diff --git a/pynxc/tutorial_samples/2_repeat_b.py b/pynxc/tutorial_samples/2_repeat_b.py
new file mode 100644
index 0000000..1400342
--- /dev/null
+++ b/pynxc/tutorial_samples/2_repeat_b.py
@@ -0,0 +1,14 @@
+DEFINE MOVE_TIME=500
+DEFINE TURN_TIME=360
+
+def main():
+
+    for repeat in range(10):
+        for repeat in range(4):
+            
+            OnFwd(OUT_AC, 75)
+            Wait(MOVE_TIME)
+            OnRev(OUT_C, 75)
+            Wait(TURN_TIME)
+
+    Off(OUT_AC)
diff --git a/pynxc/tutorial_samples/2_repeat_c.py b/pynxc/tutorial_samples/2_repeat_c.py
new file mode 100644
index 0000000..a9988c4
--- /dev/null
+++ b/pynxc/tutorial_samples/2_repeat_c.py
@@ -0,0 +1,23 @@
+#  10 SQUARES
+#
+#This program make the robot run 10 squares
+#
+#
+
+# Time for a straight move
+DEFINE MOVE_TIME=500
+# Time for turning 90 degrees
+DEFINE TURN_TIME=360
+
+def main():
+
+    for repeat in range(10):  # Make 10 squares
+        for repeat in range(4):
+            
+            OnFwd(OUT_AC, 75)
+            Wait(MOVE_TIME)
+            OnRev(OUT_C, 75)
+            Wait(TURN_TIME)
+
+    Off(OUT_AC)  # Now turn the motors off
+
diff --git a/pynxc/tutorial_samples/2_turn_b.py b/pynxc/tutorial_samples/2_turn_b.py
new file mode 100644
index 0000000..75f30c7
--- /dev/null
+++ b/pynxc/tutorial_samples/2_turn_b.py
@@ -0,0 +1,9 @@
+DEFINE MOVE_TIME=1000
+DEFINE TURN_TIME=360
+
+def main():
+    OnFwd(OUT_AC, 75)
+    Wait(MOVE_TIME)
+    OnRev(OUT_C, 75)
+    Wait(TURN_TIME)
+    Off(OUT_AC)
diff --git a/pynxc/tutorial_samples/3_random.py b/pynxc/tutorial_samples/3_random.py
new file mode 100644
index 0000000..9a5b9a0
--- /dev/null
+++ b/pynxc/tutorial_samples/3_random.py
@@ -0,0 +1,9 @@
+def main():
+
+    while True:
+        move_time = Random(600)   # default type is an integer
+        turn_time = Random(400)
+        OnFwd(OUT_AC, 75)
+        Wait(move_time)
+        OnRev(OUT_A, 75)
+        Wait(turn_time)
diff --git a/pynxc/tutorial_samples/3_spiral.py b/pynxc/tutorial_samples/3_spiral.py
new file mode 100644
index 0000000..90f9f5e
--- /dev/null
+++ b/pynxc/tutorial_samples/3_spiral.py
@@ -0,0 +1,14 @@
+DEFINE TURN_TIME=360
+
+def main():
+    
+    move_time = 200           # set the initial value
+    for repeat in range(50):
+    
+        OnFwd(OUT_AC, 75)
+        Wait(move_time)       # use the variable for sleeping
+        OnRev(OUT_C, 75)
+        Wait(TURN_TIME)
+        move_time += 200         # increase the variable
+
+    Off(OUT_AC)
diff --git a/pynxc/tutorial_samples/3_variables.py b/pynxc/tutorial_samples/3_variables.py
new file mode 100644
index 0000000..00ae642
--- /dev/null
+++ b/pynxc/tutorial_samples/3_variables.py
@@ -0,0 +1,15 @@
+bbb=ccc=5.0
+values=Integer([])
+
+def main():
+    aaa = 10
+    bbb = 20 * 5
+    ccc = bbb
+    ccc /= aaa
+    ccc -= 5         
+    aaa = 10 * (ccc + 3) # aaa is now equal to 80
+    ArrayInit(values, 0, 10) # allocate 10 elements = 0
+    values[0] = aaa
+    values[1] = bbb
+    values[2] = aaa*bbb
+    values[3] = ccc
diff --git a/pynxc/tutorial_samples/4_if.py b/pynxc/tutorial_samples/4_if.py
new file mode 100644
index 0000000..3f1365f
--- /dev/null
+++ b/pynxc/tutorial_samples/4_if.py
@@ -0,0 +1,16 @@
+DEFINE MOVE_TIME=500
+DEFINE TURN_TIME=360
+
+a=0
+
+def main():
+    while True:
+        
+        OnFwd(OUT_AC, 75)
+        Wait(MOVE_TIME)
+        if Random() > 0:
+            OnRev(OUT_C, 75)
+        else:
+            OnRev(OUT_A, 75)
+            
+        Wait(TURN_TIME)
diff --git a/pynxc/tutorial_samples/5_light.py b/pynxc/tutorial_samples/5_light.py
new file mode 100644
index 0000000..0f2cbee
--- /dev/null
+++ b/pynxc/tutorial_samples/5_light.py
@@ -0,0 +1,14 @@
+DEFINE THRESHOLD=40
+
+def main():
+    DefineSensors(None,None,LIGHT,None)
+    OnFwd(OUT_AC, 75)
+    while True:
+        if SensorVal(2) > THRESHOLD:
+            OnRev(OUT_C, 75)
+            Wait(100)
+            
+            while SensorVal(2) > THRESHOLD:
+                pass
+            
+            OnFwd(OUT_AC, 75)
diff --git a/pynxc/tutorial_samples/5_sound.py b/pynxc/tutorial_samples/5_sound.py
new file mode 100644
index 0000000..ee8c146
--- /dev/null
+++ b/pynxc/tutorial_samples/5_sound.py
@@ -0,0 +1,20 @@
+DEFINE THRESHOLD=40
+DEFINE MIC=SensorVal(2)
+
+def main():
+    DefineSensors(None,SOUND,None,None)
+    while True: 
+        while (MIC <= THRESHOLD):
+            pass
+        
+        OnFwd(OUT_AC, 75)
+        Wait(300)
+         
+         
+        while (MIC <= THRESHOLD):
+           pass
+
+        Off(OUT_AC)
+        Wait(300)
+
+
diff --git a/pynxc/tutorial_samples/5_touch.py b/pynxc/tutorial_samples/5_touch.py
new file mode 100644
index 0000000..3c37439
--- /dev/null
+++ b/pynxc/tutorial_samples/5_touch.py
@@ -0,0 +1,10 @@
+
+def main():
+    DefineSensors(TOUCH,None,None,None)
+    OnFwd(OUT_AC, 75)
+    while True:
+        if SensorVal(1) == 1:
+        
+            OnRev(OUT_AC, 75); Wait(300)
+            OnFwd(OUT_A, 75); Wait(300)
+            OnFwd(OUT_AC, 75)
diff --git a/pynxc/tutorial_samples/5_ultrasonic.py b/pynxc/tutorial_samples/5_ultrasonic.py
new file mode 100644
index 0000000..40503bf
--- /dev/null
+++ b/pynxc/tutorial_samples/5_ultrasonic.py
@@ -0,0 +1,13 @@
+# in cm
+DEFINE NEAR=15
+
+def main():
+    DefineSensors(None,None,None,EYES)
+    while True:
+        OnFwd(OUT_AC,50)
+        while SensorVal(4)>NEAR:
+            pass
+        
+        Off(OUT_AC)
+        OnRev(OUT_C,100)
+        Wait(800)
diff --git a/pynxc/tutorial_samples/5_wait.py b/pynxc/tutorial_samples/5_wait.py
new file mode 100644
index 0000000..dcf93f1
--- /dev/null
+++ b/pynxc/tutorial_samples/5_wait.py
@@ -0,0 +1,6 @@
+def main():
+    DefineSensors(TOUCH,None,None,None)
+    OnFwd(OUT_AC, 75)
+    while  SensorVal(1) != 1:
+        pass
+    Off(OUT_AC)
diff --git a/pynxc/tutorial_samples/6_define_a.py b/pynxc/tutorial_samples/6_define_a.py
new file mode 100644
index 0000000..2f08c50
--- /dev/null
+++ b/pynxc/tutorial_samples/6_define_a.py
@@ -0,0 +1,13 @@
+DEFINE turn_around=OnRev(OUT_B, 75); Wait(3400); a=5; OnFwd(OUT_AB, 75);
+
+def main():
+    a=0
+    OnFwd(OUT_AB, 75)
+    Wait(1000)
+    turn_around
+    Wait(2000)
+    turn_around
+    Wait(1000)
+    turn_around
+    Off(OUT_AB)
+    
diff --git a/pynxc/tutorial_samples/6_define_b.py b/pynxc/tutorial_samples/6_define_b.py
new file mode 100644
index 0000000..0e21654
--- /dev/null
+++ b/pynxc/tutorial_samples/6_define_b.py
@@ -0,0 +1,16 @@
+DEFINE turn_right(s,t)=OnFwd(OUT_A, s);OnRev(OUT_B, s);Wait(t);
+DEFINE turn_left(s,t)=OnRev(OUT_A, s);OnFwd(OUT_B, s);Wait(t);
+DEFINE forwards(s,t)=OnFwd(OUT_AB, s);Wait(t);
+DEFINE backwards(s,t)=OnRev(OUT_AB, s);Wait(t);
+
+def main():
+
+    backwards(50,10000)
+    forwards(50,10000)
+    turn_left(75,750)
+    forwards(75,1000)
+    backwards(75,2000)
+    forwards(75,1000)
+    turn_right(75,750)
+    forwards(30,2000)
+    Off(OUT_AB)
diff --git a/pynxc/tutorial_samples/6_inline.py b/pynxc/tutorial_samples/6_inline.py
new file mode 100644
index 0000000..7465a6d
--- /dev/null
+++ b/pynxc/tutorial_samples/6_inline.py
@@ -0,0 +1,17 @@
+def inline_turn_around():
+    OnRev(OUT_C, 75) 
+    Wait(900)
+    OnFwd(OUT_AC, 75)
+
+def main():
+
+    OnFwd(OUT_AC, 75)
+    Wait(1000)
+    inline_turn_around()
+    Wait(2000)
+    inline_turn_around()
+    Wait(1000)
+    inline_turn_around()
+    Off(OUT_AC)
+    
+
diff --git a/pynxc/tutorial_samples/6_inline2.py b/pynxc/tutorial_samples/6_inline2.py
new file mode 100644
index 0000000..0447f11
--- /dev/null
+++ b/pynxc/tutorial_samples/6_inline2.py
@@ -0,0 +1,16 @@
+def inline_turn_around(pwr,turntime):
+
+    OnRev(OUT_C, pwr)
+    Wait(turntime)
+    OnFwd(OUT_AC, pwr)
+
+def main():
+
+    OnFwd(OUT_AC, 75)
+    Wait(1000)
+    inline_turn_around(75, 2000)
+    Wait(2000)
+    inline_turn_around(75, 500)
+    Wait(1000)
+    inline_turn_around(75, 3000)
+    Off(OUT_AC)
diff --git a/pynxc/tutorial_samples/6_subs.py b/pynxc/tutorial_samples/6_subs.py
new file mode 100644
index 0000000..b35313c
--- /dev/null
+++ b/pynxc/tutorial_samples/6_subs.py
@@ -0,0 +1,13 @@
+def sub_turn_around(pwr):
+    OnRev(OUT_C, pwr); Wait(900)
+    OnFwd(OUT_AC, pwr)
+
+def main():
+    OnFwd(OUT_AC, 75)
+    Wait(1000)
+    sub_turn_around(75)
+    Wait(2000)
+    sub_turn_around(75)
+    Wait(1000)
+    sub_turn_around(75)
+    Off(OUT_AC)
diff --git a/pynxc/tutorial_samples/6_tasks.py b/pynxc/tutorial_samples/6_tasks.py
new file mode 100644
index 0000000..8651d3c
--- /dev/null
+++ b/pynxc/tutorial_samples/6_tasks.py
@@ -0,0 +1,23 @@
+
+moveMutex=Mutex()
+
+def task_move_square():
+    while True:
+        Acquire(moveMutex)
+        OnFwd(OUT_AC, 75); Wait(1000)
+        OnRev(OUT_C, 75); Wait(500)
+        Release(moveMutex)
+
+def task_check_sensors():
+  while True:
+      if SENSOR_1 == 1:
+          Acquire(moveMutex)
+          OnRev(OUT_AC, 75); Wait(500)
+          OnFwd(OUT_A, 75); Wait(500)
+          Release(moveMutex)
+
+def main():
+    Precedes(task_move_square, task_check_sensors)
+    SetSensorTouch(IN_1)
+
+
diff --git a/pynxc/tutorial_samples/7_drive_music.py b/pynxc/tutorial_samples/7_drive_music.py
new file mode 100644
index 0000000..750be10
--- /dev/null
+++ b/pynxc/tutorial_samples/7_drive_music.py
@@ -0,0 +1,15 @@
+def task_music():
+    while True:
+        PlayTone(262,400);  Wait(500);
+        PlayTone(294,400);  Wait(500);
+        PlayTone(330,400);  Wait(500);
+        PlayTone(294,400);  Wait(500);
+
+def task_movement():
+
+    while True:
+        OnFwd(OUT_AC, 75); Wait(3000);
+        OnRev(OUT_AC, 75); Wait(3000);
+
+def main():
+    Precedes(task_music, task_movement);
diff --git a/pynxc/tutorial_samples/7_music.py b/pynxc/tutorial_samples/7_music.py
new file mode 100644
index 0000000..824647d
--- /dev/null
+++ b/pynxc/tutorial_samples/7_music.py
@@ -0,0 +1,8 @@
+DEFINE VOL=3
+
+def main():
+    PlayToneEx(262,400,VOL,False);  Wait(500)
+    PlayToneEx(294,400,VOL,False);  Wait(500)
+    PlayToneEx(330,400,VOL,False);  Wait(500)
+    PlayToneEx(294,400,VOL,False);  Wait(500)
+    PlayToneEx(262,1600,VOL,False); Wait(2000)
diff --git a/pynxc/tutorial_samples/7_sounds.py b/pynxc/tutorial_samples/7_sounds.py
new file mode 100644
index 0000000..90de9fb
--- /dev/null
+++ b/pynxc/tutorial_samples/7_sounds.py
@@ -0,0 +1,22 @@
+DEFINE TIME=300
+DEFINE MAXVOL=7
+DEFINE MINVOL=1
+DEFINE MIDVOL=3
+
+DEFINE pause_4th=Wait(TIME)
+DEFINE pause_8th=Wait(TIME/2)
+DEFINE note_4th=PlayFileEx("! Click.rso",MIDVOL,FALSE); pause_4th
+DEFINE note_8th=PlayFileEx("! Click.rso",MAXVOL,FALSE); pause_8th
+
+def main():
+    PlayFileEx("! Startup.rso",MINVOL,False)
+    Wait(2000)
+    note_4th
+    note_8th
+    note_8th
+    note_4th
+    note_4th
+    pause_4th
+    note_4th
+    note_4th
+    Wait(100)
diff --git a/pynxc/tutorial_samples/8_OnReg.py b/pynxc/tutorial_samples/8_OnReg.py
new file mode 100644
index 0000000..864fa83
--- /dev/null
+++ b/pynxc/tutorial_samples/8_OnReg.py
@@ -0,0 +1,17 @@
+def main():
+
+    OnFwdReg(OUT_AC,50,OUT_REGMODE_IDLE)
+    Wait(2000)
+    Off(OUT_AC)
+    PlayTone(4000,50)
+    Wait(1000)
+    ResetAllTachoCounts(OUT_AC)
+    OnFwdReg(OUT_AC,50,OUT_REGMODE_SPEED)
+    Wait(2000)
+    Off(OUT_AC)
+    PlayTone(4000,50)
+    Wait(1000)
+    OnFwdReg(OUT_AC,50,OUT_REGMODE_SYNC)
+    Wait(2000)
+    Off(OUT_AC)
+    
diff --git a/pynxc/tutorial_samples/8_OnSync.py b/pynxc/tutorial_samples/8_OnSync.py
new file mode 100644
index 0000000..20ac0d9
--- /dev/null
+++ b/pynxc/tutorial_samples/8_OnSync.py
@@ -0,0 +1,15 @@
+def main():
+    PlayTone(5000,30)
+    OnFwdSync(OUT_AC,50,0)
+    Wait(1000)
+    PlayTone(5000,30)
+    OnFwdSync(OUT_AC,50,20)
+    Wait(1000)
+    PlayTone(5000,30)
+    OnFwdSync(OUT_AC,50,-40)
+    Wait(1000)
+    PlayTone(5000,30)
+    OnRevSync(OUT_AC,50,90)
+    Wait(1000)
+    Off(OUT_AC)
+
diff --git a/pynxc/tutorial_samples/8_PID.py b/pynxc/tutorial_samples/8_PID.py
new file mode 100644
index 0000000..a4c09a2
--- /dev/null
+++ b/pynxc/tutorial_samples/8_PID.py
@@ -0,0 +1,8 @@
+DEFINE P=40
+DEFINE I=40
+DEFINE D=70
+
+def main():
+    RotateMotorPID(OUT_A, 100, 180, P, I, D)
+    Wait(2000)
+
diff --git a/pynxc/tutorial_samples/8_RotateMotor.py b/pynxc/tutorial_samples/8_RotateMotor.py
new file mode 100644
index 0000000..10704f9
--- /dev/null
+++ b/pynxc/tutorial_samples/8_RotateMotor.py
@@ -0,0 +1,4 @@
+def main():
+    RotateMotor(OUT_AC, 50,360)
+    RotateMotor(OUT_C, 50,-360)
+
diff --git a/pynxc/tutorial_samples/8_RotateMotorEx.py b/pynxc/tutorial_samples/8_RotateMotorEx.py
new file mode 100644
index 0000000..c40d796
--- /dev/null
+++ b/pynxc/tutorial_samples/8_RotateMotorEx.py
@@ -0,0 +1,7 @@
+def main():
+
+    RotateMotorEx(OUT_AC, 50, 360, 0, True,False)
+    RotateMotorEx(OUT_AC, 50, 360, 40, True,False)
+    RotateMotorEx(OUT_AC, 50, 360, -40, True,False)
+    RotateMotorEx(OUT_AC, 50, 360, 100, True,True)
+
diff --git a/pynxc/tutorial_samples/8_float.py b/pynxc/tutorial_samples/8_float.py
new file mode 100644
index 0000000..678404b
--- /dev/null
+++ b/pynxc/tutorial_samples/8_float.py
@@ -0,0 +1,8 @@
+def main():
+    OnFwd(OUT_AC, 75)
+    Wait(500)
+    Off(OUT_AC)
+    Wait(1000)
+    OnFwd(OUT_AC, 75)
+    Wait(500)
+    Coast(OUT_AC)
diff --git a/pynxc/tutorial_samples/9_multiple.py b/pynxc/tutorial_samples/9_multiple.py
new file mode 100644
index 0000000..7ec8aa2
--- /dev/null
+++ b/pynxc/tutorial_samples/9_multiple.py
@@ -0,0 +1,38 @@
+moveMutex=Mutex()
+
+def task_moverandom():
+
+    while True:
+
+        ttt = Random(500) + 40
+        tt2 = Random(1)
+        Acquire(moveMutex)
+        if tt2 > 0:
+            OnRev(OUT_A, 75) 
+            OnFwd(OUT_C, 75) 
+            Wait(ttt)
+        else:
+            OnRev(OUT_C, 75) 
+            OnFwd(OUT_A, 75) 
+            Wait(ttt)
+            
+        ttt = Random(1500) + 50
+        OnFwd(OUT_AC, 75)
+        Wait(ttt)
+        Release(moveMutex)
+
+def task_submain():
+
+    SetSensorType(IN_1, SENSOR_TYPE_LIGHT);
+    SetSensorMode(IN_1, SENSOR_MODE_RAW);
+    while True:
+
+        if (SENSOR_1 < 100) or (SENSOR_1 > 750):
+            Acquire(moveMutex)
+            OnRev(OUT_AC, 75); Wait(300)
+            Release(moveMutex)
+
+def main():
+    Precedes(task_moverandom, task_submain)
+
+
diff --git a/pynxc/tutorial_samples/9_pulses.py b/pynxc/tutorial_samples/9_pulses.py
new file mode 100644
index 0000000..81eef2e
--- /dev/null
+++ b/pynxc/tutorial_samples/9_pulses.py
@@ -0,0 +1,14 @@
+def main():
+    SetSensorType(IN_1, SENSOR_TYPE_TOUCH)
+    SetSensorMode(IN_1, SENSOR_MODE_PULSE)
+    while True:
+
+        ClearSensor(IN_1)
+        while SENSOR_1<=0:
+            pass
+        
+        Wait(500)
+        if SENSOR_1 == 1:
+            Off(OUT_AC)
+        if SENSOR_1 == 2:
+            OnFwd(OUT_AC, 75)
diff --git a/pynxc/tutorial_samples/9_rotation.py b/pynxc/tutorial_samples/9_rotation.py
new file mode 100644
index 0000000..6d91afa
--- /dev/null
+++ b/pynxc/tutorial_samples/9_rotation.py
@@ -0,0 +1,17 @@
+def main():
+
+
+    SetSensor(IN_1, SENSOR_ROTATION); ClearSensor(IN_1)
+    SetSensor(IN_3, SENSOR_ROTATION); ClearSensor(IN_3)
+    
+    while True:
+        if SENSOR_1 < SENSOR_3:
+            OnFwd(OUT_A, 75)
+            Float(OUT_C)
+        elif SENSOR_1 > SENSOR_3:
+            OnFwd(OUT_C, 75)
+            Float(OUT_A)
+        else:
+            OnFwd(OUT_AC, 75)
+            
+
diff --git a/pynxc/tutorial_samples/test1.py b/pynxc/tutorial_samples/test1.py
new file mode 100644
index 0000000..27cc889
--- /dev/null
+++ b/pynxc/tutorial_samples/test1.py
@@ -0,0 +1,9 @@
+def main():
+
+    OnFwd(OUT_A,100)
+    OnFwd(OUT_B,100)
+    
+    Wait(5000)
+    
+    Off(OUT_A)
+    Off(OUT_B)
diff --git a/pynxc/tutorial_samples/test_string.py b/pynxc/tutorial_samples/test_string.py
new file mode 100644
index 0000000..2feef3f
--- /dev/null
+++ b/pynxc/tutorial_samples/test_string.py
@@ -0,0 +1,5 @@
+def main():
+
+    a='hello'
+    
+    
\ No newline at end of file
diff --git a/pynxc/waxy/.DS_Store b/pynxc/waxy/.DS_Store
new file mode 100644
index 0000000..e9b3bb0
--- /dev/null
+++ b/pynxc/waxy/.DS_Store
diff --git a/pynxc/waxy/__init__.py b/pynxc/waxy/__init__.py
new file mode 100644
index 0000000..b9cae90
--- /dev/null
+++ b/pynxc/waxy/__init__.py
@@ -0,0 +1,95 @@
+WAXY_VERSION = "0.0.1"
+WAXY_VERSION_TUPLE = tuple(map(int, WAXY_VERSION.split(".")))
+
+__version__ = WAXY_VERSION
+
+__original_copyright__ = "Copyright 2003-2006 Hans Nowak"
+__original_author__ = "Hans Nowak (hans@zephyrfalcon.org)"
+
+# this code is lifted from the, now unsupported, project wax
+# i've cleaned things up a bit, taken out some things that
+# don't work in the new wx, and keep modifying it to suit
+# my needs
+
+__license__ = "BSD"
+__author__ = "Brian Blais (bblais@bryant.edu)"
+
+
+
+# updated for recent wx, and modified as needed by bblais
+
+import sys
+import core # builtin functions and such
+import wx
+
+from wx import Yield
+from constants import *
+from wx import Point
+
+from aboutbox import AboutBox
+from application import Application
+from artprovider import ArtProvider
+from bitmap import Bitmap, BitmapFromData, BitmapFromFile
+from bitmapbutton import BitmapButton
+from button import Button
+from canvas import Canvas
+from checkbox import CheckBox
+from checklistbox import CheckListBox
+from colordb import ColorDB
+from colourdialog import ColourDialog,ColorDialog
+from combobox import ComboBox
+from containers import Container # do we need to publish this?
+from customdialog import CustomDialog
+from dialog import Dialog, showdialog
+from directorydialog import DirectoryDialog,ChooseDirectory
+from dragdrop import FileDropTarget, TextDropTarget, URLDropTarget
+from dropdownbox import DropDownBox
+from filedialog import FileDialog
+##from filetreeview import FileTreeView
+##from findreplacedialog import FindReplaceDialog
+##from flexgridframe import FlexGridFrame
+from flexgridpanel import FlexGridPanel
+from font import Font
+##from fontdialog import FontDialog
+from frame import Frame, HorizontalFrame, VerticalFrame
+from grid import Grid
+##from gridframe import GridFrame
+from gridpanel import GridPanel
+##from groupbox import GroupBox
+from htmlwindow import HTMLWindow
+from image import Image, AddImageHandler, AddAllImageHandlers, ImageAsBitmap,ImagePanel
+from imagelist import ImageList
+from keys import keys
+from label import Label
+from line import Line
+from listbox import ListBox
+##from listview import ListView, ListItemAttr
+#from maskedtextbox import MaskedTextBox
+from menu import Menu, MenuBar
+from messagedialog import MessageDialog, ShowMessage, Error
+##from mdiframes import MDIChildFrame, MDIParentFrame
+from mousepointer import MousePointers
+from multichoicedialog import MultiChoiceDialog
+from notebook import NoteBook
+##from overlaypanel import OverlayPanel
+from panel import Panel, HorizontalPanel, VerticalPanel
+##from plainframe import PlainFrame
+##from plainpanel import PlainPanel
+from progressdialog import ProgressDialog
+##from radiobutton import RadioButton
+##from scrollframe import ScrollFrame
+##from shell import PyCrust, PyCrustFilling
+##from simpleeditor import SimpleEditor
+from singlechoicedialog import SingleChoiceDialog
+from slider import Slider,FloatSlider
+from splitter import Splitter
+from statusbar import StatusBar
+##from styledtextbox import StyledTextBox
+##from systemsettings import SystemSettings
+from textbox import TextBox
+from textentrydialog import TextEntryDialog,IntegerInputDialog,Input_Integer,FloatInputDialog,FloatInputDialog
+##from timer import Timer
+from treelistview import TreeListView
+from treeview import TreeView
+from waxyobject import WaxyObject
+
diff --git a/pynxc/waxy/__init__.py~ b/pynxc/waxy/__init__.py~
new file mode 100644
index 0000000..1964639
--- /dev/null
+++ b/pynxc/waxy/__init__.py~
@@ -0,0 +1,77 @@
+WAXY_VERSION = "0.0.1"
+WAXY_VERSION_TUPLE = tuple(map(int, WAXY_VERSION.split(".")))
+
+__version__ = WAXY_VERSION
+__license__ = "BSD"
+__author__ = "Brian Blais (bblais@bryant.edu)"
+
+import sys
+import core # builtin functions and such
+import wx
+
+from aboutbox import AboutBox
+from application import Application
+from artprovider import ArtProvider
+from bitmap import Bitmap, BitmapFromData, BitmapFromFile
+from bitmapbutton import BitmapButton
+from button import Button
+###from canvas import Canvas
+from checkbox import CheckBox
+from checklistbox import CheckListBox
+from colordb import ColorDB
+from colourdialog import ColourDialog,ColorDialog
+from combobox import ComboBox
+from containers import Container # do we need to publish this?
+from customdialog import CustomDialog
+from dialog import Dialog, showdialog
+from directorydialog import DirectoryDialog,ChooseDirectory
+###from dragdrop import FileDropTarget, TextDropTarget, URLDropTarget
+from dropdownbox import DropDownBox
+from filedialog import FileDialog
+##from filetreeview import FileTreeView
+##from findreplacedialog import FindReplaceDialog
+##from flexgridframe import FlexGridFrame
+from flexgridpanel import FlexGridPanel
+from font import Font
+##from fontdialog import FontDialog
+from frame import Frame, HorizontalFrame, VerticalFrame
+##from grid import Grid
+##from gridframe import GridFrame
+##from gridpanel import GridPanel
+##from groupbox import GroupBox
+from htmlwindow import HTMLWindow
+from image import Image, AddImageHandler, AddAllImageHandlers, ImageAsBitmap
+##from imagelist import ImageList
+from keys import keys
+from label import Label
+from line import Line
+from listbox import ListBox
+##from listview import ListView, ListItemAttr
+#from maskedtextbox import MaskedTextBox
+from menu import Menu, MenuBar
+from messagedialog import MessageDialog, ShowMessage
+##from mdiframes import MDIChildFrame, MDIParentFrame
+##from mousepointer import MousePointers
+from multichoicedialog import MultiChoiceDialog
+from notebook import NoteBook
+##from overlaypanel import OverlayPanel
+from panel import Panel, HorizontalPanel, VerticalPanel
+##from plainframe import PlainFrame
+##from plainpanel import PlainPanel
+from progressdialog import ProgressDialog
+##from radiobutton import RadioButton
+##from scrollframe import ScrollFrame
+##from shell import PyCrust, PyCrustFilling
+##from simpleeditor import SimpleEditor
+from singlechoicedialog import SingleChoiceDialog
+from splitter import Splitter
+##from statusbar import StatusBar
+##from styledtextbox import StyledTextBox
+##from systemsettings import SystemSettings
+from textbox import TextBox
+from textentrydialog import TextEntryDialog
+##from timer import Timer
+##from treelistview import TreeListView
+##from treeview import TreeView
+from waxyobject import WaxyObject
+
diff --git a/pynxc/waxy/aboutbox.py b/pynxc/waxy/aboutbox.py
new file mode 100644
index 0000000..884e406
--- /dev/null
+++ b/pynxc/waxy/aboutbox.py
@@ -0,0 +1,43 @@
+import wx
+from wx.lib.wordwrap import wordwrap
+
+def AboutBox(parent,info=None,
+            name='',version='',copyright='',description='',url='',
+            webtitle='',developers=[],license=''):
+    
+            
+    if not info:
+        
+        info={}
+        info['name']=name
+        info['version']=version
+        info['copyright']=copyright
+        info['description']=description
+        info['url']=url
+        info['webtitle']=webtitle
+        info['developers']=developers
+        info['license']=license
+        
+        
+        
+    ainfo = wx.AboutDialogInfo()
+    ainfo.Name = info['name']
+    ainfo.Version = info['version']
+    ainfo.Copyright = info['copyright']
+    
+    if '(C)' not in ainfo.Copyright:
+        ainfo.Copyright='(C) '+info.Copyright
+        
+    ainfo.Description = wordwrap(info['description'],
+                            350, wx.ClientDC(parent))
+    ainfo.WebSite = (info['url'],info['webtitle'])
+    ainfo.Developers = info['developers']
+
+    ainfo.License = wordwrap(info['license'], 500, wx.ClientDC(parent))
+
+    # Then we call wx.AboutBox giving it that info object
+        
+    
+
+    wx.AboutBox(ainfo)
+
diff --git a/pynxc/waxy/aboutbox.py~ b/pynxc/waxy/aboutbox.py~
new file mode 100644
index 0000000..d84fc97
--- /dev/null
+++ b/pynxc/waxy/aboutbox.py~
@@ -0,0 +1,43 @@
+import wx
+from wx.lib.wordwrap import wordwrap
+
+def AboutBox(parent,info=None,
+            name='',version='',copyright='',description='',url='',
+            webtitle='',developers=[],license=''):
+    
+            
+    if not info:
+        
+        info={}
+        info['name']=name
+        info['version']=version
+        info['copyright']=copyright
+        info['description']=description
+        info['url']=url
+        info['webtitle']=webtitle
+        info['developers']=developers
+        info['license']=license
+        
+        
+        
+    ainfo = wx.AboutDialogInfo()
+    ainfo.Name = info['name']
+    ainfo.Version = info['version']
+    ainfo.Copyright = info['copyright']
+    
+    if '(C)' not in ainfo.Copyright:
+        ainfo.Copyright='(C) '+info.Copyright
+        
+    ainfo.Description = wordwrap(info['description'],
+                            350, wx.ClientDC(parent))
+    ainfo.WebSite = (info['url'],info['webtitle'])
+    ainfo.Developers = info['developers']
+
+    ainfo.License = wordwrap(info['license'], 500, wx.ClientDC(parent))
+
+    # Then we call wx.AboutBox giving it that info object
+        
+    
+
+    wx.AboutBox(info)
+
diff --git a/pynxc/waxy/application.py b/pynxc/waxy/application.py
new file mode 100644
index 0000000..c6c01fd
--- /dev/null
+++ b/pynxc/waxy/application.py
@@ -0,0 +1,32 @@
+# application.py
+
+import wx
+import sys
+#from waxconfig import WaxConfig
+#import font
+
+class Application(wx.App):
+    def __init__(self, frameklass, *args, **kwargs):
+        # takes a frame *class* plus arbitrary options.  these options will
+        # be passed to the frame constructor.
+        self.frameklass = frameklass
+        self.args = args
+        self.kwargs = kwargs
+
+        # when set, the app uses the stdout/stderr window; off by default
+        use_stdout_window = 0
+        if kwargs.has_key('use_stdout_window'):
+            use_stdout_window = kwargs['use_stdout_window']
+            del kwargs['use_stdout_window']
+        wx.App.__init__(self, use_stdout_window)
+
+    def OnInit(self):
+        self.mainframe = self.frameklass(*self.args, **self.kwargs)
+        if hasattr(self.mainframe.__class__, "__ExceptHook__"):
+            sys.excepthook = self.mainframe.__ExceptHook__
+        self.mainframe.Show(True)
+        self.SetTopWindow(self.mainframe)
+        return True
+
+    def Run(self):
+        self.MainLoop()
diff --git a/pynxc/waxy/application.py~ b/pynxc/waxy/application.py~
new file mode 100644
index 0000000..eab2e66
--- /dev/null
+++ b/pynxc/waxy/application.py~
@@ -0,0 +1,36 @@
+# application.py
+
+import wx
+import sys
+#from waxconfig import WaxConfig
+#import font
+
+class Application(wx.App):
+    def __init__(self, frameklass, *args, **kwargs):
+        # takes a frame *class* plus arbitrary options.  these options will
+        # be passed to the frame constructor.
+        self.frameklass = frameklass
+        self.args = args
+        self.kwargs = kwargs
+
+        # when set, the app uses the stdout/stderr window; off by default
+        use_stdout_window = 0
+        if kwargs.has_key('use_stdout_window'):
+            use_stdout_window = kwargs['use_stdout_window']
+            del kwargs['use_stdout_window']
+        wx.App.__init__(self, use_stdout_window)
+
+    def OnInit(self):
+        if isinstance(WaxConfig.default_font, tuple):
+            WaxConfig.default_font = font.Font(*WaxConfig.default_font)
+        else:
+            print >> sys.stderr, "Warning: This construct will not work in future wxPython versions"
+        self.mainframe = self.frameklass(*self.args, **self.kwargs)
+        if hasattr(self.mainframe.__class__, "__ExceptHook__"):
+            sys.excepthook = self.mainframe.__ExceptHook__
+        self.mainframe.Show(True)
+        self.SetTopWindow(self.mainframe)
+        return True
+
+    def Run(self):
+        self.MainLoop()
diff --git a/pynxc/waxy/artprovider.py b/pynxc/waxy/artprovider.py
new file mode 100644
index 0000000..29014ad
--- /dev/null
+++ b/pynxc/waxy/artprovider.py
@@ -0,0 +1,126 @@
+# artprovider.py
+
+import wx, os
+import string
+import cStringIO
+
+ARTCLIENTS = [ "ART_TOOLBAR",
+               "ART_MENU",
+               "ART_FRAME_ICON",
+               "ART_CMN_DIALOG",
+               "ART_HELP_BROWSER",
+               "ART_MESSAGE_BOX",
+               "ART_OTHER",
+               ]
+
+ARTIDS = [ "ART_ADD_BOOKMARK",
+           "ART_DEL_BOOKMARK",
+           "ART_HELP_SIDE_PANEL",
+           "ART_HELP_SETTINGS",
+           "ART_HELP_BOOK",
+           "ART_HELP_FOLDER",
+           "ART_HELP_PAGE",
+           "ART_GO_BACK",
+           "ART_GO_FORWARD",
+           "ART_GO_UP",
+           "ART_GO_DOWN",
+           "ART_GO_TO_PARENT",
+           "ART_GO_HOME",
+           "ART_FILE_OPEN",
+           "ART_PRINT",
+           "ART_HELP",
+           "ART_TIP",
+           "ART_REPORT_VIEW",
+           "ART_LIST_VIEW",
+           "ART_NEW_DIR",
+           "ART_FOLDER",
+           "ART_GO_DIR_UP",
+           "ART_EXECUTABLE_FILE",
+           "ART_NORMAL_FILE",
+           "ART_TICK_MARK",
+           "ART_CROSS_MARK",
+           "ART_ERROR",
+           "ART_QUESTION",
+           "ART_WARNING",
+           "ART_INFORMATION",
+           ]
+
+class ArtProvider(object):
+    def __init__(self, size=wx.DefaultSize):
+        self.custom = {}
+        self.clients = []
+        for client in ARTCLIENTS:
+            self.clients.append(client[4:].lower())
+        self.images = []
+        for image in ARTIDS:
+            self.images.append(image[4:].lower())
+        self.size = size
+        self._usecustom = False
+
+    def _SetUseCustom(self, value):
+        if self._usecustom and not value:
+            wx.ArtProvider_PopProvider()
+        elif value and not self._usecustom:
+            wx.ArtProvider_PushProvider(ArtPushProvider(self))
+        self._usecustom = value
+
+    def _GetUseCustom(self):
+        return self.__usecustom
+
+    UseCustom = property(_GetUseCustom, _SetUseCustom, doc="Custom art enable")
+
+    def _GetWxArtIds(self, name, client):
+        imageid = "ART_" + name.upper()
+        clientid = "ART_" + client.upper()
+        wx_image = getattr(wx, imageid, name)
+        wx_client = getattr(wx, clientid, client)
+        return wx_image, wx_client
+
+    def GetBitmap(self, image, client='other', size=None):
+        wx_image, wx_client = self._GetWxArtIds(image, client)
+        if size == None:
+            size = self.size
+        return wx.ArtProvider_GetBitmap(wx_image, wx_client, size)
+
+    def GetIcon(self, name, client='other', size=None):
+        wx_image, wx_client = self._GetWxArtIds(name, client)
+        if size == None:
+            size = self.size
+        return wx.ArtProvider_GetIcon(wx_image, wx_client, size)
+
+    def RegisterImage(self, image, name, client='other', size=None):
+        wx_image, wx_client = self._GetWxArtIds(name, client)
+        if size == None:
+            size = self.size
+        keyword = string.join([wx_client,"::", wx_image, "::", str(size[0]),":", str(size[1])],'')
+        if size != (-1,-1):
+            image.Rescale(size[0], size[1])
+        self.custom[keyword] = wx.BitmapFromImage(image)
+        if wx_client not in self.clients:
+            if not wx_client.startswith('wxART'):
+                self.clients.append(wx_client)
+        if wx_image not in self.images:
+            if not wx_image.startswith('wxART'):
+                self.images.append(wx_image)
+
+    def RegisterFromFile(self, filename, name, client='other', size=None):
+        image = wx.Image(opj(filename), wx.BITMAP_TYPE_ANY)
+        self.RegisterImage(image, name, client, size)
+
+    def RegisterFromData(self, stream, name, client='other', size=None):
+        image = wx.ImageFromStream(stream)
+        self.RegisterImage(image, name, client, size)
+
+class ArtPushProvider(wx.ArtProvider):
+    # custom class for push_provider
+    def __init__(self, waxArtProvider):
+        wx.ArtProvider.__init__(self)
+        self.__AP = waxArtProvider
+
+    def CreateBitmap(self, artid, client, size):
+        keyword = string.join([client,"::", artid, "::", str(size[0]),":", str(size[1])],'')
+        bmp = wx.NullBitmap
+        if self.__AP.custom.has_key(keyword):
+            bmp = self.__AP.custom[keyword]
+        return bmp
+
diff --git a/pynxc/waxy/bitmap.py b/pynxc/waxy/bitmap.py
new file mode 100644
index 0000000..49f0f8a
--- /dev/null
+++ b/pynxc/waxy/bitmap.py
@@ -0,0 +1,29 @@
+# bitmap.py
+
+import wx
+import waxyobject
+import image
+import cStringIO
+
+# XXX not sure what to do with this
+class Bitmap(wx.StaticBitmap, waxyobject.WaxyObject):
+
+    def __init__(self, parent, bitmap):
+        if isinstance(bitmap, str) or isinstance(bitmap, unicode):
+            bitmap = BitmapFromFile(bitmap)
+        wx.StaticBitmap.__init__(self, parent, wx.NewId(), bitmap)
+        # XXX supposedly you can load this from file too?
+
+#
+# use these functions for convenience...
+# unfortunately, they return wxBitmaps, not Bitmaps
+
+def BitmapFromData(data):
+    stream = cStringIO.StringIO(data)
+    z = wx.ImageFromStream(stream)
+    return wx.BitmapFromImage(z)
+
+def BitmapFromFile(filename):
+    data = open(filename, 'rb').read()
+    return BitmapFromData(data)
+
diff --git a/pynxc/waxy/bitmap.py~ b/pynxc/waxy/bitmap.py~
new file mode 100644
index 0000000..7a3629c
--- /dev/null
+++ b/pynxc/waxy/bitmap.py~
@@ -0,0 +1,29 @@
+# bitmap.py
+
+import wx
+import waxobject
+import image
+import cStringIO
+
+# XXX not sure what to do with this
+class Bitmap(wx.StaticBitmap, waxobject.WaxObject):
+
+    def __init__(self, parent, bitmap):
+        if isinstance(bitmap, str) or isinstance(bitmap, unicode):
+            bitmap = BitmapFromFile(bitmap)
+        wx.StaticBitmap.__init__(self, parent, wx.NewId(), bitmap)
+        # XXX supposedly you can load this from file too?
+
+#
+# use these functions for convenience...
+# unfortunately, they return wxBitmaps, not Bitmaps
+
+def BitmapFromData(data):
+    stream = cStringIO.StringIO(data)
+    z = wx.ImageFromStream(stream)
+    return wx.BitmapFromImage(z)
+
+def BitmapFromFile(filename):
+    data = open(filename, 'rb').read()
+    return BitmapFromData(data)
+
diff --git a/pynxc/waxy/bitmapbutton.py b/pynxc/waxy/bitmapbutton.py
new file mode 100644
index 0000000..0955387
--- /dev/null
+++ b/pynxc/waxy/bitmapbutton.py
@@ -0,0 +1,49 @@
+# bitmapbutton.py
+
+import button
+import containers
+import waxyobject
+import wx
+import os
+import styles
+
+def opj(path):
+    """Convert paths to the platform-specific separator"""
+    return apply(os.path.join, tuple(path.split('/')))
+
+def loadbitmap(filename):
+    """Load a bitmap from an image file"""
+    return wx.Image(opj(filename), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
+
+class BitmapButton(wx.BitmapButton, waxyobject.WaxyObject):
+
+    __events__ = {
+        'Click': wx.EVT_BUTTON,
+    }
+
+    def __init__(self, parent, bmp, event=None, default_style=1, size=None, **kwargs):
+        if isinstance(bmp, str) or isinstance(bmp, unicode):
+            bmp = loadbitmap(bmp)
+        style = default_style and 4 or 0
+        style |= self._params(kwargs)
+        style |= self._params(kwargs, button.Button.__styles__)
+        style |= styles.window(kwargs)
+
+        wx.BitmapButton.__init__(self, parent, wx.NewId(), bmp, 
+         size=size or (-1,-1), style=style)
+
+        self.BindEvents()
+        if event:
+            self.OnClick = event
+        styles.properties(self, kwargs)
+
+    __styles__ = {
+        'align': ({
+            'left': wx.BU_LEFT,
+            'top': wx.BU_TOP,
+            'right': wx.BU_RIGHT,
+            'bottom': wx.BU_BOTTOM,
+        }, styles.DICTSTART),
+        'autodraw': (wx.BU_AUTODRAW, styles.NORMAL),
+    }
+    
diff --git a/pynxc/waxy/bitmapbutton.py~ b/pynxc/waxy/bitmapbutton.py~
new file mode 100644
index 0000000..2c4e286
--- /dev/null
+++ b/pynxc/waxy/bitmapbutton.py~
@@ -0,0 +1,50 @@
+# bitmapbutton.py
+
+import button
+import containers
+import waxyobject
+import wx
+import os
+import styles
+
+def opj(path):
+    """Convert paths to the platform-specific separator"""
+    return apply(os.path.join, tuple(path.split('/')))
+
+def loadbitmap(filename):
+    """Load a bitmap from an image file"""
+    return wx.Image(opj(filename), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
+
+class BitmapButton(wx.BitmapButton, waxyobject.WaxyObject):
+
+    __events__ = {
+        'Click': wx.EVT_BUTTON,
+    }
+
+    def __init__(self, parent, bmp, event=None, default_style=1, size=None, **kwargs):
+        if isinstance(bmp, str) or isinstance(bmp, unicode):
+            bmp = loadbitmap(bmp)
+        style = default_style and 4 or 0
+        style |= self._params(kwargs)
+        style |= self._params(kwargs, button.Button.__styles__)
+        style |= styles.window(kwargs)
+
+        wx.BitmapButton.__init__(self, parent, wx.NewId(), bmp, 
+         size=size or (-1,-1), style=style)
+
+        self.SetDefaultFont()
+        self.BindEvents()
+        if event:
+            self.OnClick = event
+        styles.properties(self, kwargs)
+
+    __styles__ = {
+        'align': ({
+            'left': wx.BU_LEFT,
+            'top': wx.BU_TOP,
+            'right': wx.BU_RIGHT,
+            'bottom': wx.BU_BOTTOM,
+        }, styles.DICTSTART),
+        'autodraw': (wx.BU_AUTODRAW, styles.NORMAL),
+    }
+    
diff --git a/pynxc/waxy/button.py b/pynxc/waxy/button.py
new file mode 100644
index 0000000..1538abc
--- /dev/null
+++ b/pynxc/waxy/button.py
@@ -0,0 +1,54 @@
+# button.py
+
+import containers
+import waxyobject
+import wx
+import styles
+
+
+class Button(wx.Button, waxyobject.WaxyObject):
+
+    __events__ = {
+        'Click': wx.EVT_BUTTON,
+    }
+
+    def __init__(self, parent, text="", event=None, size=None,
+                        tooltip="", default=False, disabled=False, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.Button.__init__(self, parent, wx.NewId(), text, size=size or (-1,-1),
+         style=style)
+
+        self.BindEvents()
+        if event:
+            self.OnClick = event
+
+        if tooltip:
+            self.SetToolTipString(tooltip)
+            
+        if default:
+            self.SetDefault()
+            
+        if disabled:
+            self.Enable(False)
+            
+        styles.properties(self, kwargs)
+
+    #
+    # style parameters
+    
+    __styles__ = {
+        'align': ({
+            "left": wx.BU_LEFT,
+            "right": wx.BU_RIGHT,
+            "bottom": wx.BU_BOTTOM,
+            "top": wx.BU_TOP,
+            "exact": wx.BU_EXACTFIT,
+        }, styles.DICTSTART),
+        'flat': (wx.NO_BORDER, styles.NORMAL), 
+          # seems to have no effect on Windows XP
+        'exactfit': (wx.BU_EXACTFIT, styles.NORMAL),
+    }
+
diff --git a/pynxc/waxy/button.py~ b/pynxc/waxy/button.py~
new file mode 100644
index 0000000..764674d
--- /dev/null
+++ b/pynxc/waxy/button.py~
@@ -0,0 +1,51 @@
+# button.py
+
+import containers
+import waxyobject
+import wx
+import styles
+
+
+class Button(wx.Button, waxyobject.WaxyObject):
+
+    __events__ = {
+        'Click': wx.EVT_BUTTON,
+    }
+
+    def __init__(self, parent, text="", event=None, size=None,
+                        tooltip="", default=False, disabled=False, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.Button.__init__(self, parent, wx.NewId(), text, size=size or (-1,-1),
+         style=style)
+
+        self.BindEvents()
+        if event:
+            self.OnClick = event
+
+        if tooltip:
+            self.SetToolTipString(tooltip)
+            
+        if default:
+            self.SetDefault()
+            
+        styles.properties(self, kwargs)
+
+    #
+    # style parameters
+    
+    __styles__ = {
+        'align': ({
+            "left": wx.BU_LEFT,
+            "right": wx.BU_RIGHT,
+            "bottom": wx.BU_BOTTOM,
+            "top": wx.BU_TOP,
+            "exact": wx.BU_EXACTFIT,
+        }, styles.DICTSTART),
+        'flat': (wx.NO_BORDER, styles.NORMAL), 
+          # seems to have no effect on Windows XP
+        'exactfit': (wx.BU_EXACTFIT, styles.NORMAL),
+    }
+
diff --git a/pynxc/waxy/canvas.py b/pynxc/waxy/canvas.py
new file mode 100644
index 0000000..072fb85
--- /dev/null
+++ b/pynxc/waxy/canvas.py
@@ -0,0 +1,33 @@
+# canvas.py
+
+import wx
+import waxyobject
+
+class Canvas(wx.ScrolledWindow, waxyobject.WaxyObject):
+
+    __events__ = {
+        'Paint': wx.EVT_PAINT,
+    }
+
+    def __init__(self, parent):
+        wx.ScrolledWindow.__init__(self, parent, wx.NewId())
+        self.Init()
+
+        self.BindEvents()
+
+    def _OnPaint(self, event=None):
+        self.OnPaint(event)
+    def OnPaint(self, event=None):
+        dc = wx.PaintDC(self)
+        self.PrepareDC(dc)
+        self.OnDraw(dc)
+        event.Skip()
+
+    def OnDraw(self, dc):
+        # override to draw on the canvas
+        pass
+
+    def Init(self):
+        # override to place scrollbars, set color, etc.
+        pass
+
diff --git a/pynxc/waxy/checkbox.py b/pynxc/waxy/checkbox.py
new file mode 100644
index 0000000..143a260
--- /dev/null
+++ b/pynxc/waxy/checkbox.py
@@ -0,0 +1,71 @@
+# checkbox.py

+

+import wx

+import waxyobject

+import styles

+

+class CheckBox(wx.CheckBox, waxyobject.WaxyObject):

+

+    __events__ = {

+        'Check': wx.EVT_CHECKBOX,

+    }

+

+

+    def __init__(self, parent, text='', size=None, border=1, **kwargs):

+        flags = 0

+        if not border:

+            flags |= wx.NO_BORDER

+        # XXX not sure what border does... there doesn't seem to be a visible

+        # difference?

+        flags |= self._params(kwargs)

+        flags |= styles.window(kwargs)

+

+        wx.CheckBox.__init__(self, parent, wx.NewId(), text, None,

+         size or (-1, -1), flags)

+

+        self.BindEvents()

+        styles.properties(self, kwargs)

+

+    _3states = {

+        'checked': wx.CHK_CHECKED,

+        'unchecked': wx.CHK_UNCHECKED,

+        'undetermined': wx.CHK_UNDETERMINED,

+    }

+

+    def Set3StateValue(self, state):

+        for name, flag in self._3states.items():

+            if name.startswith(state):

+                wx.CheckBox.Set3StateValue(self, flag)

+                break

+        else:

+            raise KeyError, "Unknown state: %s" % (state,)

+

+    def Get3StateValue(self):

+        value = wx.CheckBox.Get3StateValue(self)

+        if value == wx.CHK_CHECKED:

+            return 'checked'

+        elif value == wx.CHK_UNCHECKED:

+            return 'unchecked'

+        elif value == wx.CHK_UNDETERMINED:

+            return 'undetermined'

+        else:

+            return '?'

+

+    #

+    # style parameters

+

+    _checkbox_states = {

+        2: wx.CHK_2STATE,

+        3: wx.CHK_3STATE,

+    }

+

+    _checkbox_align = {

+        'left': 0,

+        'right': wx.ALIGN_RIGHT,

+    }

+

+    def _params(self, kwargs):

+        flags = 0

+        flags |= styles.styledict('states', self._checkbox_states, kwargs, wx.CHK_2STATE)

+        flags |= styles.styledictstart('align', self._checkbox_align, kwargs, 0)

+        return flags

diff --git a/pynxc/waxy/checkbox.py~ b/pynxc/waxy/checkbox.py~
new file mode 100644
index 0000000..4a595f6
--- /dev/null
+++ b/pynxc/waxy/checkbox.py~
@@ -0,0 +1,72 @@
+# checkbox.py

+

+import wx

+import waxyobject

+import styles

+

+class CheckBox(wx.CheckBox, waxyobject.WaxyObject):

+

+    __events__ = {

+        'Check': wx.EVT_CHECKBOX,

+    }

+

+

+    def __init__(self, parent, text='', size=None, border=1, **kwargs):

+        flags = 0

+        if not border:

+            flags |= wx.NO_BORDER

+        # XXX not sure what border does... there doesn't seem to be a visible

+        # difference?

+        flags |= self._params(kwargs)

+        flags |= styles.window(kwargs)

+

+        wx.CheckBox.__init__(self, parent, wx.NewId(), text, None,

+         size or (-1, -1), flags)

+

+        self.BindEvents()

+        self.SetDefaultFont()

+        styles.properties(self, kwargs)

+

+    _3states = {

+        'checked': wx.CHK_CHECKED,

+        'unchecked': wx.CHK_UNCHECKED,

+        'undetermined': wx.CHK_UNDETERMINED,

+    }

+

+    def Set3StateValue(self, state):

+        for name, flag in self._3states.items():

+            if name.startswith(state):

+                wx.CheckBox.Set3StateValue(self, flag)

+                break

+        else:

+            raise KeyError, "Unknown state: %s" % (state,)

+

+    def Get3StateValue(self):

+        value = wx.CheckBox.Get3StateValue(self)

+        if value == wx.CHK_CHECKED:

+            return 'checked'

+        elif value == wx.CHK_UNCHECKED:

+            return 'unchecked'

+        elif value == wx.CHK_UNDETERMINED:

+            return 'undetermined'

+        else:

+            return '?'

+

+    #

+    # style parameters

+

+    _checkbox_states = {

+        2: wx.CHK_2STATE,

+        3: wx.CHK_3STATE,

+    }

+

+    _checkbox_align = {

+        'left': 0,

+        'right': wx.ALIGN_RIGHT,

+    }

+

+    def _params(self, kwargs):

+        flags = 0

+        flags |= styles.styledict('states', self._checkbox_states, kwargs, wx.CHK_2STATE)

+        flags |= styles.styledictstart('align', self._checkbox_align, kwargs, 0)

+        return flags

diff --git a/pynxc/waxy/checklistbox.py b/pynxc/waxy/checklistbox.py
new file mode 100644
index 0000000..67176a6
--- /dev/null
+++ b/pynxc/waxy/checklistbox.py
@@ -0,0 +1,27 @@
+# checklistbox.py
+# XXX doesn't work on Mac.
+
+# todo: styles (if any)
+
+import wx
+import waxyobject
+import styles
+
+class CheckListBox(wx.CheckListBox, waxyobject.WaxyObject):
+
+    __events__ = {
+        'CheckListBox': wx.EVT_CHECKLISTBOX,
+    }
+
+    def __init__(self, parent, choices=[], size=None, **kwargs):
+        style = 0
+        #style |= checklistbox_params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.CheckListBox.__init__(self, parent, wx.NewId(), choices=choices, style=style)
+
+        self.BindEvents()
+
+        styles.properties(self, kwargs)
+
+
diff --git a/pynxc/waxy/checklistbox.py~ b/pynxc/waxy/checklistbox.py~
new file mode 100644
index 0000000..34c7dd2
--- /dev/null
+++ b/pynxc/waxy/checklistbox.py~
@@ -0,0 +1,28 @@
+# checklistbox.py
+# XXX doesn't work on Mac.
+
+# todo: styles (if any)
+
+import wx
+import waxyobject
+import styles
+
+class CheckListBox(wx.CheckListBox, waxyobject.WaxyObject):
+
+    __events__ = {
+        'CheckListBox': wx.EVT_CHECKLISTBOX,
+    }
+
+    def __init__(self, parent, choices=[], size=None, **kwargs):
+        style = 0
+        #style |= checklistbox_params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.CheckListBox.__init__(self, parent, wx.NewId(), choices=choices, style=style)
+
+        self.SetDefaultFont()
+        self.BindEvents()
+
+        styles.properties(self, kwargs)
+
+
diff --git a/pynxc/waxy/colordb.py b/pynxc/waxy/colordb.py
new file mode 100644
index 0000000..b2cb6cd
--- /dev/null
+++ b/pynxc/waxy/colordb.py
@@ -0,0 +1,844 @@
+# colordb.py
+# Allows access to Tk's color names, plus adds some other functions.
+# You can now do obj.SetForegroundColor(colordb['papayawhip'])! ;-)
+# Or: obj.SetForegroundColor('papayawhip').
+# or even: obj.ForegroundColor = 'papayawhip'!
+
+import math
+import operator
+import string
+
+def convert_color(color):
+    if isinstance(color, str):
+        color = _colordb.byname(color)
+        # TODO: maybe colors in the format "#007FC0"?
+    return color
+
+data = {
+ 'alice blue': (240, 248, 255),
+ 'aliceblue': (240, 248, 255),
+ 'antique white': (250, 235, 215),
+ 'antiquewhite': (250, 235, 215),
+ 'antiquewhite1': (255, 239, 219),
+ 'antiquewhite2': (238, 223, 204),
+ 'antiquewhite3': (205, 192, 176),
+ 'antiquewhite4': (139, 131, 120),
+ 'aquamarine': (127, 255, 212),
+ 'aquamarine1': (127, 255, 212),
+ 'aquamarine2': (118, 238, 198),
+ 'aquamarine3': (102, 205, 170),
+ 'aquamarine4': (69, 139, 116),
+ 'azure': (240, 255, 255),
+ 'azure1': (240, 255, 255),
+ 'azure2': (224, 238, 238),
+ 'azure3': (193, 205, 205),
+ 'azure4': (131, 139, 139),
+ 'beige': (245, 245, 220),
+ 'bisque': (255, 228, 196),
+ 'bisque1': (255, 228, 196),
+ 'bisque2': (238, 213, 183),
+ 'bisque3': (205, 183, 158),
+ 'bisque4': (139, 125, 107),
+ 'black': (0, 0, 0),
+ 'blanched almond': (255, 235, 205),
+ 'blanchedalmond': (255, 235, 205),
+ 'blue': (0, 0, 255),
+ 'blue violet': (138, 43, 226),
+ 'blue1': (0, 0, 255),
+ 'blue2': (0, 0, 238),
+ 'blue3': (0, 0, 205),
+ 'blue4': (0, 0, 139),
+ 'blueviolet': (138, 43, 226),
+ 'brown': (165, 42, 42),
+ 'brown1': (255, 64, 64),
+ 'brown2': (238, 59, 59),
+ 'brown3': (205, 51, 51),
+ 'brown4': (139, 35, 35),
+ 'burlywood': (222, 184, 135),
+ 'burlywood1': (255, 211, 155),
+ 'burlywood2': (238, 197, 145),
+ 'burlywood3': (205, 170, 125),
+ 'burlywood4': (139, 115, 85),
+ 'cadet blue': (95, 158, 160),
+ 'cadetblue': (95, 158, 160),
+ 'cadetblue1': (152, 245, 255),
+ 'cadetblue2': (142, 229, 238),
+ 'cadetblue3': (122, 197, 205),
+ 'cadetblue4': (83, 134, 139),
+ 'chartreuse': (127, 255, 0),
+ 'chartreuse1': (127, 255, 0),
+ 'chartreuse2': (118, 238, 0),
+ 'chartreuse3': (102, 205, 0),
+ 'chartreuse4': (69, 139, 0),
+ 'chocolate': (210, 105, 30),
+ 'chocolate1': (255, 127, 36),
+ 'chocolate2': (238, 118, 33),
+ 'chocolate3': (205, 102, 29),
+ 'chocolate4': (139, 69, 19),
+ 'coral': (255, 127, 80),
+ 'coral1': (255, 114, 86),
+ 'coral2': (238, 106, 80),
+ 'coral3': (205, 91, 69),
+ 'coral4': (139, 62, 47),
+ 'cornflower blue': (100, 149, 237),
+ 'cornflowerblue': (100, 149, 237),
+ 'cornsilk': (255, 248, 220),
+ 'cornsilk1': (255, 248, 220),
+ 'cornsilk2': (238, 232, 205),
+ 'cornsilk3': (205, 200, 177),
+ 'cornsilk4': (139, 136, 120),
+ 'cyan': (0, 255, 255),
+ 'cyan1': (0, 255, 255),
+ 'cyan2': (0, 238, 238),
+ 'cyan3': (0, 205, 205),
+ 'cyan4': (0, 139, 139),
+ 'dark blue': (0, 0, 139),
+ 'dark cyan': (0, 139, 139),
+ 'dark goldenrod': (184, 134, 11),
+ 'dark gray': (169, 169, 169),
+ 'dark green': (0, 100, 0),
+ 'dark grey': (169, 169, 169),
+ 'dark khaki': (189, 183, 107),
+ 'dark magenta': (139, 0, 139),
+ 'dark olive green': (85, 107, 47),
+ 'dark orange': (255, 140, 0),
+ 'dark orchid': (153, 50, 204),
+ 'dark red': (139, 0, 0),
+ 'dark salmon': (233, 150, 122),
+ 'dark sea green': (143, 188, 143),
+ 'dark slate blue': (72, 61, 139),
+ 'dark slate gray': (47, 79, 79),
+ 'dark slate grey': (47, 79, 79),
+ 'dark turquoise': (0, 206, 209),
+ 'dark violet': (148, 0, 211),
+ 'darkblue': (0, 0, 139),
+ 'darkcyan': (0, 139, 139),
+ 'darkgoldenrod': (184, 134, 11),
+ 'darkgoldenrod1': (255, 185, 15),
+ 'darkgoldenrod2': (238, 173, 14),
+ 'darkgoldenrod3': (205, 149, 12),
+ 'darkgoldenrod4': (139, 101, 8),
+ 'darkgray': (169, 169, 169),
+ 'darkgreen': (0, 100, 0),
+ 'darkgrey': (169, 169, 169),
+ 'darkkhaki': (189, 183, 107),
+ 'darkmagenta': (139, 0, 139),
+ 'darkolivegreen': (85, 107, 47),
+ 'darkolivegreen1': (202, 255, 112),
+ 'darkolivegreen2': (188, 238, 104),
+ 'darkolivegreen3': (162, 205, 90),
+ 'darkolivegreen4': (110, 139, 61),
+ 'darkorange': (255, 140, 0),
+ 'darkorange1': (255, 127, 0),
+ 'darkorange2': (238, 118, 0),
+ 'darkorange3': (205, 102, 0),
+ 'darkorange4': (139, 69, 0),
+ 'darkorchid': (153, 50, 204),
+ 'darkorchid1': (191, 62, 255),
+ 'darkorchid2': (178, 58, 238),
+ 'darkorchid3': (154, 50, 205),
+ 'darkorchid4': (104, 34, 139),
+ 'darkred': (139, 0, 0),
+ 'darksalmon': (233, 150, 122),
+ 'darkseagreen': (143, 188, 143),
+ 'darkseagreen1': (193, 255, 193),
+ 'darkseagreen2': (180, 238, 180),
+ 'darkseagreen3': (155, 205, 155),
+ 'darkseagreen4': (105, 139, 105),
+ 'darkslateblue': (72, 61, 139),
+ 'darkslategray': (47, 79, 79),
+ 'darkslategray1': (151, 255, 255),
+ 'darkslategray2': (141, 238, 238),
+ 'darkslategray3': (121, 205, 205),
+ 'darkslategray4': (82, 139, 139),
+ 'darkslategrey': (47, 79, 79),
+ 'darkturquoise': (0, 206, 209),
+ 'darkviolet': (148, 0, 211),
+ 'deep pink': (255, 20, 147),
+ 'deep sky blue': (0, 191, 255),
+ 'deeppink': (255, 20, 147),
+ 'deeppink1': (255, 20, 147),
+ 'deeppink2': (238, 18, 137),
+ 'deeppink3': (205, 16, 118),
+ 'deeppink4': (139, 10, 80),
+ 'deepskyblue': (0, 191, 255),
+ 'deepskyblue1': (0, 191, 255),
+ 'deepskyblue2': (0, 178, 238),
+ 'deepskyblue3': (0, 154, 205),
+ 'deepskyblue4': (0, 104, 139),
+ 'dim gray': (105, 105, 105),
+ 'dim grey': (105, 105, 105),
+ 'dimgray': (105, 105, 105),
+ 'dimgrey': (105, 105, 105),
+ 'dodger blue': (30, 144, 255),
+ 'dodgerblue': (30, 144, 255),
+ 'dodgerblue1': (30, 144, 255),
+ 'dodgerblue2': (28, 134, 238),
+ 'dodgerblue3': (24, 116, 205),
+ 'dodgerblue4': (16, 78, 139),
+ 'firebrick': (178, 34, 34),
+ 'firebrick1': (255, 48, 48),
+ 'firebrick2': (238, 44, 44),
+ 'firebrick3': (205, 38, 38),
+ 'firebrick4': (139, 26, 26),
+ 'floral white': (255, 250, 240),
+ 'floralwhite': (255, 250, 240),
+ 'forest green': (34, 139, 34),
+ 'forestgreen': (34, 139, 34),
+ 'gainsboro': (220, 220, 220),
+ 'ghost white': (248, 248, 255),
+ 'ghostwhite': (248, 248, 255),
+ 'gold': (255, 215, 0),
+ 'gold1': (255, 215, 0),
+ 'gold2': (238, 201, 0),
+ 'gold3': (205, 173, 0),
+ 'gold4': (139, 117, 0),
+ 'goldenrod': (218, 165, 32),
+ 'goldenrod1': (255, 193, 37),
+ 'goldenrod2': (238, 180, 34),
+ 'goldenrod3': (205, 155, 29),
+ 'goldenrod4': (139, 105, 20),
+ 'gray': (190, 190, 190),
+ 'gray0': (0, 0, 0),
+ 'gray1': (3, 3, 3),
+ 'gray10': (26, 26, 26),
+ 'gray100': (255, 255, 255),
+ 'gray11': (28, 28, 28),
+ 'gray12': (31, 31, 31),
+ 'gray13': (33, 33, 33),
+ 'gray14': (36, 36, 36),
+ 'gray15': (38, 38, 38),
+ 'gray16': (41, 41, 41),
+ 'gray17': (43, 43, 43),
+ 'gray18': (46, 46, 46),
+ 'gray19': (48, 48, 48),
+ 'gray2': (5, 5, 5),
+ 'gray20': (51, 51, 51),
+ 'gray21': (54, 54, 54),
+ 'gray22': (56, 56, 56),
+ 'gray23': (59, 59, 59),
+ 'gray24': (61, 61, 61),
+ 'gray25': (64, 64, 64),
+ 'gray26': (66, 66, 66),
+ 'gray27': (69, 69, 69),
+ 'gray28': (71, 71, 71),
+ 'gray29': (74, 74, 74),
+ 'gray3': (8, 8, 8),
+ 'gray30': (77, 77, 77),
+ 'gray31': (79, 79, 79),
+ 'gray32': (82, 82, 82),
+ 'gray33': (84, 84, 84),
+ 'gray34': (87, 87, 87),
+ 'gray35': (89, 89, 89),
+ 'gray36': (92, 92, 92),
+ 'gray37': (94, 94, 94),
+ 'gray38': (97, 97, 97),
+ 'gray39': (99, 99, 99),
+ 'gray4': (10, 10, 10),
+ 'gray40': (102, 102, 102),
+ 'gray41': (105, 105, 105),
+ 'gray42': (107, 107, 107),
+ 'gray43': (110, 110, 110),
+ 'gray44': (112, 112, 112),
+ 'gray45': (115, 115, 115),
+ 'gray46': (117, 117, 117),
+ 'gray47': (120, 120, 120),
+ 'gray48': (122, 122, 122),
+ 'gray49': (125, 125, 125),
+ 'gray5': (13, 13, 13),
+ 'gray50': (127, 127, 127),
+ 'gray51': (130, 130, 130),
+ 'gray52': (133, 133, 133),
+ 'gray53': (135, 135, 135),
+ 'gray54': (138, 138, 138),
+ 'gray55': (140, 140, 140),
+ 'gray56': (143, 143, 143),
+ 'gray57': (145, 145, 145),
+ 'gray58': (148, 148, 148),
+ 'gray59': (150, 150, 150),
+ 'gray6': (15, 15, 15),
+ 'gray60': (153, 153, 153),
+ 'gray61': (156, 156, 156),
+ 'gray62': (158, 158, 158),
+ 'gray63': (161, 161, 161),
+ 'gray64': (163, 163, 163),
+ 'gray65': (166, 166, 166),
+ 'gray66': (168, 168, 168),
+ 'gray67': (171, 171, 171),
+ 'gray68': (173, 173, 173),
+ 'gray69': (176, 176, 176),
+ 'gray7': (18, 18, 18),
+ 'gray70': (179, 179, 179),
+ 'gray71': (181, 181, 181),
+ 'gray72': (184, 184, 184),
+ 'gray73': (186, 186, 186),
+ 'gray74': (189, 189, 189),
+ 'gray75': (191, 191, 191),
+ 'gray76': (194, 194, 194),
+ 'gray77': (196, 196, 196),
+ 'gray78': (199, 199, 199),
+ 'gray79': (201, 201, 201),
+ 'gray8': (20, 20, 20),
+ 'gray80': (204, 204, 204),
+ 'gray81': (207, 207, 207),
+ 'gray82': (209, 209, 209),
+ 'gray83': (212, 212, 212),
+ 'gray84': (214, 214, 214),
+ 'gray85': (217, 217, 217),
+ 'gray86': (219, 219, 219),
+ 'gray87': (222, 222, 222),
+ 'gray88': (224, 224, 224),
+ 'gray89': (227, 227, 227),
+ 'gray9': (23, 23, 23),
+ 'gray90': (229, 229, 229),
+ 'gray91': (232, 232, 232),
+ 'gray92': (235, 235, 235),
+ 'gray93': (237, 237, 237),
+ 'gray94': (240, 240, 240),
+ 'gray95': (242, 242, 242),
+ 'gray96': (245, 245, 245),
+ 'gray97': (247, 247, 247),
+ 'gray98': (250, 250, 250),
+ 'gray99': (252, 252, 252),
+ 'green': (0, 255, 0),
+ 'green yellow': (173, 255, 47),
+ 'green1': (0, 255, 0),
+ 'green2': (0, 238, 0),
+ 'green3': (0, 205, 0),
+ 'green4': (0, 139, 0),
+ 'greenyellow': (173, 255, 47),
+ 'grey': (190, 190, 190),
+ 'grey0': (0, 0, 0),
+ 'grey1': (3, 3, 3),
+ 'grey10': (26, 26, 26),
+ 'grey100': (255, 255, 255),
+ 'grey11': (28, 28, 28),
+ 'grey12': (31, 31, 31),
+ 'grey13': (33, 33, 33),
+ 'grey14': (36, 36, 36),
+ 'grey15': (38, 38, 38),
+ 'grey16': (41, 41, 41),
+ 'grey17': (43, 43, 43),
+ 'grey18': (46, 46, 46),
+ 'grey19': (48, 48, 48),
+ 'grey2': (5, 5, 5),
+ 'grey20': (51, 51, 51),
+ 'grey21': (54, 54, 54),
+ 'grey22': (56, 56, 56),
+ 'grey23': (59, 59, 59),
+ 'grey24': (61, 61, 61),
+ 'grey25': (64, 64, 64),
+ 'grey26': (66, 66, 66),
+ 'grey27': (69, 69, 69),
+ 'grey28': (71, 71, 71),
+ 'grey29': (74, 74, 74),
+ 'grey3': (8, 8, 8),
+ 'grey30': (77, 77, 77),
+ 'grey31': (79, 79, 79),
+ 'grey32': (82, 82, 82),
+ 'grey33': (84, 84, 84),
+ 'grey34': (87, 87, 87),
+ 'grey35': (89, 89, 89),
+ 'grey36': (92, 92, 92),
+ 'grey37': (94, 94, 94),
+ 'grey38': (97, 97, 97),
+ 'grey39': (99, 99, 99),
+ 'grey4': (10, 10, 10),
+ 'grey40': (102, 102, 102),
+ 'grey41': (105, 105, 105),
+ 'grey42': (107, 107, 107),
+ 'grey43': (110, 110, 110),
+ 'grey44': (112, 112, 112),
+ 'grey45': (115, 115, 115),
+ 'grey46': (117, 117, 117),
+ 'grey47': (120, 120, 120),
+ 'grey48': (122, 122, 122),
+ 'grey49': (125, 125, 125),
+ 'grey5': (13, 13, 13),
+ 'grey50': (127, 127, 127),
+ 'grey51': (130, 130, 130),
+ 'grey52': (133, 133, 133),
+ 'grey53': (135, 135, 135),
+ 'grey54': (138, 138, 138),
+ 'grey55': (140, 140, 140),
+ 'grey56': (143, 143, 143),
+ 'grey57': (145, 145, 145),
+ 'grey58': (148, 148, 148),
+ 'grey59': (150, 150, 150),
+ 'grey6': (15, 15, 15),
+ 'grey60': (153, 153, 153),
+ 'grey61': (156, 156, 156),
+ 'grey62': (158, 158, 158),
+ 'grey63': (161, 161, 161),
+ 'grey64': (163, 163, 163),
+ 'grey65': (166, 166, 166),
+ 'grey66': (168, 168, 168),
+ 'grey67': (171, 171, 171),
+ 'grey68': (173, 173, 173),
+ 'grey69': (176, 176, 176),
+ 'grey7': (18, 18, 18),
+ 'grey70': (179, 179, 179),
+ 'grey71': (181, 181, 181),
+ 'grey72': (184, 184, 184),
+ 'grey73': (186, 186, 186),
+ 'grey74': (189, 189, 189),
+ 'grey75': (191, 191, 191),
+ 'grey76': (194, 194, 194),
+ 'grey77': (196, 196, 196),
+ 'grey78': (199, 199, 199),
+ 'grey79': (201, 201, 201),
+ 'grey8': (20, 20, 20),
+ 'grey80': (204, 204, 204),
+ 'grey81': (207, 207, 207),
+ 'grey82': (209, 209, 209),
+ 'grey83': (212, 212, 212),
+ 'grey84': (214, 214, 214),
+ 'grey85': (217, 217, 217),
+ 'grey86': (219, 219, 219),
+ 'grey87': (222, 222, 222),
+ 'grey88': (224, 224, 224),
+ 'grey89': (227, 227, 227),
+ 'grey9': (23, 23, 23),
+ 'grey90': (229, 229, 229),
+ 'grey91': (232, 232, 232),
+ 'grey92': (235, 235, 235),
+ 'grey93': (237, 237, 237),
+ 'grey94': (240, 240, 240),
+ 'grey95': (242, 242, 242),
+ 'grey96': (245, 245, 245),
+ 'grey97': (247, 247, 247),
+ 'grey98': (250, 250, 250),
+ 'grey99': (252, 252, 252),
+ 'honeydew': (240, 255, 240),
+ 'honeydew1': (240, 255, 240),
+ 'honeydew2': (224, 238, 224),
+ 'honeydew3': (193, 205, 193),
+ 'honeydew4': (131, 139, 131),
+ 'hot pink': (255, 105, 180),
+ 'hotpink': (255, 105, 180),
+ 'hotpink1': (255, 110, 180),
+ 'hotpink2': (238, 106, 167),
+ 'hotpink3': (205, 96, 144),
+ 'hotpink4': (139, 58, 98),
+ 'indian red': (205, 92, 92),
+ 'indianred': (205, 92, 92),
+ 'indianred1': (255, 106, 106),
+ 'indianred2': (238, 99, 99),
+ 'indianred3': (205, 85, 85),
+ 'indianred4': (139, 58, 58),
+ 'ivory': (255, 255, 240),
+ 'ivory1': (255, 255, 240),
+ 'ivory2': (238, 238, 224),
+ 'ivory3': (205, 205, 193),
+ 'ivory4': (139, 139, 131),
+ 'khaki': (240, 230, 140),
+ 'khaki1': (255, 246, 143),
+ 'khaki2': (238, 230, 133),
+ 'khaki3': (205, 198, 115),
+ 'khaki4': (139, 134, 78),
+ 'lavender': (230, 230, 250),
+ 'lavender blush': (255, 240, 245),
+ 'lavenderblush': (255, 240, 245),
+ 'lavenderblush1': (255, 240, 245),
+ 'lavenderblush2': (238, 224, 229),
+ 'lavenderblush3': (205, 193, 197),
+ 'lavenderblush4': (139, 131, 134),
+ 'lawn green': (124, 252, 0),
+ 'lawngreen': (124, 252, 0),
+ 'lemon chiffon': (255, 250, 205),
+ 'lemonchiffon': (255, 250, 205),
+ 'lemonchiffon1': (255, 250, 205),
+ 'lemonchiffon2': (238, 233, 191),
+ 'lemonchiffon3': (205, 201, 165),
+ 'lemonchiffon4': (139, 137, 112),
+ 'light blue': (173, 216, 230),
+ 'light coral': (240, 128, 128),
+ 'light cyan': (224, 255, 255),
+ 'light goldenrod': (238, 221, 130),
+ 'light goldenrod yellow': (250, 250, 210),
+ 'light gray': (211, 211, 211),
+ 'light green': (144, 238, 144),
+ 'light grey': (211, 211, 211),
+ 'light pink': (255, 182, 193),
+ 'light salmon': (255, 160, 122),
+ 'light sea green': (32, 178, 170),
+ 'light sky blue': (135, 206, 250),
+ 'light slate blue': (132, 112, 255),
+ 'light slate gray': (119, 136, 153),
+ 'light slate grey': (119, 136, 153),
+ 'light steel blue': (176, 196, 222),
+ 'light yellow': (255, 255, 224),
+ 'lightblue': (173, 216, 230),
+ 'lightblue1': (191, 239, 255),
+ 'lightblue2': (178, 223, 238),
+ 'lightblue3': (154, 192, 205),
+ 'lightblue4': (104, 131, 139),
+ 'lightcoral': (240, 128, 128),
+ 'lightcyan': (224, 255, 255),
+ 'lightcyan1': (224, 255, 255),
+ 'lightcyan2': (209, 238, 238),
+ 'lightcyan3': (180, 205, 205),
+ 'lightcyan4': (122, 139, 139),
+ 'lightgoldenrod': (238, 221, 130),
+ 'lightgoldenrod1': (255, 236, 139),
+ 'lightgoldenrod2': (238, 220, 130),
+ 'lightgoldenrod3': (205, 190, 112),
+ 'lightgoldenrod4': (139, 129, 76),
+ 'lightgoldenrodyellow': (250, 250, 210),
+ 'lightgray': (211, 211, 211),
+ 'lightgreen': (144, 238, 144),
+ 'lightgrey': (211, 211, 211),
+ 'lightpink': (255, 182, 193),
+ 'lightpink1': (255, 174, 185),
+ 'lightpink2': (238, 162, 173),
+ 'lightpink3': (205, 140, 149),
+ 'lightpink4': (139, 95, 101),
+ 'lightsalmon': (255, 160, 122),
+ 'lightsalmon1': (255, 160, 122),
+ 'lightsalmon2': (238, 149, 114),
+ 'lightsalmon3': (205, 129, 98),
+ 'lightsalmon4': (139, 87, 66),
+ 'lightseagreen': (32, 178, 170),
+ 'lightskyblue': (135, 206, 250),
+ 'lightskyblue1': (176, 226, 255),
+ 'lightskyblue2': (164, 211, 238),
+ 'lightskyblue3': (141, 182, 205),
+ 'lightskyblue4': (96, 123, 139),
+ 'lightslateblue': (132, 112, 255),
+ 'lightslategray': (119, 136, 153),
+ 'lightslategrey': (119, 136, 153),
+ 'lightsteelblue': (176, 196, 222),
+ 'lightsteelblue1': (202, 225, 255),
+ 'lightsteelblue2': (188, 210, 238),
+ 'lightsteelblue3': (162, 181, 205),
+ 'lightsteelblue4': (110, 123, 139),
+ 'lightyellow': (255, 255, 224),
+ 'lightyellow1': (255, 255, 224),
+ 'lightyellow2': (238, 238, 209),
+ 'lightyellow3': (205, 205, 180),
+ 'lightyellow4': (139, 139, 122),
+ 'lime green': (50, 205, 50),
+ 'limegreen': (50, 205, 50),
+ 'linen': (250, 240, 230),
+ 'magenta': (255, 0, 255),
+ 'magenta1': (255, 0, 255),
+ 'magenta2': (238, 0, 238),
+ 'magenta3': (205, 0, 205),
+ 'magenta4': (139, 0, 139),
+ 'maroon': (176, 48, 96),
+ 'maroon1': (255, 52, 179),
+ 'maroon2': (238, 48, 167),
+ 'maroon3': (205, 41, 144),
+ 'maroon4': (139, 28, 98),
+ 'medium aquamarine': (102, 205, 170),
+ 'medium blue': (0, 0, 205),
+ 'medium orchid': (186, 85, 211),
+ 'medium purple': (147, 112, 219),
+ 'medium sea green': (60, 179, 113),
+ 'medium slate blue': (123, 104, 238),
+ 'medium spring green': (0, 250, 154),
+ 'medium turquoise': (72, 209, 204),
+ 'medium violet red': (199, 21, 133),
+ 'mediumaquamarine': (102, 205, 170),
+ 'mediumblue': (0, 0, 205),
+ 'mediumorchid': (186, 85, 211),
+ 'mediumorchid1': (224, 102, 255),
+ 'mediumorchid2': (209, 95, 238),
+ 'mediumorchid3': (180, 82, 205),
+ 'mediumorchid4': (122, 55, 139),
+ 'mediumpurple': (147, 112, 219),
+ 'mediumpurple1': (171, 130, 255),
+ 'mediumpurple2': (159, 121, 238),
+ 'mediumpurple3': (137, 104, 205),
+ 'mediumpurple4': (93, 71, 139),
+ 'mediumseagreen': (60, 179, 113),
+ 'mediumslateblue': (123, 104, 238),
+ 'mediumspringgreen': (0, 250, 154),
+ 'mediumturquoise': (72, 209, 204),
+ 'mediumvioletred': (199, 21, 133),
+ 'midnight blue': (25, 25, 112),
+ 'midnightblue': (25, 25, 112),
+ 'mint cream': (245, 255, 250),
+ 'mintcream': (245, 255, 250),
+ 'misty rose': (255, 228, 225),
+ 'mistyrose': (255, 228, 225),
+ 'mistyrose1': (255, 228, 225),
+ 'mistyrose2': (238, 213, 210),
+ 'mistyrose3': (205, 183, 181),
+ 'mistyrose4': (139, 125, 123),
+ 'moccasin': (255, 228, 181),
+ 'navajo white': (255, 222, 173),
+ 'navajowhite': (255, 222, 173),
+ 'navajowhite1': (255, 222, 173),
+ 'navajowhite2': (238, 207, 161),
+ 'navajowhite3': (205, 179, 139),
+ 'navajowhite4': (139, 121, 94),
+ 'navy': (0, 0, 128),
+ 'navy blue': (0, 0, 128),
+ 'navyblue': (0, 0, 128),
+ 'old lace': (253, 245, 230),
+ 'oldlace': (253, 245, 230),
+ 'olive drab': (107, 142, 35),
+ 'olivedrab': (107, 142, 35),
+ 'olivedrab1': (192, 255, 62),
+ 'olivedrab2': (179, 238, 58),
+ 'olivedrab3': (154, 205, 50),
+ 'olivedrab4': (105, 139, 34),
+ 'orange': (255, 165, 0),
+ 'orange red': (255, 69, 0),
+ 'orange1': (255, 165, 0),
+ 'orange2': (238, 154, 0),
+ 'orange3': (205, 133, 0),
+ 'orange4': (139, 90, 0),
+ 'orangered': (255, 69, 0),
+ 'orangered1': (255, 69, 0),
+ 'orangered2': (238, 64, 0),
+ 'orangered3': (205, 55, 0),
+ 'orangered4': (139, 37, 0),
+ 'orchid': (218, 112, 214),
+ 'orchid1': (255, 131, 250),
+ 'orchid2': (238, 122, 233),
+ 'orchid3': (205, 105, 201),
+ 'orchid4': (139, 71, 137),
+ 'pale goldenrod': (238, 232, 170),
+ 'pale green': (152, 251, 152),
+ 'pale turquoise': (175, 238, 238),
+ 'pale violet red': (219, 112, 147),
+ 'palegoldenrod': (238, 232, 170),
+ 'palegreen': (152, 251, 152),
+ 'palegreen1': (154, 255, 154),
+ 'palegreen2': (144, 238, 144),
+ 'palegreen3': (124, 205, 124),
+ 'palegreen4': (84, 139, 84),
+ 'paleturquoise': (175, 238, 238),
+ 'paleturquoise1': (187, 255, 255),
+ 'paleturquoise2': (174, 238, 238),
+ 'paleturquoise3': (150, 205, 205),
+ 'paleturquoise4': (102, 139, 139),
+ 'palevioletred': (219, 112, 147),
+ 'palevioletred1': (255, 130, 171),
+ 'palevioletred2': (238, 121, 159),
+ 'palevioletred3': (205, 104, 127),
+ 'palevioletred4': (139, 71, 93),
+ 'papaya whip': (255, 239, 213),
+ 'papayawhip': (255, 239, 213),
+ 'peach puff': (255, 218, 185),
+ 'peachpuff': (255, 218, 185),
+ 'peachpuff1': (255, 218, 185),
+ 'peachpuff2': (238, 203, 173),
+ 'peachpuff3': (205, 175, 149),
+ 'peachpuff4': (139, 119, 101),
+ 'peru': (205, 133, 63),
+ 'pink': (255, 192, 203),
+ 'pink1': (255, 181, 197),
+ 'pink2': (238, 169, 184),
+ 'pink3': (205, 145, 158),
+ 'pink4': (139, 99, 108),
+ 'plum': (221, 160, 221),
+ 'plum1': (255, 187, 255),
+ 'plum2': (238, 174, 238),
+ 'plum3': (205, 150, 205),
+ 'plum4': (139, 102, 139),
+ 'powder blue': (176, 224, 230),
+ 'powderblue': (176, 224, 230),
+ 'purple': (160, 32, 240),
+ 'purple1': (155, 48, 255),
+ 'purple2': (145, 44, 238),
+ 'purple3': (125, 38, 205),
+ 'purple4': (85, 26, 139),
+ 'red': (255, 0, 0),
+ 'red1': (255, 0, 0),
+ 'red2': (238, 0, 0),
+ 'red3': (205, 0, 0),
+ 'red4': (139, 0, 0),
+ 'rosy brown': (188, 143, 143),
+ 'rosybrown': (188, 143, 143),
+ 'rosybrown1': (255, 193, 193),
+ 'rosybrown2': (238, 180, 180),
+ 'rosybrown3': (205, 155, 155),
+ 'rosybrown4': (139, 105, 105),
+ 'royal blue': (65, 105, 225),
+ 'royalblue': (65, 105, 225),
+ 'royalblue1': (72, 118, 255),
+ 'royalblue2': (67, 110, 238),
+ 'royalblue3': (58, 95, 205),
+ 'royalblue4': (39, 64, 139),
+ 'saddle brown': (139, 69, 19),
+ 'saddlebrown': (139, 69, 19),
+ 'salmon': (250, 128, 114),
+ 'salmon1': (255, 140, 105),
+ 'salmon2': (238, 130, 98),
+ 'salmon3': (205, 112, 84),
+ 'salmon4': (139, 76, 57),
+ 'sandy brown': (244, 164, 96),
+ 'sandybrown': (244, 164, 96),
+ 'sea green': (46, 139, 87),
+ 'seagreen': (46, 139, 87),
+ 'seagreen1': (84, 255, 159),
+ 'seagreen2': (78, 238, 148),
+ 'seagreen3': (67, 205, 128),
+ 'seagreen4': (46, 139, 87),
+ 'seashell': (255, 245, 238),
+ 'seashell1': (255, 245, 238),
+ 'seashell2': (238, 229, 222),
+ 'seashell3': (205, 197, 191),
+ 'seashell4': (139, 134, 130),
+ 'sienna': (160, 82, 45),
+ 'sienna1': (255, 130, 71),
+ 'sienna2': (238, 121, 66),
+ 'sienna3': (205, 104, 57),
+ 'sienna4': (139, 71, 38),
+ 'sky blue': (135, 206, 235),
+ 'skyblue': (135, 206, 235),
+ 'skyblue1': (135, 206, 255),
+ 'skyblue2': (126, 192, 238),
+ 'skyblue3': (108, 166, 205),
+ 'skyblue4': (74, 112, 139),
+ 'slate blue': (106, 90, 205),
+ 'slate gray': (112, 128, 144),
+ 'slate grey': (112, 128, 144),
+ 'slateblue': (106, 90, 205),
+ 'slateblue1': (131, 111, 255),
+ 'slateblue2': (122, 103, 238),
+ 'slateblue3': (105, 89, 205),
+ 'slateblue4': (71, 60, 139),
+ 'slategray': (112, 128, 144),
+ 'slategray1': (198, 226, 255),
+ 'slategray2': (185, 211, 238),
+ 'slategray3': (159, 182, 205),
+ 'slategray4': (108, 123, 139),
+ 'slategrey': (112, 128, 144),
+ 'snow': (255, 250, 250),
+ 'snow1': (255, 250, 250),
+ 'snow2': (238, 233, 233),
+ 'snow3': (205, 201, 201),
+ 'snow4': (139, 137, 137),
+ 'spring green': (0, 255, 127),
+ 'springgreen': (0, 255, 127),
+ 'springgreen1': (0, 255, 127),
+ 'springgreen2': (0, 238, 118),
+ 'springgreen3': (0, 205, 102),
+ 'springgreen4': (0, 139, 69),
+ 'steel blue': (70, 130, 180),
+ 'steelblue': (70, 130, 180),
+ 'steelblue1': (99, 184, 255),
+ 'steelblue2': (92, 172, 238),
+ 'steelblue3': (79, 148, 205),
+ 'steelblue4': (54, 100, 139),
+ 'tan': (210, 180, 140),
+ 'tan1': (255, 165, 79),
+ 'tan2': (238, 154, 73),
+ 'tan3': (205, 133, 63),
+ 'tan4': (139, 90, 43),
+ 'thistle': (216, 191, 216),
+ 'thistle1': (255, 225, 255),
+ 'thistle2': (238, 210, 238),
+ 'thistle3': (205, 181, 205),
+ 'thistle4': (139, 123, 139),
+ 'tomato': (255, 99, 71),
+ 'tomato1': (255, 99, 71),
+ 'tomato2': (238, 92, 66),
+ 'tomato3': (205, 79, 57),
+ 'tomato4': (139, 54, 38),
+ 'turquoise': (64, 224, 208),
+ 'turquoise1': (0, 245, 255),
+ 'turquoise2': (0, 229, 238),
+ 'turquoise3': (0, 197, 205),
+ 'turquoise4': (0, 134, 139),
+ 'violet': (238, 130, 238),
+ 'violet red': (208, 32, 144),
+ 'violetred': (208, 32, 144),
+ 'violetred1': (255, 62, 150),
+ 'violetred2': (238, 58, 140),
+ 'violetred3': (205, 50, 120),
+ 'violetred4': (139, 34, 82),
+ 'wheat': (245, 222, 179),
+ 'wheat1': (255, 231, 186),
+ 'wheat2': (238, 216, 174),
+ 'wheat3': (205, 186, 150),
+ 'wheat4': (139, 126, 102),
+ 'white': (255, 255, 255),
+ 'white smoke': (245, 245, 245),
+ 'whitesmoke': (245, 245, 245),
+ 'yellow': (255, 255, 0),
+ 'yellow green': (154, 205, 50),
+ 'yellow1': (255, 255, 0),
+ 'yellow2': (238, 238, 0),
+ 'yellow3': (205, 205, 0),
+ 'yellow4': (139, 139, 0),
+ 'yellowgreen': (154, 205, 50),
+}
+
+class ColorDB:
+
+    def __init__(self):
+        self.colordata = data
+
+    def byname(self, name):
+        """ Find color by name. """
+        try:
+            return self.colordata[name]
+        except KeyError:
+            pass
+        try:
+            return self.colordata[name.lower()]
+        except KeyError:
+            pass
+        raise KeyError, name
+
+    def blend(self, color1, color2):
+        """ "Blend" two colors, i.e. take their average RGB values. """
+        if isinstance(color1, str):
+            color1 = self.byname(color1)
+        if isinstance(color2, str):
+            color2 = self.byname(color2)
+        return tuple([(v1+v2)/2 for (v1, v2) in zip(color1, color2)])
+
+    def blend_weighed(self, color1, weight1, color2, weight2):
+        """ Blend two colors, using a weighing factor. """
+        if isinstance(color1, str):
+            color1 = self.byname(color1)
+        if isinstance(color2, str):
+            color2 = self.byname(color2)
+        total_weight = weight1 + weight2
+        return tuple([(v1*weight1 + v2*weight2) / total_weight
+                      for (v1, v2) in zip(color1, color2)])
+
+    def invert(self, color):
+        if isinstance(color, str):
+            color = self.byname(str)
+        return tuple([255 - v for v in color])
+
+    def findcolors(self, color, numresults=5):
+        """ Find the topmost <numresults> colors in the color database that
+            are closest to <color>.  Useful for finding the name of a color.
+            <color> is a tuple (r, g, b).
+
+            Returns a list of tuples (distance, name, (r, g, b).
+        """
+        if isinstance(color, str):
+            color = self.byname(color)
+
+        def sqr(x): return x*x
+        def distance(color1, color2):
+            squares = [sqr(abs(v1-v2)) for (v1, v2) in zip(color1, color2)]
+            sum = reduce(operator.add, squares)
+            return math.sqrt(sum)
+
+        results = {}
+        for (name, acolor) in self.colordata.items():
+            dist = distance(color, acolor)
+            results[dist] = (dist, name, acolor)
+
+        results = results.values()
+        results.sort()
+        return results[:numresults]
+
+    def __getitem__(self, name):
+        return self.byname(name)
+
+    def hex(self, name):
+        rgb = self.byname(name)
+        return "%02x%02x%02x" % rgb
+
+_colordb = ColorDB()
diff --git a/pynxc/waxy/colourdialog.py b/pynxc/waxy/colourdialog.py
new file mode 100644
index 0000000..5ccd797
--- /dev/null
+++ b/pynxc/waxy/colourdialog.py
@@ -0,0 +1,34 @@
+import wx
+import waxyobject
+from font import Font
+
+class ColourDialog(wx.ColourDialog, waxyobject.WaxyObject):
+
+    def __init__(self, parent):
+        wx.ColourDialog.__init__(self, parent)
+        # Ensure the full colour dialog is displayed, 
+        # not the abbreviated version.
+        self.GetColourData().SetChooseFull(True)
+
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.ColourDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
+
+    def GetChosenColour(self):
+        """ Shorthand... """
+        data = self.GetColourData()
+        color = data.GetColour().Get()
+        return color
+
+class ColorDialog(ColourDialog):
+    
+    
+    def GetChosenColor(self):
+        """ Shorthand... """
+        data = self.GetColourData()
+        color = data.GetColour().Get()
+        return color
diff --git a/pynxc/waxy/colourdialog.py~ b/pynxc/waxy/colourdialog.py~
new file mode 100644
index 0000000..5ccd797
--- /dev/null
+++ b/pynxc/waxy/colourdialog.py~
@@ -0,0 +1,34 @@
+import wx
+import waxyobject
+from font import Font
+
+class ColourDialog(wx.ColourDialog, waxyobject.WaxyObject):
+
+    def __init__(self, parent):
+        wx.ColourDialog.__init__(self, parent)
+        # Ensure the full colour dialog is displayed, 
+        # not the abbreviated version.
+        self.GetColourData().SetChooseFull(True)
+
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.ColourDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
+
+    def GetChosenColour(self):
+        """ Shorthand... """
+        data = self.GetColourData()
+        color = data.GetColour().Get()
+        return color
+
+class ColorDialog(ColourDialog):
+    
+    
+    def GetChosenColor(self):
+        """ Shorthand... """
+        data = self.GetColourData()
+        color = data.GetColour().Get()
+        return color
diff --git a/pynxc/waxy/combobox.py b/pynxc/waxy/combobox.py
new file mode 100644
index 0000000..a39cff3
--- /dev/null
+++ b/pynxc/waxy/combobox.py
@@ -0,0 +1,50 @@
+# combobox.py
+
+import wx
+import containers
+import styles
+import waxyobject
+
+class ComboBox(wx.ComboBox, waxyobject.WaxyObject):
+
+    __events__ = {
+        'Select': wx.EVT_COMBOBOX,
+        'TextChanged': wx.EVT_TEXT,
+    }
+
+    def __init__(self, parent, choices=[], size=None, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.ComboBox.__init__(self, parent, wx.NewId(), "",
+         size=size or (-1,-1), choices=choices, style=style)
+
+        self.BindEvents()
+        styles.properties(self, kwargs)
+
+    def SetItems(self, items):
+        """ Clear the internal list of items, and set new items.  <items> is
+            a list of 2-tuples (string, data). """
+        self.Clear()
+        for s, data in items:
+            self.Append(s, data)
+
+    def GetItems(self):
+        """ Return a list of 2-tuples (string, data). """
+        items = []
+        for i in range(self.GetCount()):
+            s = self.GetString(i)
+            data = self.GetClientData(i)
+            items.append((s, data))
+        return items
+
+    #
+    # style parameters
+
+    def _params(self, kwargs):
+        flags = wx.CB_DROPDOWN # default
+        flags |= styles.stylebool('simple', wx.CB_SIMPLE, kwargs)
+        flags |= styles.stylebool('readonly', wx.CB_READONLY, kwargs)
+        flags |= styles.stylebool('sort', wx.CB_SORT, kwargs)
+        return flags
diff --git a/pynxc/waxy/combobox.py~ b/pynxc/waxy/combobox.py~
new file mode 100644
index 0000000..853cdb4
--- /dev/null
+++ b/pynxc/waxy/combobox.py~
@@ -0,0 +1,51 @@
+# combobox.py
+
+import wx
+import containers
+import styles
+import waxyobject
+
+class ComboBox(wx.ComboBox, waxyobject.WaxyObject):
+
+    __events__ = {
+        'Select': wx.EVT_COMBOBOX,
+        'TextChanged': wx.EVT_TEXT,
+    }
+
+    def __init__(self, parent, choices=[], size=None, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.ComboBox.__init__(self, parent, wx.NewId(), "",
+         size=size or (-1,-1), choices=choices, style=style)
+        self.SetDefaultFont()
+
+        self.BindEvents()
+        styles.properties(self, kwargs)
+
+    def SetItems(self, items):
+        """ Clear the internal list of items, and set new items.  <items> is
+            a list of 2-tuples (string, data). """
+        self.Clear()
+        for s, data in items:
+            self.Append(s, data)
+
+    def GetItems(self):
+        """ Return a list of 2-tuples (string, data). """
+        items = []
+        for i in range(self.GetCount()):
+            s = self.GetString(i)
+            data = self.GetClientData(i)
+            items.append((s, data))
+        return items
+
+    #
+    # style parameters
+
+    def _params(self, kwargs):
+        flags = wx.CB_DROPDOWN # default
+        flags |= styles.stylebool('simple', wx.CB_SIMPLE, kwargs)
+        flags |= styles.stylebool('readonly', wx.CB_READONLY, kwargs)
+        flags |= styles.stylebool('sort', wx.CB_SORT, kwargs)
+        return flags
diff --git a/pynxc/waxy/constants.py b/pynxc/waxy/constants.py
new file mode 100644
index 0000000..c2a448c
--- /dev/null
+++ b/pynxc/waxy/constants.py
@@ -0,0 +1,3 @@
+from wx import MEDIUM_GREY_PEN
+
+Medium_Grey_Pen=MEDIUM_GREY_PEN
\ No newline at end of file
diff --git a/pynxc/waxy/containers.py b/pynxc/waxy/containers.py
new file mode 100644
index 0000000..b781ccc
--- /dev/null
+++ b/pynxc/waxy/containers.py
@@ -0,0 +1,311 @@
+# containers.py

+# Containers are mixin classes that have a sizer and a number of methods to

+# deal with that sizer (add components, etc).  Used to implement fairly

+# "basic" controls like Panel and Frame.  When in doubt, derive from those

+# two rather than making up your own container construct.

+

+import utils

+import waxyobject

+import wx

+import warnings

+

+class Container(waxyobject.WaxyObject):

+

+    def _create_sizer(self, direction):

+        if direction.lower().startswith("h"):

+            dir = wx.HORIZONTAL

+        elif direction.lower().startswith("v"):

+            dir = wx.VERTICAL

+        else:

+            raise ValueError, "Incorrect direction"

+        self.sizer = wx.BoxSizer(dir)

+        self._packed = 0

+

+    def Body(self):

+        """ Optionally override this to create components.  Add them with the

+            AddComponent() method. """

+

+    def AddComponent(self, comp, expand=0, stretch=0, align=None, border=0):

+        # expand: expands a component in the direction of the panel/sizer

+        # stretch: expands a component in the other direction

+        # for example, if we have a horizontal panel, and resize the window

+        # both horizontally and vertically, then a component with 'expand'

+        # will expand horizontally, and one with 'stretch' will expand

+        # vertically. (See simplebuttons.py)

+

+        if isinstance(expand, str):

+            expand = expand.lower()

+            if expand.startswith("h"):

+                if self.GetOrientation() == 'horizontal':

+                    expand, stretch = 1, 0

+                else:

+                    expand, stretch = 0, 1

+            elif expand.startswith("v"):

+                if self.GetOrientation() == 'horizontal':

+                    expand, stretch = 0, 1

+                else:

+                    expand, stretch = 1, 0

+            elif expand.startswith("b"):

+                expand = stretch = 1

+            elif expand == '':

+                expand = stretch = 0

+            else:

+                raise ValueError, "Invalid value for expand: %r" % (expand,)

+

+        flags = 0

+        if stretch:

+            flags |= wx.EXPAND

+        if align:

+            flags |= {

+                "t": wx.ALIGN_TOP,

+                "c": wx.ALIGN_CENTER,

+                "b": wx.ALIGN_BOTTOM,

+                "r": wx.ALIGN_RIGHT,

+                "l": wx.ALIGN_LEFT,

+            }.get(align.lower()[:1], 0)

+        if border:

+            flags |= wx.ALL

+

+        flags |= wx.FIXED_MINSIZE

+        if 0 and hasattr(comp, 'sizer') and hasattr(comp, '_include_sizer'):

+            # ugly hack to add nested sizer rather than its frame

+            # only for certain quirky controls, like GroupBox!

+            self.sizer.Add(comp.sizer, expand, flags)

+        else:

+            self.sizer.Add(comp, expand, flags, border)

+            # comp can be a component or a tuple (width, height), but the

+            # Add() method is called just the same, as of wxPython 2.5.1.5

+

+    def AddSpace(self, width, height=None, *args, **kwargs):

+        if height is None:

+            height = width

+        return self.AddComponent((width, height), *args, **kwargs)

+    AddSeparator = AddSpace

+

+    def Pack(self):

+        if not self._packed:

+            self.SetSizerAndFit(self.sizer)

+            self._packed = 1

+

+    def Repack(self):

+        self.sizer.RecalcSizes()

+

+    def GetOrientation(self):

+        """ Return 'horizontal' or 'vertical'. """

+        orientation = self.sizer.GetOrientation()

+        if orientation == wx.HORIZONTAL:

+            return 'horizontal'

+        elif orientation == wx.VERTICAL:

+            return 'vertical'

+        else:

+            raise ValueError, "Unknown direction for sizer"

+

+#

+# GridContainer (used to implement GridPanel)

+

+class GridContainer(Container):

+

+    _sizerclass = wx.GridSizer

+

+    alignment = {

+        'b': wx.ALIGN_BOTTOM,

+        'r': wx.ALIGN_RIGHT,

+        'l': wx.ALIGN_LEFT,

+        'c': wx.ALIGN_CENTER,

+        't': wx.ALIGN_TOP,

+        'h': wx.ALIGN_CENTER_HORIZONTAL,

+        'v': wx.ALIGN_CENTER_VERTICAL,

+    }

+

+    def _create_sizer(self, rows, cols, hgap=1, vgap=1):

+        self.sizer = self._sizerclass(rows, cols, vgap, hgap)

+        self.controls = {}

+        for row in range(rows):

+            for col in range(cols):

+                self.controls[col, row] = None

+                # (col, row) allows for (x, y)-like calling

+        self._packed = 0

+

+    def AddComponent(self, col, row, obj, expand=1, align='', border=0, stretch=0, proportion=0):

+        # make sure the parents are correct

+        if stretch:

+            warnings.warn("stretch is deprecated and has no effect here")

+

+        if self.controls[col, row]:

+            raise ValueError, "A control has already been set for position (%s, %s)" % (row, col)

+        self.controls[col, row] = {'obj': obj, 'expand': expand, 'align': align,

+                                   'border': border, 'proportion': proportion}

+

+    def Pack(self):

+        if not self._packed:

+            controls = self._AllControls()

+            self.sizer.AddMany(controls)

+            self.SetSizerAndFit(self.sizer) # is this still necessary?

+            self._packed = 1

+

+    def __setitem__(self, index, value):

+        col, row = index

+        self.AddComponent(col, row, value)

+

+    def __getitem__(self, index):

+        col, row = index

+        return self.controls[col, row]['obj']  # may raise KeyError

+

+    def _AllControls(self):

+        controls = []

+        for row in range(self.sizer.GetRows()):

+            for col in range(self.sizer.GetCols()):

+                d = self.controls[col, row]

+                if d is None:

+                    from panel import Panel

+                    p = Panel(self) # hack up a dummy panel

+                    controls.append((p, 0, wx.EXPAND|wx.FIXED_MINSIZE))

+                else:

+                    obj = d['obj']

+

+                    # set alignment

+                    align = d['align'].lower()

+                    alignment = 0

+                    for key, value in self.__class__.alignment.items():

+                        if key in align:

+                            alignment |= value

+

+                    z = d['expand'] and wx.EXPAND

+                    z |= alignment

+                    border = d['border']

+                    #if border and not alignment:

+                    if border:

+                        z |= wx.ALL

+                    z |= wx.FIXED_MINSIZE

+                    proportion = d['proportion']

+                    controls.append((obj, proportion, z, border))

+

+        return controls

+

+    # XXX maybe a Wax version of AddMany() would be useful?

+

+#

+# FlexGridContainer

+

+class FlexGridContainer(GridContainer):

+    _sizerclass = wx.FlexGridSizer

+

+    def AddGrowableRow(self, row):

+        self.sizer.AddGrowableRow(row)

+

+    def AddGrowableCol(self, col):

+        self.sizer.AddGrowableCol(col)

+

+#

+# OverlayContainer

+

+class OverlaySizer(wx.PySizer):

+    def __init__(self):

+        wx.PySizer.__init__(self)

+

+    def CalcMin(self):

+        maxx, maxy = 0, 0

+        for win in self.GetChildren():

+            x, y = win.CalcMin()

+            maxx = max(maxx, x)

+            maxy = max(maxy, y)

+        return wx.Size(maxx, maxy)

+

+    def RecalcSizes(self):

+        pos = self.GetPosition()

+        size = self.GetSize()

+        for win in self.GetChildren():

+            win.SetDimension(pos, size)

+

+

+class OverlayContainer(Container):

+    """ Container that takes an arbitrary number of windows, and stacks them

+        on top of each other.  Controls are hidden by default. """

+

+    def _create_sizer(self):

+        self.sizer = OverlaySizer()

+        self.windows = []

+        self._packed = 0

+

+    def AddComponent(self, window, expand=0, stretch=0, align=None, border=0):

+        """

+        # make sure the parents are correct

+        if waxconfig.WaxConfig.check_parent:

+            if window.GetParent() is not self:

+                utils.parent_warning(window, self)

+

+        flags = 0

+        if stretch:

+            flags |= wx.EXPAND

+        if align:

+            flags |= {

+                "t": wx.ALIGN_TOP,

+                "c": wx.ALIGN_CENTER,

+                "b": wx.ALIGN_BOTTOM,

+                "r": wx.ALIGN_RIGHT,

+                "l": wx.ALIGN_LEFT,

+            }.get(align.lower()[:1], 0)

+        if border:

+            flags |= wx.ALL

+        flags |= wx.FIXED_MINSIZE

+

+        self.sizer.Add(window, expand, flags, border)

+        """

+        Container.AddComponent(self, window, expand, stretch, align, border)

+        self.windows.append(window)

+        window.Hide()   # default is hiding

+

+    

+

+#

+# GroupBoxContainer

+

+class GroupBoxContainer(Container):

+

+    def _create_sizer(self, groupbox, direction='h'):

+        direction = direction.lower()

+        if direction.startswith('v'):

+            dir = wx.VERTICAL

+        elif direction.startswith('h'):

+            dir = wx.HORIZONTAL

+        else:

+            raise ValueError, "Unknown direction: %s" % (direction,)

+

+        self.sizer = wx.StaticBoxSizer(groupbox, dir)

+        self._packed = 0

+

+#

+# PlainContainer

+

+class PlainContainer(Container):

+    """ A container without a sizer.  Controls must be added at a given position.

+        Size can be specified as well.

+    """

+

+    def _create_sizer(self):

+        self.sizer = None

+        self._packed = 0    # included for compatibility

+

+    def AddComponent(self, x, y, comp):

+        # make sure the parents are correct

+

+        comp.SetPosition((x, y))

+

+    def AddComponentAndSize(self, x, y, sx, sy, comp):

+        # make sure the parents are correct

+

+        comp.SetPosition((x, y))

+        comp.SetSize((sx, sy))

+

+    def Pack(self):

+        self._packed = 1    # useless, but included for compatibility

+

+        if len(self.Children) == 1:

+            import panel

+            dummy = panel.Panel(self, size=(0,0))

+            dummy.Position = 0, 0

+            self.__dummy = dummy

+

+    def Repack():

+        pass

+

diff --git a/pynxc/waxy/containers.py~ b/pynxc/waxy/containers.py~
new file mode 100644
index 0000000..5c8c70d
--- /dev/null
+++ b/pynxc/waxy/containers.py~
@@ -0,0 +1,314 @@
+# containers.py

+# Containers are mixin classes that have a sizer and a number of methods to

+# deal with that sizer (add components, etc).  Used to implement fairly

+# "basic" controls like Panel and Frame.  When in doubt, derive from those

+# two rather than making up your own container construct.

+

+import utils

+import waxyobject

+import wx

+import warnings

+

+class Container(waxyobject.WaxyObject):

+

+    def _create_sizer(self, direction):

+        if direction.lower().startswith("h"):

+            dir = wx.HORIZONTAL

+        elif direction.lower().startswith("v"):

+            dir = wx.VERTICAL

+        else:

+            raise ValueError, "Incorrect direction"

+        self.sizer = wx.BoxSizer(dir)

+        self._packed = 0

+

+    def Body(self):

+        """ Optionally override this to create components.  Add them with the

+            AddComponent() method. """

+

+    def AddComponent(self, comp, expand=0, stretch=0, align=None, border=0):

+        # expand: expands a component in the direction of the panel/sizer

+        # stretch: expands a component in the other direction

+        # for example, if we have a horizontal panel, and resize the window

+        # both horizontally and vertically, then a component with 'expand'

+        # will expand horizontally, and one with 'stretch' will expand

+        # vertically. (See simplebuttons.py)

+

+        if isinstance(expand, str):

+            expand = expand.lower()

+            if expand.startswith("h"):

+                if self.GetOrientation() == 'horizontal':

+                    expand, stretch = 1, 0

+                else:

+                    expand, stretch = 0, 1

+            elif expand.startswith("v"):

+                if self.GetOrientation() == 'horizontal':

+                    expand, stretch = 0, 1

+                else:

+                    expand, stretch = 1, 0

+            elif expand.startswith("b"):

+                expand = stretch = 1

+            elif expand == '':

+                expand = stretch = 0

+            else:

+                raise ValueError, "Invalid value for expand: %r" % (expand,)

+

+        flags = 0

+        if stretch:

+            flags |= wx.EXPAND

+        if align:

+            flags |= {

+                "t": wx.ALIGN_TOP,

+                "c": wx.ALIGN_CENTER,

+                "b": wx.ALIGN_BOTTOM,

+                "r": wx.ALIGN_RIGHT,

+                "l": wx.ALIGN_LEFT,

+            }.get(align.lower()[:1], 0)

+        if border:

+            flags |= wx.ALL

+

+        flags |= wx.FIXED_MINSIZE

+        if 0 and hasattr(comp, 'sizer') and hasattr(comp, '_include_sizer'):

+            # ugly hack to add nested sizer rather than its frame

+            # only for certain quirky controls, like GroupBox!

+            self.sizer.Add(comp.sizer, expand, flags)

+        else:

+            self.sizer.Add(comp, expand, flags, border)

+            # comp can be a component or a tuple (width, height), but the

+            # Add() method is called just the same, as of wxPython 2.5.1.5

+

+    def AddSpace(self, width, height=None, *args, **kwargs):

+        if height is None:

+            height = width

+        return self.AddComponent((width, height), *args, **kwargs)

+    AddSeparator = AddSpace

+

+    def Pack(self):

+        if not self._packed:

+            self.SetSizerAndFit(self.sizer)

+            self._packed = 1

+

+    def Repack(self):

+        self.sizer.RecalcSizes()

+

+    def GetOrientation(self):

+        """ Return 'horizontal' or 'vertical'. """

+        orientation = self.sizer.GetOrientation()

+        if orientation == wx.HORIZONTAL:

+            return 'horizontal'

+        elif orientation == wx.VERTICAL:

+            return 'vertical'

+        else:

+            raise ValueError, "Unknown direction for sizer"

+

+#

+# GridContainer (used to implement GridPanel)

+

+class GridContainer(Container):

+

+    _sizerclass = wx.GridSizer

+

+    alignment = {

+        'b': wx.ALIGN_BOTTOM,

+        'r': wx.ALIGN_RIGHT,

+        'l': wx.ALIGN_LEFT,

+        'c': wx.ALIGN_CENTER,

+        't': wx.ALIGN_TOP,

+        'h': wx.ALIGN_CENTER_HORIZONTAL,

+        'v': wx.ALIGN_CENTER_VERTICAL,

+    }

+

+    def _create_sizer(self, rows, cols, hgap=1, vgap=1):

+        self.sizer = self._sizerclass(rows, cols, vgap, hgap)

+        self.controls = {}

+        for row in range(rows):

+            for col in range(cols):

+                self.controls[col, row] = None

+                # (col, row) allows for (x, y)-like calling

+        self._packed = 0

+

+    def AddComponent(self, col, row, obj, expand=1, align='', border=0, stretch=0, proportion=0):

+        # make sure the parents are correct

+        if stretch:

+            warnings.warn("stretch is deprecated and has no effect here")

+

+        if self.controls[col, row]:

+            raise ValueError, "A control has already been set for position (%s, %s)" % (row, col)

+        self.controls[col, row] = {'obj': obj, 'expand': expand, 'align': align,

+                                   'border': border, 'proportion': proportion}

+

+    def Pack(self):

+        if not self._packed:

+            controls = self._AllControls()

+            self.sizer.AddMany(controls)

+            self.SetSizerAndFit(self.sizer) # is this still necessary?

+            self._packed = 1

+

+    def __setitem__(self, index, value):

+        col, row = index

+        self.AddComponent(col, row, value)

+

+    def __getitem__(self, index):

+        col, row = index

+        return self.controls[col, row]['obj']  # may raise KeyError

+

+    def _AllControls(self):

+        controls = []

+        for row in range(self.sizer.GetRows()):

+            for col in range(self.sizer.GetCols()):

+                d = self.controls[col, row]

+                if d is None:

+                    from panel import Panel

+                    p = Panel(self) # hack up a dummy panel

+                    controls.append((p, 0, wx.EXPAND|wx.FIXED_MINSIZE))

+                else:

+                    obj = d['obj']

+

+                    # set alignment

+                    align = d['align'].lower()

+                    alignment = 0

+                    for key, value in self.__class__.alignment.items():

+                        if key in align:

+                            alignment |= value

+

+                    z = d['expand'] and wx.EXPAND

+                    z |= alignment

+                    border = d['border']

+                    #if border and not alignment:

+                    if border:

+                        z |= wx.ALL

+                    z |= wx.FIXED_MINSIZE

+                    proportion = d['proportion']

+                    controls.append((obj, proportion, z, border))

+

+        return controls

+

+    # XXX maybe a Wax version of AddMany() would be useful?

+

+#

+# FlexGridContainer

+

+class FlexGridContainer(GridContainer):

+    _sizerclass = wx.FlexGridSizer

+

+    def AddGrowableRow(self, row):

+        self.sizer.AddGrowableRow(row)

+

+    def AddGrowableCol(self, col):

+        self.sizer.AddGrowableCol(col)

+

+#

+# OverlayContainer

+

+class OverlaySizer(wx.PySizer):

+    def __init__(self):

+        wx.PySizer.__init__(self)

+

+    def CalcMin(self):

+        maxx, maxy = 0, 0

+        for win in self.GetChildren():

+            x, y = win.CalcMin()

+            maxx = max(maxx, x)

+            maxy = max(maxy, y)

+        return wx.Size(maxx, maxy)

+

+    def RecalcSizes(self):

+        pos = self.GetPosition()

+        size = self.GetSize()

+        for win in self.GetChildren():

+            win.SetDimension(pos, size)

+

+

+class OverlayContainer(Container):

+    """ Container that takes an arbitrary number of windows, and stacks them

+        on top of each other.  Controls are hidden by default. """

+

+    def _create_sizer(self):

+        self.sizer = OverlaySizer()

+        self.windows = []

+        self._packed = 0

+

+    def AddComponent(self, window, expand=0, stretch=0, align=None, border=0):

+        """

+        # make sure the parents are correct

+        if waxconfig.WaxConfig.check_parent:

+            if window.GetParent() is not self:

+                utils.parent_warning(window, self)

+

+        flags = 0

+        if stretch:

+            flags |= wx.EXPAND

+        if align:

+            flags |= {

+                "t": wx.ALIGN_TOP,

+                "c": wx.ALIGN_CENTER,

+                "b": wx.ALIGN_BOTTOM,

+                "r": wx.ALIGN_RIGHT,

+                "l": wx.ALIGN_LEFT,

+            }.get(align.lower()[:1], 0)

+        if border:

+            flags |= wx.ALL

+        flags |= wx.FIXED_MINSIZE

+

+        self.sizer.Add(window, expand, flags, border)

+        """

+        Container.AddComponent(self, window, expand, stretch, align, border)

+        self.windows.append(window)

+        window.Hide()   # default is hiding

+

+    

+

+#

+# GroupBoxContainer

+

+class GroupBoxContainer(Container):

+

+    def _create_sizer(self, groupbox, direction='h'):

+        direction = direction.lower()

+        if direction.startswith('v'):

+            dir = wx.VERTICAL

+        elif direction.startswith('h'):

+            dir = wx.HORIZONTAL

+        else:

+            raise ValueError, "Unknown direction: %s" % (direction,)

+

+        self.sizer = wx.StaticBoxSizer(groupbox, dir)

+        self._packed = 0

+

+#

+# PlainContainer

+

+class PlainContainer(Container):

+    """ A container without a sizer.  Controls must be added at a given position.

+        Size can be specified as well.

+    """

+

+    def _create_sizer(self):

+        self.sizer = None

+        self._packed = 0    # included for compatibility

+

+    def AddComponent(self, x, y, comp):

+        # make sure the parents are correct

+

+        comp.SetPosition((x, y))

+

+    def AddComponentAndSize(self, x, y, sx, sy, comp):

+        # make sure the parents are correct

+        if waxconfig.WaxConfig.check_parent:

+            if comp.GetParent() is not self:

+                utils.parent_warning(comp, self)

+

+        comp.SetPosition((x, y))

+        comp.SetSize((sx, sy))

+

+    def Pack(self):

+        self._packed = 1    # useless, but included for compatibility

+

+        if len(self.Children) == 1:

+            import panel

+            dummy = panel.Panel(self, size=(0,0))

+            dummy.Position = 0, 0

+            self.__dummy = dummy

+

+    def Repack():

+        pass

+

diff --git a/pynxc/waxy/core.py b/pynxc/waxy/core.py
new file mode 100644
index 0000000..0b58a48
--- /dev/null
+++ b/pynxc/waxy/core.py
@@ -0,0 +1,36 @@
+DEBUG = 0   # set to 1 to enable debugging messages
+
+from wx import BeginBusyCursor, CallAfter, EndBusyCursor, GetActiveWindow, \
+                GetApp, Platform, SafeYield, WakeUpIdle, Yield, YieldIfNeeded
+
+
+
+if False:
+    required = (2, 8, 0, 0) # minimum wxPython version
+    required_str = ".".join(map(str, required))
+    
+    # if a multiversion wxPython is installed, attempt to get a required version
+    try:
+        # for wxversion, we only take the first two numbers
+        import wxversion
+        wxversion_req = ".".join(map(str, required[:2]))
+        try:
+            wxversion.ensureMinimal(wxversion_req)
+        except wxversion.VersionError, e:
+            # it should also be possible to import wax after wxPython is imported.
+            # this VersionError prevents this, so we work around it.
+            if e.args[0].find("must be called before wxPython is imported") < 0:
+                raise
+    except ImportError: # will fail if it's not a multiversion installation
+        pass
+    
+    import wx
+    
+    assert wx.VERSION >= required, \
+           "This version of Wax requires wxPython %s or later" % (required_str,)
+    
+    DEBUG = 0   # set to 1 to enable debugging messages
+    
+    from wx import BeginBusyCursor, CallAfter, EndBusyCursor, GetActiveWindow, \
+                   GetApp, Platform, SafeYield, WakeUpIdle, Yield, YieldIfNeeded
+    
diff --git a/pynxc/waxy/core.py~ b/pynxc/waxy/core.py~
new file mode 100644
index 0000000..ef04e1f
--- /dev/null
+++ b/pynxc/waxy/core.py~
@@ -0,0 +1,2 @@
+required = (2, 8, 0, 0) # minimum wxPython version
+required_str = ".".join(map(str, required))
diff --git a/pynxc/waxy/customdialog.py b/pynxc/waxy/customdialog.py
new file mode 100644
index 0000000..dfe73b9
--- /dev/null
+++ b/pynxc/waxy/customdialog.py
@@ -0,0 +1,66 @@
+# customdialog.py
+
+import wx
+import containers
+import dialog
+
+class CustomDialog(wx.Dialog, containers.Container):
+
+    __events__ = dialog.Dialog.__events__.copy()
+
+    def __init__(self, parent, title=""):
+        wx.Dialog.__init__(self, parent, wx.NewId(), title, wx.DefaultPosition)
+
+        # this should create self.sizer and give access to self.AddComponent
+        self._create_sizer('vertical')
+
+        # We use EndModal() internally, and that requires that we return
+        # IDs.  _modalhooks is a mapping from ID to desired return value (as a
+        # string), used by CustomDialog.ShowModal.  _count is used for
+        # generating the unique IDs.
+        self._modalhooks = {}
+        self._count = 0 # enumerator
+
+        self.Body()
+
+        self.BindEvents()
+        self.Pack()
+        self.Centre()
+
+    def Body(self):
+        pass
+
+    def _GetEnumValue(self):
+        self._count = self._count + 1
+        return self._count
+
+    def SetBehavior(self, button, result, validator=None, event=None):
+        """ Set the behavior for the given button.  <result> is the desired
+            result, as a string ('ok', 'cancel', 'foo', etc).  <event> is
+            called, if defined.
+            Note 1: EndModal() is always called, causing the dialog to be
+            closed.  If you don't want this (i.e. if you want a "regular" button
+            on the dialog), don't call SetBehavior.
+            Note: Any OnClick-event that already exists on the button will
+            be overwritten.  It will *not* be called.
+        """
+        id = self._GetEnumValue()
+        self._modalhooks[id] = result
+        def OnClick(zevent):
+            # XXX there's room for a "validator" here
+            if validator:
+                pass # not sure how to do this yet
+            if event:
+                event(zevent)
+                # note: if an exception occurs here, it is not caught
+            self.EndModal(id)
+        button.OnClick = OnClick
+
+    def OnClickButton(self, event):
+        button = event.GetEventObject()
+
+    def ShowModal(self):
+        r = wx.Dialog.ShowModal(self)
+        # here, we need to figure out which button was clicked!
+        return self._modalhooks.get(r, "?")
+
diff --git a/pynxc/waxy/customdialog.py~ b/pynxc/waxy/customdialog.py~
new file mode 100644
index 0000000..6af64c8
--- /dev/null
+++ b/pynxc/waxy/customdialog.py~
@@ -0,0 +1,67 @@
+# customdialog.py
+
+import wx
+import containers
+import dialog
+
+class CustomDialog(wx.Dialog, containers.Container):
+
+    __events__ = dialog.Dialog.__events__.copy()
+
+    def __init__(self, parent, title=""):
+        wx.Dialog.__init__(self, parent, wx.NewId(), title, wx.DefaultPosition)
+
+        # this should create self.sizer and give access to self.AddComponent
+        self._create_sizer('vertical')
+        self.SetDefaultFont()
+
+        # We use EndModal() internally, and that requires that we return
+        # IDs.  _modalhooks is a mapping from ID to desired return value (as a
+        # string), used by CustomDialog.ShowModal.  _count is used for
+        # generating the unique IDs.
+        self._modalhooks = {}
+        self._count = 0 # enumerator
+
+        self.Body()
+
+        self.BindEvents()
+        self.Pack()
+        self.Centre()
+
+    def Body(self):
+        pass
+
+    def _GetEnumValue(self):
+        self._count = self._count + 1
+        return self._count
+
+    def SetBehavior(self, button, result, validator=None, event=None):
+        """ Set the behavior for the given button.  <result> is the desired
+            result, as a string ('ok', 'cancel', 'foo', etc).  <event> is
+            called, if defined.
+            Note 1: EndModal() is always called, causing the dialog to be
+            closed.  If you don't want this (i.e. if you want a "regular" button
+            on the dialog), don't call SetBehavior.
+            Note: Any OnClick-event that already exists on the button will
+            be overwritten.  It will *not* be called.
+        """
+        id = self._GetEnumValue()
+        self._modalhooks[id] = result
+        def OnClick(zevent):
+            # XXX there's room for a "validator" here
+            if validator:
+                pass # not sure how to do this yet
+            if event:
+                event(zevent)
+                # note: if an exception occurs here, it is not caught
+            self.EndModal(id)
+        button.OnClick = OnClick
+
+    def OnClickButton(self, event):
+        button = event.GetEventObject()
+
+    def ShowModal(self):
+        r = wx.Dialog.ShowModal(self)
+        # here, we need to figure out which button was clicked!
+        return self._modalhooks.get(r, "?")
+
diff --git a/pynxc/waxy/demos/.DS_Store b/pynxc/waxy/demos/.DS_Store
new file mode 100644
index 0000000..e162bfd
--- /dev/null
+++ b/pynxc/waxy/demos/.DS_Store
diff --git a/pynxc/waxy/demos/.jedrecent b/pynxc/waxy/demos/.jedrecent
new file mode 100644
index 0000000..f4f65e0
--- /dev/null
+++ b/pynxc/waxy/demos/.jedrecent
@@ -0,0 +1,11 @@
+/home/bblais/python/lib/waxy/progressdialog.py:17:31:0
+/home/bblais/python/work/waxy/demos/ProgressDialog.py:27:30:0
+/home/bblais/python/lib/waxy/multichoicedialog.py:1:1:0
+/home/bblais/python/lib/waxy/keys.py:1:1:0
+/home/bblais/python/lib/waxy/artprovider.py:1:1:0
+/home/bblais/python/lib/waxy/bitmapbutton.py:18:52:0
+/home/bblais/python/lib/waxy/notes.txt:17:9:0
+/home/bblais/python/lib/waxy/__init__.py:20:1:0
+/home/bblais/python/lib/waxy/singlechoicedialog.py:8:1:1
+/home/bblais/python/lib/waxy/listbox.py:5:12:1
+/home/bblais/python/lib/waxy/demos/SingleChoiceDialog.py:54:43:1
diff --git a/pynxc/waxy/demos/AboutBox.py b/pynxc/waxy/demos/AboutBox.py
new file mode 100755
index 0000000..7cdea24
--- /dev/null
+++ b/pynxc/waxy/demos/AboutBox.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(Frame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "About Box1",self.About1,default=True)
+        self.AddComponent(b)
+        
+        b = Button(self, "About Box2",self.About2,default=True)
+        self.AddComponent(b)
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def About1(self,event):
+        
+        licenseText = "blah " * 250 + "\n\n" +"yadda " * 100
+        
+        AboutBox(self,name='Hello World',
+                 version='1.2.3',
+                 copyright="(C) 2006 Programmers and Coders Everywhere",
+                 description=(
+            "A \"hello world\" program is a software program that prints out "
+            "\"Hello world!\" on a display device. It is used in many introductory "
+            "tutorials for teaching a programming language."
+            
+            "\n\nSuch a program is typically one of the simplest programs possible "
+            "in a computer language. A \"hello world\" program can be a useful "
+            "sanity test to make sure that a language's compiler, development "
+            "environment, and run-time environment are correctly installed."),
+            url="http://en.wikipedia.org/wiki/Hello_world",
+            webtitle="Hello World home page",
+            developers=[ "Joe Programmer",
+                            "Jane Coder",
+                            "Vippy the Mascot" ],
+            license=licenseText)
+        
+        
+    def About2(self,event):
+        
+        licenseText = "blah " * 250 + "\n\n" +"yadda " * 100
+        
+        info={}
+        info['name']='Hello World'
+        info['version']='1.2.3'
+        info['copyright']="(C) 2006 Programmers and Coders Everywhere"
+        info['description']=(
+            "A \"hello world\" program is a software program that prints out "
+            "\"Hello world!\" on a display device. It is used in many introductory "
+            "tutorials for teaching a programming language."
+            
+            "\n\nSuch a program is typically one of the simplest programs possible "
+            "in a computer language. A \"hello world\" program can be a useful "
+            "sanity test to make sure that a language's compiler, development "
+            "environment, and run-time environment are correctly installed.")
+        info['url']="http://en.wikipedia.org/wiki/Hello_world"
+        info['webtitle']="Hello World home page"
+        info['developers']=[ "Joe Programmer",
+                            "Jane Coder",
+                            "Vippy the Mascot" ]
+        info['license']=licenseText
+        
+        
+        AboutBox(self,info)
+        
+        
+        
+
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="AboutBox")
+    app.Run()
diff --git a/pynxc/waxy/demos/AboutBox.py~ b/pynxc/waxy/demos/AboutBox.py~
new file mode 100755
index 0000000..eacd55a
--- /dev/null
+++ b/pynxc/waxy/demos/AboutBox.py~
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(Frame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "About Box1",self.About1,default=True)
+        self.AddComponent(b)
+        
+        b = Button(self, "About Box2",self.About2,default=True)
+        self.AddComponent(b)
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def About1(self):
+        
+        licenseText = "blah " * 250 + "\n\n" +"yadda " * 100
+        
+        AboutBox(self,name='Hello World',
+                 version='1.2.3',
+                 copyright="(C) 2006 Programmers and Coders Everywhere",
+                 description=(
+            "A \"hello world\" program is a software program that prints out "
+            "\"Hello world!\" on a display device. It is used in many introductory "
+            "tutorials for teaching a programming language."
+            
+            "\n\nSuch a program is typically one of the simplest programs possible "
+            "in a computer language. A \"hello world\" program can be a useful "
+            "sanity test to make sure that a language's compiler, development "
+            "environment, and run-time environment are correctly installed."),
+            url="http://en.wikipedia.org/wiki/Hello_world",
+            webtitle="Hello World home page",
+            developers=[ "Joe Programmer",
+                            "Jane Coder",
+                            "Vippy the Mascot" ],
+            license=licenseText)
+        
+        
+    def About2(self):
+        
+        licenseText = "blah " * 250 + "\n\n" +"yadda " * 100
+        
+        info={}
+        info['name']='Hello World'
+        info['version']='1.2.3'
+        info['copyright']="(C) 2006 Programmers and Coders Everywhere"
+        info['description']=(
+            "A \"hello world\" program is a software program that prints out "
+            "\"Hello world!\" on a display device. It is used in many introductory "
+            "tutorials for teaching a programming language."
+            
+            "\n\nSuch a program is typically one of the simplest programs possible "
+            "in a computer language. A \"hello world\" program can be a useful "
+            "sanity test to make sure that a language's compiler, development "
+            "environment, and run-time environment are correctly installed.")
+        info['url']="http://en.wikipedia.org/wiki/Hello_world"
+        info['webtitle']="Hello World home page"
+        info['developers']=[ "Joe Programmer",
+                            "Jane Coder",
+                            "Vippy the Mascot" ]
+        info['license']=licenseText
+        
+        
+        AboutBox(self,info)
+        
+        
+        
+
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="AboutBox")
+    app.Run()
diff --git a/pynxc/waxy/demos/Button.py b/pynxc/waxy/demos/Button.py
new file mode 100755
index 0000000..998ef2b
--- /dev/null
+++ b/pynxc/waxy/demos/Button.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "Default Button",self.OnClick,default=True)
+        self.AddComponent(b)
+        
+        b = Button(self, "Hello Again",self.OnClick,
+                                 tooltip="This is a Hello button...")
+        self.AddComponent(b)
+        
+        b = Button(self, "Flat Button?",self.OnClick,
+                          tooltip="This button has a style flag of wx.NO_BORDER. On some platforms that will give it a flattened look.",flat=True)
+        self.AddComponent(b)
+
+        self.Pack()
+        self.SetSize((640, 480))
+        
+    def OnClick(self,event):
+        print "Click! (%d)\n" % (event.GetId())
+        
+    def CloseWindow(self,event):
+        self.Close()
+    
+    
+if __name__=="__main__":
+    app = Application(MainFrame, title="Some buttons")
+    app.Run()
diff --git a/pynxc/waxy/demos/Button.py~ b/pynxc/waxy/demos/Button.py~
new file mode 100755
index 0000000..7274a33
--- /dev/null
+++ b/pynxc/waxy/demos/Button.py~
@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "Default Button",self.OnClick,default=True)
+        self.AddComponent(b)
+        
+        b = Button(self, "Hello Again",self.OnClick,
+                                 tooltip="This is a Hello button...")
+        self.AddComponent(b)
+        
+        b = Button(self, "Flat Button?",self.OnClick,
+                          tooltip="This button has a style flag of wx.NO_BORDER. On some platforms that will give it a flattened look.",flat=True)
+        self.AddComponent(b)
+
+        self.Pack()
+        self.SetSize((640, 480))
+        
+    def OnClick(self,event):
+        print "Click! (%d)\n" % (event.GetId())
+        
+    def CloseWindow(self,event):
+        self.Close()
+    
+    
+app = Application(MainFrame, title="Some buttons")
+app.Run()
diff --git a/pynxc/waxy/demos/Calendar.py b/pynxc/waxy/demos/Calendar.py
new file mode 100755
index 0000000..1780b0d
--- /dev/null
+++ b/pynxc/waxy/demos/Calendar.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+from waxy import *
+import wx.lib.calendar
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        self.calend = wx.lib.calendar.Calendar(self, -1)
+        self.calend.SetCurrentDay()
+        self.calend.grid_color = 'BLUE'
+        self.calend.SetBusType()
+        self.calend.Show(True)
+        
+        self.Bind(wx.lib.calendar.EVT_CALENDAR, self.MouseClick, self.calend)
+        
+        
+        self.SetSize((640, 480))
+        
+    def MouseClick(self, evt):
+        text = '%s CLICK   %02d/%02d/%d' % (evt.click, evt.day, evt.month, evt.year)  # format date
+        print 'Date Selected: ' + text + '\n'
+
+    
+        
+        
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="Calendar")
+    app.Run()
diff --git a/pynxc/waxy/demos/Canvas.py b/pynxc/waxy/demos/Canvas.py
new file mode 100644
index 0000000..7822e62
--- /dev/null
+++ b/pynxc/waxy/demos/Canvas.py
@@ -0,0 +1,43 @@
+from waxy import *
+
+class MyCanvas(Canvas):
+
+    def Init(self):
+        self.SetBackgroundColour('WHITE')
+
+    def OnDraw(self, dc):
+        dc.SetTextForeground('BLACK')
+        dc.SetPen(MEDIUM_GREY_PEN)
+
+        self.DrawHexagons(dc, 300, 10, radius=40, max_number=11)
+
+    def DrawHexagons(self, dc, x, y, radius, max_number):
+        for i in range(1, max_number+1):
+            offset = i * -0.5 * radius
+            for j in range(i):
+                self.DrawHexagon(dc, x + offset + j * radius,
+                 y + (i * 0.75 * radius), radius)
+
+    def DrawHexagon(self, dc, x, y, radius):
+        # does not seem like a 'real' hexagon, but this will do for now
+        p1 = (x, y)
+        p2 = (x + 0.5 * radius, y + 0.25 * radius)
+        p3 = (p2[0], p2[1] + 0.5 * radius)
+        p4 = (p1[0], p1[1] + radius)
+        p5 = (x - 0.5 * radius, p3[1])
+        p6 = (x - 0.5 * radius, y + 0.25 * radius)
+
+        dc.DrawLinePoint(p1, p2)
+        dc.DrawLinePoint(p2, p3)
+        dc.DrawLinePoint(p3, p4)
+        dc.DrawLinePoint(p4, p5)
+        dc.DrawLinePoint(p5, p6)
+        dc.DrawLinePoint(p6, p1)
+
+class MainFrame(Frame):
+    def Body(self):
+        canvas = MyCanvas(self)
+        self.SetSize((600, 500))
+
+app = Application(MainFrame)
+app.MainLoop()
diff --git a/pynxc/waxy/demos/ColorDialog.py b/pynxc/waxy/demos/ColorDialog.py
new file mode 100755
index 0000000..03c3234
--- /dev/null
+++ b/pynxc/waxy/demos/ColorDialog.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(Frame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "Color Dialog",self.Color,default=True)
+        self.AddComponent(b)
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def Color(self,event):
+        
+        
+        dlg=ColorDialog(self)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenColor()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+
+
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="ColorDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/ColorDialog.py~ b/pynxc/waxy/demos/ColorDialog.py~
new file mode 100644
index 0000000..bf26f0f
--- /dev/null
+++ b/pynxc/waxy/demos/ColorDialog.py~
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(Frame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "Colour Dialog",self.Colour,default=True)
+        self.AddComponent(b)
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def Colour(self,event):
+        
+        
+        dlg=ColourDialog(self)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenColour()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+
+
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="ColourDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/ColourDialog.py b/pynxc/waxy/demos/ColourDialog.py
new file mode 100755
index 0000000..bf26f0f
--- /dev/null
+++ b/pynxc/waxy/demos/ColourDialog.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(Frame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "Colour Dialog",self.Colour,default=True)
+        self.AddComponent(b)
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def Colour(self,event):
+        
+        
+        dlg=ColourDialog(self)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenColour()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+
+
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="ColourDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/ColourDialog.py~ b/pynxc/waxy/demos/ColourDialog.py~
new file mode 100755
index 0000000..761b610
--- /dev/null
+++ b/pynxc/waxy/demos/ColourDialog.py~
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(Frame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "Colour Dialog",self.Colour,default=True)
+        self.AddComponent(b)
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def Colour(self,event):
+        
+        
+        dlg=ColourDialog(self)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Here: ",dlg.GetChosenColour()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+
+
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="ColourDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/DirectoryDialog.py b/pynxc/waxy/demos/DirectoryDialog.py
new file mode 100755
index 0000000..1943b1f
--- /dev/null
+++ b/pynxc/waxy/demos/DirectoryDialog.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "Directory Dialog",self.Directory,default=True)
+        self.AddComponent(b,border=10)
+        
+        b = Button(self, "Choose Directory",self.Directory2)
+        self.AddComponent(b,border=10)
+        
+        b = Button(self, "Directory Dialog with New Button",self.Directory3,default=True)
+        self.AddComponent(b,border=10)
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def Directory(self,event):
+        
+        
+        dlg=DirectoryDialog(self)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenDirectory()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def Directory2(self,event):
+        
+        
+        res=ChooseDirectory(self)
+        
+        print "Chose: ",res
+
+
+    def Directory3(self,event):
+        
+        
+        dlg=DirectoryDialog(self,new_dir_button=True)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenDirectory()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="DirectoryDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/DirectoryDialog.py~ b/pynxc/waxy/demos/DirectoryDialog.py~
new file mode 100755
index 0000000..3d13c7d
--- /dev/null
+++ b/pynxc/waxy/demos/DirectoryDialog.py~
@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "Directory Dialog",self.Directory,default=True)
+        self.AddComponent(b,border=20)
+        
+        b = Button(self, "Choose Directory",self.Directory2)
+        self.AddComponent(b,border=20)
+        
+        b = Button(self, "Directory Dialog with New Button",self.Directory3,default=True)
+        self.AddComponent(b,border=20)
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def Directory(self,event):
+        
+        
+        dlg=DirectoryDialog(self)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenDirectory()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def Directory2(self,event):
+        
+        
+        res=ChooseDirectory(self)
+        
+        print "Chose: ",res
+
+
+    def Directory3(self,event):
+        
+        
+        dlg=DirectoryDialog(self,new_dir_button=True)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenDirectory()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="DirectoryDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/Drag.py b/pynxc/waxy/demos/Drag.py
new file mode 100755
index 0000000..42ae3bf
--- /dev/null
+++ b/pynxc/waxy/demos/Drag.py
@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+
+from waxy import *
+class Sprite:
+    def __init__(self, fname):
+        self.bitmap = Image(fname+".png").ConvertToBitmap()
+        self.bitmap_rev = Image(fname+"rev.png").ConvertToBitmap()
+        self.background = None
+        self.pos=wx.Point(0,0)
+        self.reversed=False
+        
+    def Draw(self, dc):
+        # copy background from dc to memory object
+        memdc = wx.MemoryDC()
+        memdc.Blit(0, 0, self.bitmap.GetWidth(), self.bitmap.GetHeight(), dc,
+                   self.pos[0], self.pos[1], wx.COPY, 1)
+        self.background = memdc # keep around for later
+
+        bitmap = self.bitmap if not self.reversed else self.bitmap_rev
+        dc.DrawBitmap(bitmap, self.pos[0], self.pos[1], 1)
+        
+    def HitTest(self, pt):
+        rect = self.GetRect()
+        return rect.InsideXY(pt.x, pt.y)
+        
+        
+    def GetRect(self):
+        return wx.Rect(self.pos[0], self.pos[1],
+                      self.bitmap.GetWidth(), self.bitmap.GetHeight())
+        
+class MyCanvas(Canvas):
+
+    def Init(self):
+        self.SetBackgroundColour('WHITE')
+        self.SetScrollbars(20, 20, 100, 100)
+        self.sprite = Sprite('heretic2')
+        self.sprite.pos=wx.Point(50,50)
+        self.selected=False
+        self.starting_mouse_pos=None
+        self.sprite_orig_pos=None
+        
+    def OnLeftDown(self,event=None):
+        
+        if self.sprite.HitTest(event.Position):
+            self.selected=True
+            self.starting_mouse_pos=event.Position
+            self.sprite_orig_pos=self.sprite.pos
+            self.sprite.reversed=not self.sprite.reversed
+            self.Refresh()
+            
+    def OnLeftUp(self,event=None):
+        self.selected=False
+
+    def OnMotion(self,event=None):
+        if not event.Dragging():
+            return
+            
+        if not self.selected:
+            return
+        
+        print "move.",event.Position
+        self.sprite.pos=self.sprite_orig_pos+event.Position-self.starting_mouse_pos
+            
+        self.Refresh()
+
+    
+    def OnDraw(self, dc):
+        dc.SetTextForeground('BLUE')
+        dc.SetPen(wx.MEDIUM_GREY_PEN)
+        for i in range(50):
+            dc.DrawLine(0, i*10, i*10, 0)
+
+        self.sprite.Draw(dc)
+    
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+
+
+        self.canvas = MyCanvas(self)
+        self.canvas.SetSize((400,300))
+        self.AddComponent(self.canvas, expand=1, stretch=1)
+
+        self.Pack()
+
+
+
+        self.CenterOnScreen()
+
+        self.Show()
+        
+        
+    def CloseWindow(self,event):
+        self.Close()
+
+
+
+if __name__=="__main__":
+    app = Application(MainFrame, title=__file__)
+    app.Run()
diff --git a/pynxc/waxy/demos/FileDialog.py b/pynxc/waxy/demos/FileDialog.py
new file mode 100755
index 0000000..6c2bc8e
--- /dev/null
+++ b/pynxc/waxy/demos/FileDialog.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+wildcard = "Python source (*.py)|*.py|"     \
+           "Compiled Python (*.pyc)|*.pyc|" \
+           "SPAM files (*.spam)|*.spam|"    \
+           "Egg file (*.egg)|*.egg|"        \
+           "All files (*.*)|*.*"
+
+class MainFrame(Frame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "File OPEN Dialog",self.File1,default=True)
+        self.AddComponent(b,border=10)
+        
+        b = Button(self, "File SAVE Dialog",self.File2)
+        self.AddComponent(b,border=10)
+        
+        b = Button(self, "File MULTIPLE OPEN Dialog",self.File3)
+        self.AddComponent(b,border=10)
+        
+        b = Button(self, "File Dialog (default?)",self.File0)
+        self.AddComponent(b,border=10)
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def File1(self,event):
+        
+        
+        dlg=FileDialog(self,wildcard=wildcard,open=True)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenFile()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def File2(self,event):
+        
+        
+        dlg=FileDialog(self,wildcard=wildcard,save=True)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenFile()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def File3(self,event):
+        
+        
+        dlg=FileDialog(self,wildcard=wildcard,open=True,multiple=True)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenFile()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def File0(self,event):
+        
+        
+        dlg=FileDialog(self,wildcard=wildcard)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenFile()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="FileDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/FileDialog.py~ b/pynxc/waxy/demos/FileDialog.py~
new file mode 100755
index 0000000..4bf03bc
--- /dev/null
+++ b/pynxc/waxy/demos/FileDialog.py~
@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+wildcard = "Python source (*.py)|*.py|"     \
+           "Compiled Python (*.pyc)|*.pyc|" \
+           "SPAM files (*.spam)|*.spam|"    \
+           "Egg file (*.egg)|*.egg|"        \
+           "All files (*.*)|*.*"
+
+class MainFrame(Frame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "File OPEN Dialog",self.File1,default=True)
+        self.AddComponent(b,border=10)
+        
+        b = Button(self, "File SAVE Dialog",self.File2)
+        self.AddComponent(b,border=10)
+        
+        b = Button(self, "File MULTIPLE OPEN Dialog",self.File3)
+        self.AddComponent(b,border=10)
+        
+        b = Button(self, "File Dialog (default?)",self.File2)
+        self.AddComponent(b,border=10)
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def File1(self,event):
+        
+        
+        dlg=FileDialog(self,wildcard=wildcard,open=True)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenFile()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def File2(self,event):
+        
+        
+        dlg=FileDialog(self,wildcard=wildcard,save=True)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenFile()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def File3(self,event):
+        
+        
+        dlg=FileDialog(self,wildcard=wildcard,open=True,multiple=True)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenFile()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def File0(self,event):
+        
+        
+        dlg=FileDialog(self,wildcard=wildcard)
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenFile()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="FileDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/Grid.py b/pynxc/waxy/demos/Grid.py
new file mode 100755
index 0000000..833d57d
--- /dev/null
+++ b/pynxc/waxy/demos/Grid.py
@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        self.cellbox=TextBox(self)
+        self.AddComponent(self.cellbox,border=10,stretch=True)
+        self.cellbox.OnChar=self.EditCell
+        
+        self.grid = Grid(self,100,40)
+        self.AddComponent(self.grid,border=10,expand='both')
+        self.grid.OnSelectCell=self.OnSelectCell
+        
+        self.Pack()
+        self.SetSize((1000, 800))
+        
+        self.CenterOnScreen()
+
+        self.Show()
+        self.grid.SetFocus()
+        self.cellbox.SetValue(self.grid[0,0])
+
+    def EditCell(self,event):
+        
+        if event.KeyCode>0 and event.KeyCode<255:  # a character
+        
+            v=self.cellbox.GetValue()
+            r,c=self.grid.GetGridCursorRow(),self.grid.GetGridCursorCol()
+
+
+            if event.KeyCode==13: # return
+                self.grid[r,c]=v
+                self.grid.SetFocus()
+            elif event.KeyCode==27: # escape
+                self.cellbox.SetValue("")
+                self.grid.SetFocus()
+
+        event.Skip()
+        
+
+    def CloseWindow(self,event):
+        self.Close()
+
+    def OnSelectCell(self,event):
+        r,c=event.Row,event.Col
+        self.cellbox.SetValue(self.grid[r,c])
+        event.Skip()
+        
+        
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="Grid")
+    app.Run()
diff --git a/pynxc/waxy/demos/Grid2.py b/pynxc/waxy/demos/Grid2.py
new file mode 100755
index 0000000..e8d8f5b
--- /dev/null
+++ b/pynxc/waxy/demos/Grid2.py
@@ -0,0 +1,177 @@
+#!/usr/bin/env python
+
+from waxy import *
+import  wx
+
+
+class CustomDataTable(wx.grid.PyGridTableBase):
+    def __init__(self):
+        wx.grid.PyGridTableBase.__init__(self)
+
+        self.colLabels = ['ID', 'Description', 'Severity', 'Priority', 'Platform',
+                          'Opened?', 'Fixed?', 'Tested?', 'TestFloat']
+
+        self.dataTypes = [wx.grid.GRID_VALUE_NUMBER,
+                          wx.grid.GRID_VALUE_STRING,
+                          wx.grid.GRID_VALUE_CHOICE + ':only in a million years!,wish list,minor,normal,major,critical',
+                          wx.grid.GRID_VALUE_NUMBER + ':1,5',
+                          wx.grid.GRID_VALUE_CHOICE + ':all,MSW,GTK,other',
+                          wx.grid.GRID_VALUE_BOOL,
+                          wx.grid.GRID_VALUE_BOOL,
+                          wx.grid.GRID_VALUE_BOOL,
+                          wx.grid.GRID_VALUE_FLOAT + ':6,2',
+                          ]
+
+        self.data = [
+            [1010, "The foo doesn't bar", "major", 1, 'MSW', 1, 1, 1, 1.12],
+            [1011, "I've got a wicket in my wocket", "wish list", 2, 'other', 0, 0, 0, 1.50],
+            [1012, "Rectangle() returns a triangle", "critical", 5, 'all', 0, 0, 0, 1.56]
+
+            ]
+
+
+    #--------------------------------------------------
+    # required methods for the wxPyGridTableBase interface
+
+    def GetNumberRows(self):
+        return len(self.data) + 1
+
+    def GetNumberCols(self):
+        return len(self.data[0])
+
+    def IsEmptyCell(self, row, col):
+        try:
+            return not self.data[row][col]
+        except IndexError:
+            return True
+
+    # Get/Set values in the table.  The Python version of these
+    # methods can handle any data-type, (as long as the Editor and
+    # Renderer understands the type too,) not just strings as in the
+    # C++ version.
+    def GetValue(self, row, col):
+        try:
+            return self.data[row][col]
+        except IndexError:
+            return ''
+
+    def SetValue(self, row, col, value):
+        try:
+            self.data[row][col] = value
+        except IndexError:
+            # add a new row
+            self.data.append([''] * self.GetNumberCols())
+            self.SetValue(row, col, value)
+
+            # tell the grid we've added a row
+            msg = wx.grid.GridTableMessage(self,            # The table
+                    wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED, # what we did to it
+                    1                                       # how many
+                    )
+
+            self.GetView().ProcessTableMessage(msg)
+
+
+    #--------------------------------------------------
+    # Some optional methods
+
+    # Called when the grid needs to display labels
+    def GetColLabelValue(self, col):
+        return self.colLabels[col]
+
+    # Called to determine the kind of editor/renderer to use by
+    # default, doesn't necessarily have to be the same type used
+    # natively by the editor/renderer if they know how to convert.
+    def GetTypeName(self, row, col):
+        return self.dataTypes[col]
+
+    # Called to determine how the data can be fetched and stored by the
+    # editor and renderer.  This allows you to enforce some type-safety
+    # in the grid.
+    def CanGetValueAs(self, row, col, typeName):
+        colType = self.dataTypes[col].split(':')[0]
+        if typeName == colType:
+            return True
+        else:
+            return False
+
+    def CanSetValueAs(self, row, col, typeName):
+        return self.CanGetValueAs(row, col, typeName)
+
+
+
+class MyGrid(Grid):
+    
+    def __init__(self, parent):
+        Grid.__init__(self, parent)
+        table = CustomDataTable()
+
+        self.SetTable(table, True)
+
+        self.SetRowLabelSize(0)
+        self.SetMargins(0,0)
+        self.AutoSizeColumns(False)
+
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        self.cellbox=TextBox(self)
+        self.AddComponent(self.cellbox,border=10,stretch=True)
+        self.cellbox.OnChar=self.EditCell
+        
+        self.grid = MyGrid(self)
+        self.AddComponent(self.grid,border=10,expand='both')
+        self.grid.OnSelectCell=self.OnSelectCell
+        
+        self.Pack()
+        self.SetSize((1000, 800))
+        
+        self.CenterOnScreen()
+
+        self.Show()
+        self.grid.SetFocus()
+        self.cellbox.SetValue(self.grid[0,0])
+
+    def EditCell(self,event):
+        
+        if event.KeyCode>0 and event.KeyCode<255:  # a character
+        
+            v=self.cellbox.GetValue()
+            r,c=self.grid.GetGridCursorRow(),self.grid.GetGridCursorCol()
+
+
+            if event.KeyCode==13: # return
+                self.grid[r,c]=v
+                self.grid.SetFocus()
+            elif event.KeyCode==27: # escape
+                self.cellbox.SetValue("")
+                self.grid.SetFocus()
+
+        event.Skip()
+        
+
+    def CloseWindow(self,event):
+        self.Close()
+
+    def OnSelectCell(self,event):
+        r,c=event.Row,event.Col
+        self.cellbox.SetValue(self.grid[r,c])
+        event.Skip()
+        
+        
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="Grid")
+    app.Run()
diff --git a/pynxc/waxy/demos/MessageDialog.py b/pynxc/waxy/demos/MessageDialog.py
new file mode 100755
index 0000000..96f069a
--- /dev/null
+++ b/pynxc/waxy/demos/MessageDialog.py
@@ -0,0 +1,98 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "Message Dialog: Question",self.Message,default=True)
+        self.AddComponent(b,border=10)
+        
+        b = Button(self, "Choose Message: Statement",self.Message2)
+        self.AddComponent(b,border=10)
+        
+        
+        panel=Panel(self,direction='h')
+        
+        choices = MessageDialog._icons.keys()
+        choices.sort()
+
+        self.dd = DropDownBox(panel, choices)
+        panel.AddComponent(self.dd, border=10)
+
+        b = Button(panel, "Show message", self.Message3)
+        panel.AddComponent(b,border=10)
+
+
+
+        panel.Pack()
+        
+
+        self.AddComponent(panel,border=20)
+
+        b = Button(self, "File Exists", self.Message4)
+        self.AddComponent(b,border=10)
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def Message(self,event):
+
+        dlg=MessageDialog(self,title="Holy cow", text="You wanna dance?",
+              ok=0, yes_no=1)
+        res=dlg.ShowModal()
+        
+        print res
+
+        dlg.Destroy()
+        
+    def Message2(self,event):
+
+        dlg=MessageDialog(self,text="Resistance is futile.")
+        res=dlg.ShowModal()
+        
+        print res
+
+        dlg.Destroy()
+        
+        
+    def Message3(self,event):
+        
+        choice = self.dd.GetStringSelection()
+        dlg = MessageDialog(self, "A message", "You chose: " + repr(choice),
+              icon=choice)
+        res=dlg.ShowModal()
+        
+        print res
+        
+        dlg.Destroy()
+        
+    def Message4(self,event):
+        filename='hello.txt'
+        dlg = MessageDialog(self, '"%s" already exists. Do you want to replace it?' % filename,
+        'A file or folder with the same name already exists in plasticity. Replacing it will overwrite its current contents.',icon='Warning',cancel=1)
+        result = dlg.ShowModal()
+
+        print result
+        
+        dlg.Destroy()        
+
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="MessageDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/MessageDialog.py~ b/pynxc/waxy/demos/MessageDialog.py~
new file mode 100755
index 0000000..5a42619
--- /dev/null
+++ b/pynxc/waxy/demos/MessageDialog.py~
@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "Message Dialog: Question",self.Message,default=True)
+        self.AddComponent(b,border=10)
+        
+        b = Button(self, "Choose Message: Statement",self.Message2)
+        self.AddComponent(b,border=10)
+        
+        
+        panel=Panel(self,direction='h')
+        
+        choices = MessageDialog._icons.keys()
+        choices.sort()
+
+        self.dd = DropDownBox(panel, choices)
+        panel.AddComponent(self.dd, border=10)
+
+        b = Button(panel, "Show message", self.Message3)
+        panel.AddComponent(b)
+        panel.Pack()
+        
+        self.AddComponent(panel,border=20)
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def Message(self,event):
+
+        dlg=MessageDialog(self,title="Holy cow", text="You wanna dance?",
+              ok=0, yes_no=1)
+        res=dlg.ShowModal()
+        
+        print res
+
+        dlg.Destroy()
+        
+    def Message2(self,event):
+
+        dlg=MessageDialog(self,text="Resistance is futile.")
+        res=dlg.ShowModal()
+        
+        print res
+
+        dlg.Destroy()
+        
+        
+    def Message3(self,event):
+        
+        choice = self.dd.GetStringSelection()
+        dlg = MessageDialog(self, "A message", "You chose: " + repr(choice),
+              icon=choice)
+        res=dlg.ShowModal()
+        
+        print res
+        
+        dlg.Destroy()
+        
+        
+
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="MessageDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/MultiChoiceDialog.py b/pynxc/waxy/demos/MultiChoiceDialog.py
new file mode 100755
index 0000000..01644fb
--- /dev/null
+++ b/pynxc/waxy/demos/MultiChoiceDialog.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "MultiChoice Dialog",self.MultiChoice,default=True)
+        self.AddComponent(b,border=10)
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def MultiChoice(self,event):
+        
+        
+        lst = [ 'apple', 'pear', 'banana', 'coconut', 'orange', 'grape', 'pineapple',
+                'blueberry', 'raspberry', 'blackberry', 'snozzleberry',
+                'etc', 'etc..', 'etc...' ]
+
+        dlg = MultiChoiceDialog( self, lst,
+                                   "Pick some fruit from\nthis list",
+                                   "MultiChoiceDialog")
+
+
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenItems()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+        
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="MultiChoiceDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/MultiChoiceDialog.py~ b/pynxc/waxy/demos/MultiChoiceDialog.py~
new file mode 100644
index 0000000..bf53055
--- /dev/null
+++ b/pynxc/waxy/demos/MultiChoiceDialog.py~
@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "MultiChoice Dialog",self.MultiChoice,default=True)
+        self.AddComponent(b,border=10)
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def MultiChoice(self,event):
+        
+        
+        lst = [ 'apple', 'pear', 'banana', 'coconut', 'orange', 'grape', 'pineapple',
+                'blueberry', 'raspberry', 'blackberry', 'snozzleberry',
+                'etc', 'etc..', 'etc...' ]
+
+        dlg = MultiChoiceDialog( self, lst,
+                                   "Pick some fruit from\nthis list",
+                                   "MultiChoiceDialog")
+
+
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenMultiChoice()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+        
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="MultiChoiceDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/ProgressDialog.py b/pynxc/waxy/demos/ProgressDialog.py
new file mode 100755
index 0000000..0847d4d
--- /dev/null
+++ b/pynxc/waxy/demos/ProgressDialog.py
@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+
+from waxy import *
+import time
+
+class MainFrame(Frame):
+    def Body(self):
+        self.AddComponent(Button(self, "one", self.OnClick))
+        self.AddComponent(Button(self, "two", self.OnClick2))
+        self.AddComponent(Button(self, "three", self.OnClick3))
+        self.Pack()
+    
+    def OnClick(self, event):
+        # note: does not have a Cancel button, so it cannot be interrupted
+        dlg = ProgressDialog(self, title="Progress Dialog Test", 
+              message="Counting from 1 to 1000", maximum=1000, modal=0)
+        dlg.Show()
+        cancel = True
+        for i in range(1000):
+            if i % 100 == 0:
+                keep_going,skip = dlg.Update(i, "Counting from " + str(i) + " to 1000")
+            else:
+                keep_going,skip = dlg.Update(i)
+                
+               
+            time.sleep(.01)
+            if not keep_going:
+                break
+        dlg.Destroy()
+        
+    def OnClick2(self, event):
+        dlg = ProgressDialog(self, title="Progress Dialog Test", 
+              message="Counting from 1 to 1000", maximum=1000, abort=1)
+        dlg.Show()
+        cancel = True
+        for i in range(1000):
+            if i % 100 == 0:
+                cancel = dlg.Update(i, "Counting from " + str(i) + " to 1000")
+            else:
+                cancel = dlg.Update(i)
+            time.sleep(.01)
+            if not cancel[0]:
+                break
+        dlg.Destroy()
+
+    def OnClick3(self, event):
+        dlg = ProgressDialog(self, title="Progress Dialog Test", 
+              message="Counting from 1 to 1000", maximum=1000, abort=1, 
+              show_elapsed_time=1, 
+              #show_estimated_time=1, 
+              show_remaining_time=1)
+        dlg.Show()
+        cancel = True
+        for i in range(1000):
+            if i % 100 == 0:
+                cancel = dlg.Update(i, "Counting from " + str(i) + " to 1000")
+            else:
+                cancel = dlg.Update(i)
+            time.sleep(.01)
+            if not cancel[0]:
+                dlg2 = MessageDialog(self, title="Continue?", text="Do you want to abort?", yes_no=1)
+                result = dlg2.ShowModal()
+                if result == "yes":
+                    dlg.Destroy()
+                    break
+                else:
+                    dlg.Resume()
+                dlg2.Destroy()
+        if dlg:
+            dlg.Destroy()
+            
+            
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="ProgressDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/ProgressDialog.py~ b/pynxc/waxy/demos/ProgressDialog.py~
new file mode 100755
index 0000000..5fc5157
--- /dev/null
+++ b/pynxc/waxy/demos/ProgressDialog.py~
@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+
+from waxy import *
+import time
+
+class MainFrame(Frame):
+    def Body(self):
+        self.AddComponent(Button(self, "one", self.OnClick))
+        self.AddComponent(Button(self, "two", self.OnClick2))
+        self.AddComponent(Button(self, "three", self.OnClick3))
+        self.Pack()
+    
+    def OnClick(self, event):
+        # note: does not have a Cancel button, so it cannot be interrupted
+        dlg = ProgressDialog(self, title="Progress Dialog Test", 
+              message="Counting from 1 to 1000", maximum=1000, modal=0)
+        dlg.Show()
+        cancel = True
+        for i in range(1000):
+            if i % 100 == 0:
+                keep_going,skip = dlg.Update(i, "Counting from " + str(i) + " to 1000")
+            else:
+                keep_going,skip = dlg.Update(i)
+                
+               
+            time.sleep(.01)
+            if not cancel[0]:
+                break
+        dlg.Destroy()
+        
+    def OnClick2(self, event):
+        dlg = ProgressDialog(self, title="Progress Dialog Test", 
+              message="Counting from 1 to 1000", maximum=1000, abort=1)
+        dlg.Show()
+        cancel = True
+        for i in range(1000):
+            if i % 100 == 0:
+                cancel = dlg.Update(i, "Counting from " + str(i) + " to 1000")
+            else:
+                cancel = dlg.Update(i)
+            time.sleep(.01)
+            if not cancel[0]:
+                break
+        dlg.Destroy()
+
+    def OnClick3(self, event):
+        dlg = ProgressDialog(self, title="Progress Dialog Test", 
+              message="Counting from 1 to 1000", maximum=1000, abort=1, 
+              show_elapsed_time=1, 
+              #show_estimated_time=1, 
+              show_remaining_time=1)
+        dlg.Show()
+        cancel = True
+        for i in range(1000):
+            if i % 100 == 0:
+                cancel = dlg.Update(i, "Counting from " + str(i) + " to 1000")
+            else:
+                cancel = dlg.Update(i)
+            time.sleep(.01)
+            if not cancel[0]:
+                dlg2 = MessageDialog(self, title="Continue?", text="Do you want to abort?", yes_no=1)
+                result = dlg2.ShowModal()
+                if result == "yes":
+                    dlg.Destroy()
+                    break
+                else:
+                    dlg.Resume()
+                dlg2.Destroy()
+        if dlg:
+            dlg.Destroy()
+            
+            
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="ProgressDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/Rubberband.py b/pynxc/waxy/demos/Rubberband.py
new file mode 100755
index 0000000..316850a
--- /dev/null
+++ b/pynxc/waxy/demos/Rubberband.py
@@ -0,0 +1,221 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+# Modified from:
+# Recipe 189744: wxPython Graphics - Drawing rubberbands over a canvas 
+# http://code.activestate.com/recipes/189744/
+
+class Sprite:
+    def __init__(self, fname):
+        self.bitmap = Image(fname+".png").ConvertToBitmap()
+        self.bitmap_rev = Image(fname+"rev.png").ConvertToBitmap()
+        self.background = None
+        self.pos=wx.Point(0,0)
+        self.reversed=False
+        
+    def Draw(self, dc):
+        # copy background from dc to memory object
+        memdc = wx.MemoryDC()
+        memdc.Blit(0, 0, self.bitmap.GetWidth(), self.bitmap.GetHeight(), dc,
+                   self.pos[0], self.pos[1], wx.COPY, 1)
+        self.background = memdc # keep around for later
+
+        bitmap = self.bitmap if not self.reversed else self.bitmap_rev
+        dc.DrawBitmap(bitmap, self.pos[0], self.pos[1], 1)
+        
+    def HitTest(self, pt):
+        rect = self.GetRect()
+        return rect.InsideXY(pt.x, pt.y)
+        
+    def Intersects(self, rect):
+        myrect = self.GetRect()
+        
+        # adjust for negative
+        arect=[val for val in rect]
+        if arect[2]<0:
+            arect[0]+=arect[2]
+            arect[2]=-arect[2]
+
+        if arect[3]<0:
+            arect[1]+=arect[3]
+            arect[3]=-arect[3]
+        
+        return myrect.Intersects(arect)
+        
+    def GetRect(self):
+        return wx.Rect(self.pos[0], self.pos[1],
+                      self.bitmap.GetWidth(), self.bitmap.GetHeight())
+
+class MyCanvas(Canvas):
+
+    def Init(self):
+        self.SetBackgroundColour('WHITE')
+        self.SetScrollbars(20, 20, 100, 100)
+        self.sprite = Sprite('heretic2')
+        self.sprite.pos=wx.Point(50,50)
+
+        # mouse selection start point
+        self.m_stpoint=Point(0,0)
+        # mouse selection end point
+        self.m_endpoint=Point(0,0)
+        # mouse selection cache point
+        self.m_savepoint=Point(0,0)
+        
+        # flags for left click/ selection
+        self._leftclicked=False
+        self._selected=False
+
+    def OnLeftDown(self,event):
+        
+        # Left mouse button down, change cursor to
+         # something else to denote event capture
+         self.m_stpoint = event.GetPosition()
+         self.SetCursor('cross')
+      
+         # invalidate current canvas
+         self.Refresh()
+         # cache current position
+         self.m_savepoint = self.m_stpoint
+         self.m_endpoint = self.m_savepoint
+         self._selected = False
+         self._leftclicked = True
+
+
+    def OnMotion(self,event):
+        
+        if event.Dragging() and self._leftclicked:
+            
+            # Draw new rectangle
+            self.m_endpoint =  event.GetPosition()
+            self.m_savepoint = self.m_endpoint # cache current endpoint
+            self.Refresh()
+            
+    def OnLeftUp(self,event):
+        
+        # User released left button, change cursor back
+         self.SetCursor('arrow')       
+         self._selected = True  #selection is done
+         self._leftclicked = False # end of clicking  
+         self.Refresh()
+
+    def OnDraw(self, dc):
+        dc.SetTextForeground('BLUE')
+        dc.SetPen(wx.MEDIUM_GREY_PEN)
+        for i in range(50):
+            dc.DrawLine(0, i*10, i*10, 0)
+
+        w = (self.m_endpoint.x - self.m_stpoint.x)
+        h = (self.m_endpoint.y - self.m_stpoint.y)
+        rect=self.m_stpoint.x, self.m_stpoint.y, w, h
+        
+        if self.sprite.Intersects(rect):
+            self.sprite.reversed=True
+        else:
+            self.sprite.reversed=False
+
+        self.sprite.Draw(dc)
+
+        if not self._selected:
+            dc.SetLogicalFunction(wx.XOR)
+            wbrush = wx.Brush(wx.Colour(255,255,255), wx.TRANSPARENT)
+            wpen = wx.Pen(wx.Colour(200, 200, 200), 1, wx.SOLID)
+            dc.SetBrush(wbrush)
+            dc.SetPen(wpen)
+            
+        
+            # Set clipping region to rectangle corners
+            # dc.SetClippingRegion(self.m_stpoint.x, self.m_stpoint.y, w,h)
+            dc.DrawRectangle(*rect) 
+
+
+
+    def GetCurrentSelection(self):
+        """ Return the current selected rectangle """
+
+        # if there is no selection, selection defaults to
+        # current viewport
+
+        left = Point(0,0)
+        right = Point(0,0)
+
+        # user dragged mouse to right
+        if self.m_endpoint.y > self.m_stpoint.y:
+            right = self.m_endpoint
+            left = self.m_stpoint
+        # user dragged mouse to left
+        elif self.m_endpoint.y < self.m_stpoint.y:
+            right = self.m_stpoint
+            left = self.m_endpoint
+
+        return (left.x, left.y, right.x, right.y)
+
+
+    def ClearCurrentSelection(self):
+        """ Clear the current selected rectangle """
+
+        box = self.GetCurrentSelection()
+
+        dc=wx.ClientDC(self)
+
+        w = box[2] - box[0]
+        h = box[3] - box[1]
+        dc.SetClippingRegion(box[0], box[1], w, h)
+        dc.SetLogicalFunction(wx.XOR)
+
+        # The brush is not really needed since we
+        # dont do any filling of the dc. It is set for 
+        # sake of completion.
+
+        wbrush = wx.Brush(wx.Colour(255,255,255), wx.TRANSPARENT)
+        wpen = wx.Pen(wx.Colour(200, 200, 200), 1, wx.SOLID)
+        dc.SetBrush(wbrush)
+        dc.SetPen(wpen)
+        dc.DrawRectangle(box[0], box[1], w,h)
+        self._selected = false 
+
+        # reset selection to canvas size
+        self.ResetSelection()    
+
+    def ResetSelection(self):
+        """ Resets the mouse selection to entire canvas """
+
+        self.m_stpoint = Point(0,0)
+        sz=self._canvas.GetSize()
+        w,h=sz.GetWidth(), sz.GetHeight()
+        self.m_endpoint = wxPoint(w,h)
+
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+
+
+        self.canvas = MyCanvas(self)
+        self.canvas.SetSize((400,300))
+        self.AddComponent(self.canvas, expand=1, stretch=1)
+
+        self.Pack()
+
+        self.CenterOnScreen()
+
+        self.Show()
+        
+        
+    def CloseWindow(self,event):
+        self.Close()
+
+
+
+if __name__=="__main__":
+    app = Application(MainFrame, title=__file__)
+    app.Run()
diff --git a/pynxc/waxy/demos/SingleChoiceDialog.py b/pynxc/waxy/demos/SingleChoiceDialog.py
new file mode 100755
index 0000000..0c0815d
--- /dev/null
+++ b/pynxc/waxy/demos/SingleChoiceDialog.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MyDialog(SingleChoiceDialog):
+    
+    def OnClick(self):
+        
+        print "hello!"
+        
+
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "SingleChoice Dialog",self.SingleChoice,default=True)
+        self.AddComponent(b,border=10)
+        
+        b = Button(self, "Custom SingleChoice Dialog",self.SingleChoice2)
+        self.AddComponent(b,border=10)
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def SingleChoice(self,event):
+        
+        
+        lst = [ 'apple', 'pear', 'banana', 'coconut', 'orange', 'grape', 'pineapple',
+                'blueberry', 'raspberry', 'blackberry', 'snozzleberry',
+                'etc', 'etc..', 'etc...' ]
+
+        dlg = SingleChoiceDialog( self, lst,
+                                   "Pick some fruit from\nthis list",
+                                   "SingleChoiceDialog")
+
+
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenItem()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def SingleChoice2(self,event):
+        
+        
+        lst = [ 'apple', 'pear', 'banana', 'coconut', 'orange', 'grape', 'pineapple',
+                'blueberry', 'raspberry', 'blackberry', 'snozzleberry',
+                'etc', 'etc..', 'etc...' ]
+
+        dlg = MyDialog( self, lst,
+                                   "Pick some fruit from\nthis list",
+                                   "SingleChoiceDialog")
+
+
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenItem()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+        
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="SingleChoiceDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/SingleChoiceDialog.py~ b/pynxc/waxy/demos/SingleChoiceDialog.py~
new file mode 100755
index 0000000..90eab15
--- /dev/null
+++ b/pynxc/waxy/demos/SingleChoiceDialog.py~
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+class MyDialog(SingleChoiceDialog):
+    
+    def OnClick(self):
+        
+        print "hello!"
+        
+
+
+class MainFrame(VerticalFrame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        b = Button(self, "SingleChoice Dialog",self.SingleChoice,default=True)
+        self.AddComponent(b,border=10)
+        
+        b = Button(self, "Custom SingleChoice Dialog",self.SingleChoice2)
+        self.AddComponent(b,border=10)
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+        
+    def SingleChoice(self,event):
+        
+        
+        lst = [ 'apple', 'pear', 'banana', 'coconut', 'orange', 'grape', 'pineapple',
+                'blueberry', 'raspberry', 'blackberry', 'snozzleberry',
+                'etc', 'etc..', 'etc...' ]
+
+        dlg = SingleChoiceDialog( self, lst,
+                                   "Pick some fruit from\nthis list",
+                                   "SingleChoiceDialog")
+
+
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetString()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+    def SingleChoice2(self,event):
+        
+        
+        lst = [ 'apple', 'pear', 'banana', 'coconut', 'orange', 'grape', 'pineapple',
+                'blueberry', 'raspberry', 'blackberry', 'snozzleberry',
+                'etc', 'etc..', 'etc...' ]
+
+        dlg = MyDialog( self, lst,
+                                   "Pick some fruit from\nthis list",
+                                   "SingleChoiceDialog")
+
+
+        res=dlg.ShowModal()
+        
+        if res=='ok':
+            print "Ok: ",dlg.GetChosenItem()
+            
+        else:
+            print "Canceled!"
+            
+        dlg.Destroy()
+        
+        
+    def CloseWindow(self,event):
+        self.Close()
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="SingleChoiceDialog")
+    app.Run()
diff --git a/pynxc/waxy/demos/Slider.py b/pynxc/waxy/demos/Slider.py
new file mode 100755
index 0000000..8b53d8e
--- /dev/null
+++ b/pynxc/waxy/demos/Slider.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+
+from waxy import *
+import pylab
+import numpy
+
+def myfunc(x,params):
+
+    y=params[0]+params[1]*x+params[2]*x**2
+    
+    return y
+    
+    
+def myplot(x,y):
+
+    pylab(x,y,'-o')
+    title('This is a test')
+    xlabel('This')
+    ylabel('That')
+    
+    show()
+
+class MainFrame(VerticalFrame):
+
+    def Body(self):
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        
+        s=Slider(self,min=-5.0,max=5.0,tickfreq=0.1,ticks='bottom',labels=True)
+        self.AddComponent(s,stretch=True)
+        s=FloatSlider(self,min=-5.0,max=5.0,tickfreq=0.1,ticks='bottom',labels=True)
+        self.AddComponent(s,stretch=True)
+        self.Pack()
+        self.SetSize((640, 480))
+
+    def CloseWindow(self,event):
+        self.Close()                
+
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="Slider Example")
+    app.Run()
+
diff --git a/pynxc/waxy/demos/TreeListView.py b/pynxc/waxy/demos/TreeListView.py
new file mode 100755
index 0000000..bf4bb66
--- /dev/null
+++ b/pynxc/waxy/demos/TreeListView.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+
+# treelistview-1.py
+
+from waxy import *
+import wx
+# uses wx at the moment; will be fixed later
+
+class MainFrame(Frame):
+
+    def CreateTreeListView(self, parent):
+        treelistview = TreeListView(parent,
+                       columns=["Main column", "Column 1", "Column 2"],
+                       has_buttons=1, lines=1)
+        treelistview.Size = (400, 400)
+
+        # add columns
+        treelistview.SetMainColumn(0)
+        treelistview.SetColumnWidth(0, 175)
+
+        self.root = treelistview.AddRoot("the root item")
+        treelistview.SetItemText(self.root, "col 1 root", 1)
+        treelistview.SetItemText(self.root, "col 2 root", 2)
+
+        for x in range(15):
+            text = "Item %d" % (x,)
+            child = treelistview.AppendItem(self.root, text)
+            # child is a TreeItemId or something like that :-(
+            treelistview.SetItemText(child, text + "(c1)", 1)
+            treelistview.SetItemText(child, text + "(c2)", 2)
+            # this should really be something like:
+            # child.SetText(column, text)
+            # or even:
+            # child[column] = text
+            # ...can we use a wrapper object without messing up everything?
+
+            for y in range(5):
+                text = "Item %d-%d" % (x, y)
+                last = treelistview.AppendItem(child, text)
+                treelistview.SetItemText(last, text + "(c1)", 1)
+                treelistview.SetItemText(last, text + "(c1)", 1)
+
+        return treelistview
+
+    def Body(self):
+        self.treelistview = self.CreateTreeListView(self)
+        self.AddComponent(self.treelistview, expand='both')
+        self.Pack()
+
+app = Application(MainFrame)
+app.Run()
diff --git a/pynxc/waxy/demos/TreeView.py b/pynxc/waxy/demos/TreeView.py
new file mode 100755
index 0000000..50ebe10
--- /dev/null
+++ b/pynxc/waxy/demos/TreeView.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+
+from waxy import *
+
+def filltree(tree):
+    root = tree.AddRoot("the root item")
+    for i in range(10):
+        child = tree.AppendItem(root, "Item %d" % (i,))
+        for j in range(5):
+            grandchild = tree.AppendItem(child, "Item %d" % (i*10+j))
+
+    print [x for x in tree.GetChildNodes(root)]
+
+    d = {
+        "Hans": {
+            "age": 30,
+            "sign": "Aquarius",
+            "job": "programmer",
+        },
+        "Fred": {
+            "age": "unknown",
+            "sign": "unknown",
+            "shoe size": "unknown",
+        },
+        "Old Guy John": {
+            "age": "old",
+            "sign": "Aquarius",
+        },
+        "Bob": {
+            "sign": "Taurus",
+            "job": "proprietor",
+        },
+        "Christine": {
+            "age": 17,
+            "sign": "Aries",
+            "job": "cashier",
+        }
+    }
+
+    stuff = tree.AppendItem(root, "stuff")
+    tree.LoadFromDict(stuff, d)
+
+    return tree
+
+
+
+class MainFrame(Frame): # frame has a sizer built in
+
+    def Body(self):
+
+        self.CenterOnScreen()
+
+        self.CreateStatusBar()
+        self.SetStatusText("This is the statusbar")
+
+        menubar = MenuBar(self)
+        menu1 = Menu(self)
+        menu1.Append("E&xit", self.CloseWindow, "Exit demo",hotkey="Ctrl+Q")
+        menubar.Append(menu1, "&File")
+        
+        splitter = Splitter(self)
+        self.treeview = TreeView(splitter, twist_buttons=1, has_buttons=1)
+        self.treeview.OnSelectionChanged = self.OnTreeSelectionChanged
+        self.textbox = TextBox(splitter, multiline=1)
+        splitter.Split(self.treeview, self.textbox, direction='v')
+        self.AddComponent(splitter, expand='both')
+        filltree(self.treeview)
+        
+        
+        
+        self.Pack()
+        self.SetSize((640, 480))
+
+    def CloseWindow(self,event):
+        self.Close()
+
+    def OnTreeSelectionChanged(self, event):
+        item = event.GetItem()
+        data = self.treeview.GetPyData(item)
+        if data is None:
+            data = self.treeview.GetItemText(item)
+        self.textbox.Clear()
+        self.textbox.AppendText(str(data))
+        event.Skip()
+
+
+
+
+if __name__=="__main__":
+    app = Application(MainFrame, title="TreeView")
+    app.Run()
diff --git a/pynxc/waxy/demos/heretic2.png b/pynxc/waxy/demos/heretic2.png
new file mode 100644
index 0000000..a4ede33
--- /dev/null
+++ b/pynxc/waxy/demos/heretic2.png
diff --git a/pynxc/waxy/demos/heretic2rev.png b/pynxc/waxy/demos/heretic2rev.png
new file mode 100644
index 0000000..fa92a54
--- /dev/null
+++ b/pynxc/waxy/demos/heretic2rev.png
diff --git a/pynxc/waxy/demos/plotit.py b/pynxc/waxy/demos/plotit.py
new file mode 100644
index 0000000..f5eb429
--- /dev/null
+++ b/pynxc/waxy/demos/plotit.py
@@ -0,0 +1,151 @@
+from numpy import *
+
+from waxy import *
+
+from matplotlib.backends.backend_wxagg import FigureCanvasWx as FigureCanvas
+from matplotlib.backends.backend_wx import FigureManager
+from matplotlib.figure import Figure
+from matplotlib.axes import Subplot
+
+def export_fig(parent,filename=None):
+    from matplotlib.backends.backend_pdf import FigureCanvasPdf
+    
+    if not filename:
+    
+#        parent.canvas.Show(False)
+            
+        dlg = FileDialog(parent, "Export to...",default_dir=os.getcwd(),
+                        wildcard='PNG Files|*.png|PDF Files|*.pdf|EPS Files|*.eps|SVG Files|*.svg|All Files|*.*',save=1)
+        result = dlg.ShowModal()
+        if result == 'ok':
+            filename = dlg.GetPaths()[0]
+        else:
+            filename=None
+
+        filter_index=dlg.GetFilterIndex()
+            
+        dlg.Destroy()
+
+        parent.canvas.Show(True)
+        
+        
+    if filename:
+    
+        nme,ext=os.path.splitext(filename)
+        if not ext:  # do the filter index
+            ext='.pdf'
+            
+            print filter_index
+            
+            if filter_index==0:
+                ext='.png'
+            elif filter_index==1:
+                ext='.pdf'
+            elif filter_index==2:
+                ext='.eps'
+        
+            filename=nme+ext
+    
+        nme,ext=os.path.splitext(filename)
+
+        if os.path.exists(filename):
+            dlg = MessageDialog(parent, '"%s" already exists. Do you want to replace it?' % filename,
+            'A file or folder with the same name already exists in plasticity. Replacing it will overwrite its current contents.',icon='warning',cancel=1)
+            result = dlg.ShowModal()
+            
+            if result=='cancel':
+                return
+        
+        if ext=='.pdf': # hack to fix a problem in the pdf backend
+            orig_dpi = parent.fig.dpi.get()
+            canvas_pdf = FigureCanvasPdf(parent.fig)
+            parent.fig.savefig(filename)
+            parent.fig.set_canvas(parent.canvas)  # restore automagically switched attributes
+            parent.fig.dpi.set(orig_dpi)
+        else:
+            parent.fig.savefig(filename)
+
+
+
+class MainFrame(Frame):
+
+    def __init__(self,x,y,style,parent=None):
+        self.fig=None
+        Frame.__init__(self,parent,'Plot','H',size=(750,750))
+        self.x=x
+        self.y=y
+        self.style=style
+        self.Plot()
+        
+    def Body(self):
+    
+        self.CreateMenu()
+        self.CenterOnScreen()
+        
+        self.fig = Figure(figsize=(7,5),dpi=100)
+        self.canvas = FigureCanvas(self, -1, self.fig)
+        self.figmgr = FigureManager(self.canvas, 1, self)
+
+        self.axes = [self.fig.add_subplot(111)]
+        
+    def CreateMenu(self):
+    
+        menubar = MenuBar()
+
+        menu = Menu(self)
+        menu.Append("&Run", self.Run, "Run",hotkey="Ctrl+R")
+        menu.Append("Export Figure...", self.Export, "Export the Screen")
+        menu.Append("&Quit", self.Quit, "Quit",hotkey="Ctrl+Q")
+
+        menubar.Append(menu, "&File")
+        self.running=False
+        
+        self.SetMenuBar(menubar)
+        self.CreateStatusBar()
+
+    def Export(self,event=None):
+        export_fig(self)
+        
+    
+    def Run(self,event=None):
+    
+        if self.running:
+            self.y=self.y_bak
+            self.UpdatePlot()
+
+        else:        
+            t=0.0
+            self.y_bak=self.y
+            
+            for t in linspace(0,2*pi*4,100):
+                self.y=y*cos(t)
+                self.UpdatePlot()
+
+        self.running=not self.running
+        
+    def UpdatePlot(self):
+        self.h.set_ydata(self.y)
+        self.canvas.draw()
+        self.canvas.gui_repaint()
+        wx.Yield()
+        
+    def Plot(self):
+        self.axes[0].clear()
+        self.h,=self.axes[0].plot(self.x,self.y,self.style,linewidth=3)
+        
+        self.canvas.draw()
+        self.canvas.gui_repaint()
+
+
+    def Quit(self,event=None):
+        self.Close()
+
+def Plot(x,y,style='-'):
+    app = Application(MainFrame,x,y,style)
+    app.Run()
+
+if __name__=="__main__":
+
+    x=linspace(-10,10,100)
+    y=x*sin(x)+x
+    Plot(x,y)
diff --git a/pynxc/waxy/dialog.py b/pynxc/waxy/dialog.py
new file mode 100644
index 0000000..df3397d
--- /dev/null
+++ b/pynxc/waxy/dialog.py
@@ -0,0 +1,115 @@
+# dialog.py
+
+# TODO: Pressing Esc in a dialog should be the same as Cancel...
+# (but how?  using EVT_CHAR doesn't work...  neither does OnCharHook.)
+
+import wx
+
+from button import Button
+from containers import Container
+from line import Line
+from panel import Panel
+from keys import keys
+import frame
+
+# TODO: styles (same as Frame?)
+
+class Dialog(wx.Dialog, Container):
+
+    __events__ = frame.Frame.__events__.copy()
+    __events__ .update({
+        'CharHook': wx.EVT_CHAR_HOOK,
+    })
+
+    def __init__(self, parent, title, cancel_button=1):
+        wx.Dialog.__init__(self, parent, wx.NewId(), title, wx.DefaultPosition)
+
+        # this should create self.sizer and give access to self.AddComponent
+        self._create_sizer('vertical')
+
+        # enter stuff here...
+        self.Body()
+
+        # add line and buttons pane...
+        line = Line(self, size=(20,-1), direction='horizontal')
+        self.AddComponent(line, align='center', stretch=1, border=5)
+
+        panel = self.AddButtonPanel(cancel_button)
+
+        self.BindEvents()
+
+        panel.Pack()
+        self.AddComponent(panel)
+
+        self.Pack()
+
+        self.Centre()
+
+    def AddButtonPanel(self, cancel_button=1):
+        panel = Panel(self, direction='horizontal')
+        self.okbutton = Button(panel, "OK", event=self.OnClickOKButton)
+        self.okbutton.SetDefault()
+        panel.AddComponent(self.okbutton, expand=1, border=5)
+
+        if cancel_button:
+            cancelbutton = Button(panel, "Cancel", event=self.OnClickCancelButton)
+            panel.AddComponent(cancelbutton, expand=1, border=5)
+        return panel
+
+    def OnClickOKButton(self, event=None):
+        if self.Validate():
+            event.Skip()
+            # only close the dialog if we validate:
+            self.EndModal(wx.ID_OK)
+        else:
+            self.OnValidateError(event)
+
+    def OnClickCancelButton(self, event=None):
+        self.EndModal(wx.ID_CANCEL)
+
+    def OnValidateError(self, event=None):
+        """ Override this to take action when the input does not validate.
+            (E.g. display an error message, etc.) """
+
+    def ShowModal(self):
+        """ Show the dialog modally.  Returns 'ok' or 'cancel'. """
+        r = wx.Dialog.ShowModal(self)
+        return {
+            wx.ID_OK: "ok",
+            wx.ID_CANCEL: "cancel",
+        }.get(r, "?")
+
+    def Body(self):
+        # override this
+        # NOTE: do not call self.Pack() here, it's called automatically later
+        return None
+
+    def Validate(self):
+        """ Override this to validate input and return 0 if it's not correct.
+            Return 1 otherwise. """
+        return 1
+
+    # this doesn't work -- or does it?:
+    def OnCharHook(self, event=None):
+        if event.GetKeyCode() == keys.esc:
+            self.OnClickCancelButton()
+        event.Skip()
+
+
+def showdialog(dialogclass, *args, **kwargs):
+    """ Easy function to call dialogs and clean up when it's done. """
+    dlg = dialogclass(*args, **kwargs)
+    try:
+        result = dlg.ShowModal()
+    finally:
+        dlg.Destroy()
+        
+    if result=='ok':
+        val=dlg.GetValue()
+    else:
+        val=None
+        
+    dlg.Destroy()
+    
+    return val
+
diff --git a/pynxc/waxy/dialog.py~ b/pynxc/waxy/dialog.py~
new file mode 100644
index 0000000..48444ab
--- /dev/null
+++ b/pynxc/waxy/dialog.py~
@@ -0,0 +1,108 @@
+# dialog.py
+
+# TODO: Pressing Esc in a dialog should be the same as Cancel...
+# (but how?  using EVT_CHAR doesn't work...  neither does OnCharHook.)
+
+import wx
+
+from button import Button
+from containers import Container
+from line import Line
+from panel import Panel
+from keys import keys
+import frame
+
+# TODO: styles (same as Frame?)
+
+class Dialog(wx.Dialog, Container):
+
+    __events__ = frame.Frame.__events__.copy()
+    __events__ .update({
+        'CharHook': wx.EVT_CHAR_HOOK,
+    })
+
+    def __init__(self, parent, title, cancel_button=1):
+        wx.Dialog.__init__(self, parent, wx.NewId(), title, wx.DefaultPosition)
+
+        # this should create self.sizer and give access to self.AddComponent
+        self._create_sizer('vertical')
+        self.SetDefaultFont()
+
+        # enter stuff here...
+        self.Body()
+
+        # add line and buttons pane...
+        line = Line(self, size=(20,-1), direction='horizontal')
+        self.AddComponent(line, align='center', stretch=1, border=5)
+
+        panel = self.AddButtonPanel(cancel_button)
+
+        self.BindEvents()
+
+        panel.Pack()
+        self.AddComponent(panel)
+
+        self.Pack()
+
+        self.Centre()
+
+    def AddButtonPanel(self, cancel_button=1):
+        panel = Panel(self, direction='horizontal')
+        self.okbutton = Button(panel, "OK", event=self.OnClickOKButton)
+        self.okbutton.SetDefault()
+        panel.AddComponent(self.okbutton, expand=1, border=5)
+
+        if cancel_button:
+            cancelbutton = Button(panel, "Cancel", event=self.OnClickCancelButton)
+            panel.AddComponent(cancelbutton, expand=1, border=5)
+        return panel
+
+    def OnClickOKButton(self, event=None):
+        if self.Validate():
+            event.Skip()
+            # only close the dialog if we validate:
+            self.EndModal(wx.ID_OK)
+        else:
+            self.OnValidateError(event)
+
+    def OnClickCancelButton(self, event=None):
+        self.EndModal(wx.ID_CANCEL)
+
+    def OnValidateError(self, event=None):
+        """ Override this to take action when the input does not validate.
+            (E.g. display an error message, etc.) """
+
+    def ShowModal(self):
+        """ Show the dialog modally.  Returns 'ok' or 'cancel'. """
+        r = wx.Dialog.ShowModal(self)
+        return {
+            wx.ID_OK: "ok",
+            wx.ID_CANCEL: "cancel",
+        }.get(r, "?")
+
+    def Body(self):
+        # override this
+        # NOTE: do not call self.Pack() here, it's called automatically later
+        return None
+
+    def Validate(self):
+        """ Override this to validate input and return 0 if it's not correct.
+            Return 1 otherwise. """
+        return 1
+
+    # this doesn't work -- or does it?:
+    def OnCharHook(self, event=None):
+        if event.GetKeyCode() == keys.esc:
+            self.OnClickCancelButton()
+        event.Skip()
+
+
+def showdialog(dialogclass, *args, **kwargs):
+    """ Easy function to call dialogs and clean up when it's done. """
+    dlg = dialogclass(*args, **kwargs)
+    try:
+        result = dlg.ShowModal()
+    finally:
+        dlg.Destroy()
+    return result
+
diff --git a/pynxc/waxy/directorydialog.py b/pynxc/waxy/directorydialog.py
new file mode 100644
index 0000000..5d1ee2a
--- /dev/null
+++ b/pynxc/waxy/directorydialog.py
@@ -0,0 +1,39 @@
+# choosedirectory.py
+
+import wx
+import waxyobject
+
+class DirectoryDialog(wx.DirDialog, waxyobject.WaxyObject):
+
+    def __init__(self, parent, title="Choose a directory", new_dir_button=0):
+        style = wx.DD_DEFAULT_STYLE
+        if new_dir_button:
+            style |= wx.DD_NEW_DIR_BUTTON
+        wx.DirDialog.__init__(self, parent, title, style=style)
+
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.DirDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
+
+    def GetChosenDirectory(self):
+        """ Shorthand... """
+        path = self.GetPath()
+        return path
+        
+        
+# EXPERIMENTAL:
+# This dialog returns a list of filenames (dlg.GetPath()) upon success, and
+# an empty list upon cancel.
+
+def ChooseDirectory(parent, title="Choose a directory", new_dir_button=0):
+    path = None
+    dlg = DirectoryDialog(parent, title=title, new_dir_button=new_dir_button)
+    if dlg.ShowModal() == 'ok':
+        path = dlg.GetPath()
+    dlg.Destroy()
+    return path
+
diff --git a/pynxc/waxy/directorydialog.py~ b/pynxc/waxy/directorydialog.py~
new file mode 100644
index 0000000..866a238
--- /dev/null
+++ b/pynxc/waxy/directorydialog.py~
@@ -0,0 +1,40 @@
+# choosedirectory.py
+
+import wx
+import waxyobject
+
+class DirectoryDialog(wx.DirDialog, waxyobject.WaxyObject):
+
+    def __init__(self, parent, title="Choose a directory", new_dir_button=0):
+        style = wx.DD_DEFAULT_STYLE
+        if new_dir_button:
+            style |= wx.DD_NEW_DIR_BUTTON
+        wx.DirDialog.__init__(self, parent, title, style=style)
+
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.DirDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
+
+    def GetChosenDirectory(self):
+        """ Shorthand... """
+        data = self.GetColourData()
+        color = data.GetColour().Get()
+        return color
+        
+        
+# EXPERIMENTAL:
+# This dialog returns a list of filenames (dlg.GetPath()) upon success, and
+# an empty list upon cancel.
+
+def ChooseDirectory(parent, title="Choose a directory", new_dir_button=0):
+    path = None
+    dlg = DirectoryDialog(parent, title=title, new_dir_button=new_dir_button)
+    if dlg.ShowModal() == 'ok':
+        path = dlg.GetPath()
+    dlg.Destroy()
+    return path
+
diff --git a/pynxc/waxy/dragdrop.py b/pynxc/waxy/dragdrop.py
new file mode 100644
index 0000000..05a5965
--- /dev/null
+++ b/pynxc/waxy/dragdrop.py
@@ -0,0 +1,63 @@
+# dragdrop.py
+
+import wx
+
+# These can be overridden if you need them:
+# def OnDropFiles(self, x, y, files)
+# def OnDragOver(self, x, y, d)
+# def OnEnter(self, x, y, d)
+# def OnLeave(self, d)
+#
+# However, for most purposes, it will probably suffice to pass in a function
+# to <event>.
+
+class FileDropTarget(wx.FileDropTarget):
+    # note that you can pass an event, or just override OnDropFiles.
+
+    def __init__(self, window, event=None):
+        wx.FileDropTarget.__init__(self)
+        self.window = window
+        self.event = event
+        self.window.SetDropTarget(self)
+
+    def OnDropFiles(self, x, y, filenames):
+        if self.event:
+            self.event(x, y, filenames)
+
+class TextDropTarget(wx.TextDropTarget):
+
+    def __init__(self, window, event=None):
+        wx.TextDropTarget.__init__(self)
+        self.window = window
+        self.event = event
+        self.window.SetDropTarget(self)
+
+    def OnDropText(self, x, y, text):
+        if self.event:
+            self.event(x, y, text)
+
+    def OnDragOver(self, x, y, d):
+        return wx.DragCopy
+        # XXX not sure what this does; copied from wxPython demo
+
+class URLDropTarget(wx.PyDropTarget):
+    
+    def __init__(self, window, event=None):
+        # <event> is a function with signature (x, y, d, url).
+        wx.PyDropTarget.__init__(self)
+        self.window = window
+        self.event = event
+        self.window.SetDropTarget(self)
+        self.data = wx.URLDataObject()
+        self.SetDataObject(self.data)
+        
+    def OnDragOver(self, x, y, d):
+        return wx.DragLink
+        
+    def OnData(self, x, y, d):
+        if not self.GetData():
+            return wx.DragNone
+        url = self.data.GetURL()
+        if self.event:
+            self.event(x, y, d, url)
+        return d
diff --git a/pynxc/waxy/dropdownbox.py b/pynxc/waxy/dropdownbox.py
new file mode 100644
index 0000000..345351a
--- /dev/null
+++ b/pynxc/waxy/dropdownbox.py
@@ -0,0 +1,40 @@
+# dropdownbox.py
+
+# todo: styles... if any?
+
+import wx
+import containers
+import waxyobject
+import styles
+
+class DropDownBox(wx.Choice, waxyobject.WaxyObject):
+
+    __events__ = {
+        'Select': wx.EVT_CHOICE,
+    }
+
+    def __init__(self, parent, choices=[], size=None, **kwargs):
+        style = 0
+        style |= styles.window(kwargs)
+        wx.Choice.__init__(self, parent, wx.NewId(), choices=choices,
+         size=size or (-1,-1), style=style)
+
+        self.BindEvents()
+        styles.properties(self, kwargs)
+
+    def SetItems(self, items):
+        """ Clear the internal list of items, and set new items.  <items> is
+            a list of 2-tuples (string, data). """
+        self.Clear()
+        for s, data in items:
+            self.Append(s, data)
+
+    def GetItems(self):
+        """ Return a list of 2-tuples (string, data). """
+        items = []
+        for i in range(self.GetCount()):
+            s = self.GetString(i)
+            data = self.GetClientData(i)
+            items.append((s, data))
+        return items
+
diff --git a/pynxc/waxy/dropdownbox.py~ b/pynxc/waxy/dropdownbox.py~
new file mode 100644
index 0000000..4598ff2
--- /dev/null
+++ b/pynxc/waxy/dropdownbox.py~
@@ -0,0 +1,40 @@
+# dropdownbox.py
+
+# todo: styles... if any?
+
+import wx
+import containers
+import waxyobject
+import styles
+
+class DropDownBox(wx.Choice, waxyobject.WaxyObject):
+
+    __events__ = {
+        'Select': wx.EVT_CHOICE,
+    }
+
+    def __init__(self, parent, choices=[], size=None, **kwargs):
+        style = 0
+        style |= styles.window(kwargs)
+        wx.Choice.__init__(self, parent, wx.NewId(), choices=choices,
+         size=size or (-1,-1), style=style)
+
+        self.BindEvents()
+        styles.properties(self, kwargs)
+
+    def SetItems(self, items):
+        """ Clear the internal list of items, and set new items.  <items> is
+            a list of 2-tuples (string, data). """
+        self.Clear()
+            for s, data in items:
+            self.Append(s, data)
+
+    def GetItems(self):
+        """ Return a list of 2-tuples (string, data). """
+        items = []
+        for i in range(self.GetCount()):
+            s = self.GetString(i)
+            data = self.GetClientData(i)
+            items.append((s, data))
+        return items
+
diff --git a/pynxc/waxy/events.py b/pynxc/waxy/events.py
new file mode 100644
index 0000000..a9fef15
--- /dev/null
+++ b/pynxc/waxy/events.py
@@ -0,0 +1,33 @@
+# events.py
+
+import wx
+
+# place general events here... OnEnter, OnExit, mouse events, etc.
+
+events = {
+    'Enter': wx.EVT_ENTER_WINDOW,       # entering a control w/ mouse pointer
+    'EnterWindow': wx.EVT_ENTER_WINDOW,
+    'Exit': wx.EVT_LEAVE_WINDOW,        # leaving a control w/ mouse pointer
+    'ExitWindow': wx.EVT_LEAVE_WINDOW,
+    'GetFocus': wx.EVT_SET_FOCUS,       # control gets focus
+    'HotKey': wx.EVT_HOTKEY,
+    'KeyDown': wx.EVT_KEY_DOWN,
+    'KeyUp': wx.EVT_KEY_UP,
+    'Leave': wx.EVT_LEAVE_WINDOW,
+    'LeaveWindow': wx.EVT_LEAVE_WINDOW,
+    'LeftClick': wx.EVT_LEFT_DOWN,      # alias for LeftDown
+    'LeftDown': wx.EVT_LEFT_DOWN,
+    'LeftDoubleClick': wx.EVT_LEFT_DCLICK,
+    'LeftUp': wx.EVT_LEFT_UP,
+    'LoseFocus': wx.EVT_KILL_FOCUS,     # control loses focus
+    'Motion':wx.EVT_MOTION,
+    'Move': wx.EVT_MOVE,                # window is moved. is this for frames only?
+    'Resize': wx.EVT_SIZE,              # same as 'Size'
+    'RightClick': wx.EVT_RIGHT_DOWN,    # alias for RightDown
+    'RightDown': wx.EVT_RIGHT_DOWN,
+    'RightUp': wx.EVT_RIGHT_UP,
+    'Size': wx.EVT_SIZE,                # window is resized
+
+    # NOTE: OnPaint should really be here, but this causes problems with the
+    # OnPaint method that many controls already have.
+}
diff --git a/pynxc/waxy/filedialog.py b/pynxc/waxy/filedialog.py
new file mode 100644
index 0000000..a11141e
--- /dev/null
+++ b/pynxc/waxy/filedialog.py
@@ -0,0 +1,40 @@
+# filedialog.py
+
+import wx
+import waxyobject
+
+class FileDialog(wx.FileDialog, waxyobject.WaxyObject):
+
+    def __init__(self, parent, title="Choose a file", default_dir="",
+                 default_file="", wildcard="*.*", open=0, save=0, multiple=0):
+        style = 0
+        if open:
+            style |= wx.OPEN
+        elif save:
+            style |= wx.SAVE
+            style |= wx.OVERWRITE_PROMPT
+        if multiple:
+            style |= wx.MULTIPLE
+
+        self.multiple=multiple
+            
+        wx.FileDialog.__init__(self, parent, title, default_dir, default_file,
+         wildcard, style)
+
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.FileDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
+
+        
+    def GetChosenFile(self):
+        """ Shorthand... """
+        data = self.GetPaths()
+        
+        if not self.multiple:
+            data=data[0]
+        
+        return data
diff --git a/pynxc/waxy/filedialog.py~ b/pynxc/waxy/filedialog.py~
new file mode 100644
index 0000000..2bfd2b6
--- /dev/null
+++ b/pynxc/waxy/filedialog.py~
@@ -0,0 +1,35 @@
+# filedialog.py
+
+import wx
+import waxyobject
+
+class FileDialog(wx.FileDialog, waxyobject.WaxyObject):
+
+    def __init__(self, parent, title="Choose a file", default_dir="",
+                 default_file="", wildcard="*.*", open=0, save=0, multiple=0):
+        style = 0
+        if open:
+            style |= wx.OPEN
+        elif save:
+            style |= wx.SAVE
+        if multiple:
+            style |= wx.MULTIPLE
+
+        self.multiple=multiple
+            
+        wx.FileDialog.__init__(self, parent, title, default_dir, default_file,
+         wildcard, style)
+
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.FileDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
+
+        
+    def GetChosenFile(self):
+        """ Shorthand... """
+        data = self.GetPaths()
+        return data
diff --git a/pynxc/waxy/flexgridpanel.py b/pynxc/waxy/flexgridpanel.py
new file mode 100644
index 0000000..b8e5a90
--- /dev/null
+++ b/pynxc/waxy/flexgridpanel.py
@@ -0,0 +1,21 @@
+# flexgridpanel.py
+
+# todo: styles
+
+import wx
+import containers
+import panel
+
+class FlexGridPanel(wx.Panel, containers.FlexGridContainer):
+    """ Sub-level containers inside a frame, used for layout. """
+    def __init__(self, parent=None, rows=3, cols=3, hgap=1, vgap=1,
+     growable_cols=(), growable_rows=()):
+        wx.Panel.__init__(self, parent or NULL, wx.NewId())
+
+        self._create_sizer(rows, cols, hgap, vgap)
+        self.Body()
+
+        for col in growable_cols:
+            self.AddGrowableCol(col)
+        for row in growable_rows:
+            self.AddGrowableRow(row)
diff --git a/pynxc/waxy/flexgridpanel.py~ b/pynxc/waxy/flexgridpanel.py~
new file mode 100644
index 0000000..751e1ae
--- /dev/null
+++ b/pynxc/waxy/flexgridpanel.py~
@@ -0,0 +1,22 @@
+# flexgridpanel.py
+
+# todo: styles
+
+import wx
+import containers
+import panel
+
+class FlexGridPanel(wx.Panel, containers.FlexGridContainer):
+    """ Sub-level containers inside a frame, used for layout. """
+    def __init__(self, parent=None, rows=3, cols=3, hgap=1, vgap=1,
+     growable_cols=(), growable_rows=()):
+        wx.Panel.__init__(self, parent or NULL, wx.NewId())
+
+        self._create_sizer(rows, cols, hgap, vgap)
+        self.SetDefaultFont()
+        self.Body()
+
+        for col in growable_cols:
+            self.AddGrowableCol(col)
+        for row in growable_rows:
+            self.AddGrowableRow(row)
diff --git a/pynxc/waxy/font.py b/pynxc/waxy/font.py
new file mode 100644
index 0000000..aefd228
--- /dev/null
+++ b/pynxc/waxy/font.py
@@ -0,0 +1,18 @@
+# font.py
+
+import wx
+
+class Font(wx.Font):
+    def __init__(self, name, size, italic=0, bold=0, underline=0):
+        wx.Font.__init__(self, size, wx.DEFAULT, italic and wx.ITALIC or wx.NORMAL,
+         bold and wx.BOLD or wx.NORMAL, underline, name)
+
+    def IsItalic(self):
+        return bool(self.GetStyle() & wx.ITALIC)
+
+    def IsBold(self):
+        return bool(self.GetWeight() & wx.BOLD)
+
+    def IsUnderlined(self):
+        return self.GetUnderlined()
+
diff --git a/pynxc/waxy/fontdialog.py b/pynxc/waxy/fontdialog.py
new file mode 100644
index 0000000..f4fbdca
--- /dev/null
+++ b/pynxc/waxy/fontdialog.py
@@ -0,0 +1,35 @@
+# fontdialog.py
+
+# Issues:
+# objects' GetFont() really should return a Font instance, not a wx.Font
+
+import wx
+import waxyobject
+from font import Font
+
+class FontDialog(wx.FontDialog, waxyobject.WaxyObject):
+
+    def __init__(self, parent, data=None):
+        if not data:
+            data = wx.FontData()
+        wx.FontDialog.__init__(self, parent, data)
+
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.FontDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
+
+    def GetChosenFont(self):
+        """ Shorthand... """
+        data = self.GetFontData()
+        font = data.GetChosenFont()
+        font.__class__ = Font
+        return font
+
+# XXX
+# Problem: GetFontData() returns a wxFontData object, whose GetChosenFont()
+# still returns a wxFont, not a wax Font.  No big deal really, but inconsistent.
+# Maybe Wax needs its own FontData class...?
diff --git a/pynxc/waxy/fontdialog.py~ b/pynxc/waxy/fontdialog.py~
new file mode 100644
index 0000000..e6959c0
--- /dev/null
+++ b/pynxc/waxy/fontdialog.py~
@@ -0,0 +1,35 @@
+# fontdialog.py
+
+# Issues:
+# objects' GetFont() really should return a Font instance, not a wx.Font
+
+import wx
+import waxyobject
+from font import Font
+
+class FontDialog(wx.FontDialog, waxobject.WaxObject):
+
+    def __init__(self, parent, data=None):
+        if not data:
+            data = wx.FontData()
+        wx.FontDialog.__init__(self, parent, data)
+
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.FontDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
+
+    def GetChosenFont(self):
+        """ Shorthand... """
+        data = self.GetFontData()
+        font = data.GetChosenFont()
+        font.__class__ = Font
+        return font
+
+# XXX
+# Problem: GetFontData() returns a wxFontData object, whose GetChosenFont()
+# still returns a wxFont, not a wax Font.  No big deal really, but inconsistent.
+# Maybe Wax needs its own FontData class...?
diff --git a/pynxc/waxy/frame.py b/pynxc/waxy/frame.py
new file mode 100644
index 0000000..c98e932
--- /dev/null
+++ b/pynxc/waxy/frame.py
@@ -0,0 +1,67 @@
+# frame.py
+
+import wx
+import containers
+import styles
+
+class Frame(wx.Frame, containers.Container):
+    """ Top-level frame (window) with built-in sizer. """
+
+    __events__ = {
+        'Close': wx.EVT_CLOSE,
+        'Iconize': wx.EVT_ICONIZE,
+        'Show': wx.EVT_SHOW,
+        'Activate': wx.EVT_ACTIVATE,
+        'Idle': wx.EVT_IDLE,
+        # some of these might be better off in events.py?
+
+        'MenuHighlight': wx.EVT_MENU_HIGHLIGHT,
+    }
+
+    def __init__(self, parent=None, title="", direction="H", size=None, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.Frame.__init__(self, parent, wx.NewId(), title, size=size or (-1,-1),
+         style=style)
+
+        self.BindEvents()
+
+        self._create_sizer(direction)
+        styles.properties(self, kwargs)
+        self.Body()
+
+    def SetIcon(self, obj):
+        """ Like wx.Frame.SetIcon, but also accepts a path to an icon file. """
+        if isinstance(obj, str) or isinstance(obj, unicode):
+            obj = wx.Icon(obj, wx.BITMAP_TYPE_ICO)    # FIXME
+        wx.Frame.SetIcon(self, obj)
+
+    #
+    # style parameters
+
+    def _params(self, kwargs):
+        flags = wx.DEFAULT_FRAME_STYLE
+
+        # REMOVE this flag if resize=0:
+        flags &= ~(styles.styleboolexclude('resize', wx.RESIZE_BORDER, kwargs, reverse=1))
+        flags &= ~(styles.styleboolexclude('close_box', wx.CLOSE_BOX, kwargs, reverse=1))
+        flags &= ~(styles.styleboolexclude('minimize_box', wx.MINIMIZE_BOX, kwargs, reverse=1))
+        flags &= ~(styles.styleboolexclude('maximize_box', wx.MAXIMIZE_BOX, kwargs, reverse=1))
+
+        flags |= styles.stylebool('shaped', wx.FRAME_SHAPED, kwargs)
+        flags |= styles.stylebool('stayontop', wx.STAY_ON_TOP, kwargs)
+        flags |= styles.stylebool('stay_on_top', wx.STAY_ON_TOP, kwargs)
+        return flags
+
+
+
+class HorizontalFrame(Frame):
+    def __init__(self, parent=None, title="", *args, **kwargs):
+        Frame.__init__(self, parent=parent, title=title, direction='h', *args, **kwargs)
+
+class VerticalFrame(Frame):
+    def __init__(self, parent=None, title="", *args, **kwargs):
+        Frame.__init__(self, parent=parent, title=title, direction='v', *args, **kwargs)
+
diff --git a/pynxc/waxy/frame.py~ b/pynxc/waxy/frame.py~
new file mode 100644
index 0000000..0758ca2
--- /dev/null
+++ b/pynxc/waxy/frame.py~
@@ -0,0 +1,68 @@
+# frame.py
+
+import wx
+import containers
+import styles
+
+class Frame(wx.Frame, containers.Container):
+    """ Top-level frame (window) with built-in sizer. """
+
+    __events__ = {
+        'Close': wx.EVT_CLOSE,
+        'Iconize': wx.EVT_ICONIZE,
+        'Show': wx.EVT_SHOW,
+        'Activate': wx.EVT_ACTIVATE,
+        'Idle': wx.EVT_IDLE,
+        # some of these might be better off in events.py?
+
+        'MenuHighlight': wx.EVT_MENU_HIGHLIGHT,
+    }
+
+    def __init__(self, parent=None, title="", direction="H", size=None, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.Frame.__init__(self, parent, wx.NewId(), title, size=size or (-1,-1),
+         style=style)
+
+        self.BindEvents()
+
+        self._create_sizer(direction)
+#        self.SetDefaultFont()
+        styles.properties(self, kwargs)
+        self.Body()
+
+    def SetIcon(self, obj):
+        """ Like wx.Frame.SetIcon, but also accepts a path to an icon file. """
+        if isinstance(obj, str) or isinstance(obj, unicode):
+            obj = wx.Icon(obj, wx.BITMAP_TYPE_ICO)    # FIXME
+        wx.Frame.SetIcon(self, obj)
+
+    #
+    # style parameters
+
+    def _params(self, kwargs):
+        flags = wx.DEFAULT_FRAME_STYLE
+
+        # REMOVE this flag if resize=0:
+        flags &= ~(styles.styleboolexclude('resize', wx.RESIZE_BORDER, kwargs, reverse=1))
+        flags &= ~(styles.styleboolexclude('close_box', wx.CLOSE_BOX, kwargs, reverse=1))
+        flags &= ~(styles.styleboolexclude('minimize_box', wx.MINIMIZE_BOX, kwargs, reverse=1))
+        flags &= ~(styles.styleboolexclude('maximize_box', wx.MAXIMIZE_BOX, kwargs, reverse=1))
+
+        flags |= styles.stylebool('shaped', wx.FRAME_SHAPED, kwargs)
+        flags |= styles.stylebool('stayontop', wx.STAY_ON_TOP, kwargs)
+        flags |= styles.stylebool('stay_on_top', wx.STAY_ON_TOP, kwargs)
+        return flags
+
+
+
+class HorizontalFrame(Frame):
+    def __init__(self, parent=None, title="", *args, **kwargs):
+        Frame.__init__(self, parent=parent, title=title, direction='h', *args, **kwargs)
+
+class VerticalFrame(Frame):
+    def __init__(self, parent=None, title="", *args, **kwargs):
+        Frame.__init__(self, parent=parent, title=title, direction='v', *args, **kwargs)
+
diff --git a/pynxc/waxy/grid.py b/pynxc/waxy/grid.py
new file mode 100644
index 0000000..e246405
--- /dev/null
+++ b/pynxc/waxy/grid.py
@@ -0,0 +1,52 @@
+# grid.py
+
+# todo: styles
+
+import wx
+import wx.grid as gridlib
+import waxyobject
+
+class Grid(gridlib.Grid, waxyobject.WaxyObject):
+
+    __events__ = {
+        'CellLeftClick': gridlib.EVT_GRID_CELL_LEFT_CLICK,
+        'CellRightClick': gridlib.EVT_GRID_CELL_RIGHT_CLICK,
+        'CellLeftDoubleClick': gridlib.EVT_GRID_CELL_LEFT_DCLICK,
+        'CellRightDoubleClick': gridlib.EVT_GRID_CELL_RIGHT_DCLICK,
+        'LabelLeftClick': gridlib.EVT_GRID_LABEL_LEFT_CLICK,
+        'LabelRightClick': gridlib.EVT_GRID_LABEL_RIGHT_CLICK,
+        'LabelLeftDoubleClick': gridlib.EVT_GRID_LABEL_LEFT_DCLICK,
+        'LabelRightDoubleClick': gridlib.EVT_GRID_LABEL_RIGHT_DCLICK,
+        'RowSize': gridlib.EVT_GRID_ROW_SIZE,
+        'ColSize': gridlib.EVT_GRID_COL_SIZE,
+        'RangeSelect': gridlib.EVT_GRID_RANGE_SELECT,
+        'CellChange':gridlib.EVT_GRID_CELL_CHANGE,
+        'SelectCell':gridlib.EVT_GRID_SELECT_CELL,
+        'EditorShown':gridlib.EVT_GRID_EDITOR_SHOWN, 
+        'EditorHidden':gridlib.EVT_GRID_EDITOR_HIDDEN,
+        'EditorCreated':gridlib.EVT_GRID_EDITOR_CREATED,
+    }
+
+
+    def __init__(self, parent, numrows=10, numcolumns=10):
+        gridlib.Grid.__init__(self, parent, wx.NewId())
+        self.CreateGrid(numrows, numcolumns)
+        self.BindEvents()
+        
+    def SetGlobalSize(self, rowsize, colsize):
+        """ Set all cells to the same size. """
+        for i in range(self.GetNumberRows()):
+            self.SetRowSize(i, rowsize)
+        for i in range(self.GetNumberCols()):
+            self.SetColSize(i, colsize)
+
+    def __setitem__(self, index, value):
+        assert isinstance(index, tuple) and len(index) == 2
+        row, column = index
+        self.SetCellValue(row, column, value)
+
+    def __getitem__(self, index):
+        assert isinstance(index, tuple) and len(index) == 2
+        row, column = index
+        return self.GetCellValue(row, column)
+
diff --git a/pynxc/waxy/gridpanel.py b/pynxc/waxy/gridpanel.py
new file mode 100644
index 0000000..ff010af
--- /dev/null
+++ b/pynxc/waxy/gridpanel.py
@@ -0,0 +1,24 @@
+# gridpanel.py
+
+# todo: styles
+
+import wx
+import containers
+import panel
+
+class GridPanel(wx.Panel, containers.GridContainer):
+    """ Sub-level containers inside a frame, used for layout. """
+    def __init__(self, parent=None, rows=3, cols=3, hgap=1, vgap=1):
+        wx.Panel.__init__(self, parent or NULL, wx.NewId())
+
+        self._create_sizer(rows, cols, hgap, vgap)
+#        self.SetDefaultFont()
+        self.Body()
+
+'''
+NOTES
+
+1. Do not make the mistake of writing GridPanel(parent, 3, 3, 2, 2) or something
+like that.  This will work, but set the *title* to 3, and cols to 2.
+Why does a Panel need a title anyway?  Can we remove this?
+'''
diff --git a/pynxc/waxy/htmlwindow.py b/pynxc/waxy/htmlwindow.py
new file mode 100644
index 0000000..4453bcd
--- /dev/null
+++ b/pynxc/waxy/htmlwindow.py
@@ -0,0 +1,15 @@
+# htmlwindow.py
+
+# todo: styles
+
+import wx.html
+import waxyobject
+
+class HTMLWindow(wx.html.HtmlWindow, waxyobject.WaxyObject):
+
+    def __init__(self, parent, fullrepaint=1):
+        style = 0
+        if not fullrepaint:
+            style |= wx.NO_FULL_REPAINT_ON_RESIZE
+        wx.html.HtmlWindow.__init__(self, parent, wx.NewId(), style=style)
+
diff --git a/pynxc/waxy/htmlwindow.py~ b/pynxc/waxy/htmlwindow.py~
new file mode 100644
index 0000000..57a649d
--- /dev/null
+++ b/pynxc/waxy/htmlwindow.py~
@@ -0,0 +1,15 @@
+# htmlwindow.py
+
+# todo: styles
+
+import wx.html
+import waxobject
+
+class HTMLWindow(wx.html.HtmlWindow, waxobject.WaxObject):
+
+    def __init__(self, parent, fullrepaint=1):
+        style = 0
+        if not fullrepaint:
+            style |= wx.NO_FULL_REPAINT_ON_RESIZE
+        wx.html.HtmlWindow.__init__(self, parent, wx.NewId(), style=style)
+
diff --git a/pynxc/waxy/image.py b/pynxc/waxy/image.py
new file mode 100644
index 0000000..e18bfc8
--- /dev/null
+++ b/pynxc/waxy/image.py
@@ -0,0 +1,115 @@
+# image.py
+
+import wx
+import waxyobject
+
+_handlers = {}
+
+def AddImageHandler(type):
+    d = {
+        "bmp": wx.BMPHandler,
+        "png": wx.PNGHandler,
+        "jpg": wx.JPEGHandler,
+        "gif": wx.GIFHandler,
+        "pcx": wx.PCXHandler,
+        "pnm": wx.PNMHandler,
+        "tiff": wx.TIFFHandler,
+        #"iff": wx.IFFHandler,
+        #"xpm": wx.XPMHandler,
+        "ico": wx.ICOHandler,
+        "cur": wx.CURHandler,
+        "ani": wx.ANIHandler,
+    }
+    key = type.lower()
+    handler = d[key]
+    wx.Image_AddHandler(handler())
+    _handlers[key] = 1
+
+def AddAllImageHandlers():
+    wx.InitAllImageHandlers()
+
+class Image(wx.Image, waxyobject.WaxyObject):
+
+    def __init__(self, filename, type=None, autoinstall=False):
+        lfilename = filename.lower()
+        t = 0
+
+        # if type isn't set, try to grok it from the filename.
+        if not type:
+            if lfilename.endswith(".bmp"):
+                type = 'bmp'
+            elif lfilename.endswith(".gif"):
+                type = 'gif'
+            elif lfilename.endswith(".png"):
+                type = 'png'
+            elif lfilename.endswith(".jpg") or lfilename.endswith(".jpeg"):
+                type = 'jpg'
+            elif lfilename.endswith(".pcx"):
+                type = 'pcx'
+            elif lfilename.endswith(".ico"):
+                type = 'ico'
+
+        t = {
+            "bmp": wx.BITMAP_TYPE_BMP,
+            "gif": wx.BITMAP_TYPE_GIF,
+            "png": wx.BITMAP_TYPE_PNG,
+            "jpg": wx.BITMAP_TYPE_JPEG,
+            "jpeg": wx.BITMAP_TYPE_JPEG,
+            "pcx": wx.BITMAP_TYPE_PCX,
+            "ico": wx.BITMAP_TYPE_ICO,
+        }.get(type.lower(), 0)
+
+        if not t:
+            raise ValueError, "Could not determine bitmap type of '%s'" % (
+                  filename,)
+
+        # if autoinstall is true, install handler on demand
+        if autoinstall:
+            if not _handlers.has_key(type):
+                AddImageHandler(type)
+
+        wx.Image.__init__(self, filename, t)
+
+
+def ImageAsBitmap(filename, *args, **kwargs):
+    return Image(filename, *args, **kwargs).ConvertToBitmap()
+
+class ImagePanel(wx.Panel, waxyobject.WaxyObject):
+
+    def __init__(self,parent,image,size=(200,200),pos=(0,0)):
+    
+        wx.Panel.__init__(self,parent, size=size,pos=pos)
+       
+        if isinstance(image,str):
+            self.image=Image(image)
+        else:
+            self.image=image
+        
+        self.bitmap=wx.StaticBitmap(self, -1, self.image.ConvertToBitmap(),
+                                    style=wx.TAB_TRAVERSAL|wx.SIMPLE_BORDER)
+        self.update()
+
+    def SetImage(self,image):
+        
+        if isinstance(image,str):
+            image=Image(image)
+            
+        self.image=image
+        self.update()
+
+    def update(self):
+    
+        size=self.GetSizeTuple()
+        
+        imsize=(self.image.GetWidth(),self.image.GetHeight())
+        
+        if (float(imsize[0])/float(size[0]))>(float(imsize[1])/float(size[1])):
+            scale=(float(imsize[0])/float(size[0]))
+        else:
+            scale=(float(imsize[1])/float(size[1]))
+            
+        newsize=(int(imsize[0]/scale),int(imsize[1]/scale))
+        newpos=( (size[0]-newsize[0])/2, (size[1]-newsize[1])/2)
+        self.bitmap.SetBitmap(self.image.Rescale(newsize[0],newsize[1]).ConvertToBitmap())
+        self.bitmap.SetPosition(newpos);        
+
diff --git a/pynxc/waxy/image.py~ b/pynxc/waxy/image.py~
new file mode 100644
index 0000000..7b0d062
--- /dev/null
+++ b/pynxc/waxy/image.py~
@@ -0,0 +1,116 @@
+# image.py
+
+import wx
+import waxyobject
+
+_handlers = {}
+
+def AddImageHandler(type):
+    d = {
+        "bmp": wx.BMPHandler,
+        "png": wx.PNGHandler,
+        "jpg": wx.JPEGHandler,
+        "gif": wx.GIFHandler,
+        "pcx": wx.PCXHandler,
+        "pnm": wx.PNMHandler,
+        "tiff": wx.TIFFHandler,
+        #"iff": wx.IFFHandler,
+        #"xpm": wx.XPMHandler,
+        "ico": wx.ICOHandler,
+        "cur": wx.CURHandler,
+        "ani": wx.ANIHandler,
+    }
+    key = type.lower()
+    handler = d[key]
+    wx.Image_AddHandler(handler())
+    _handlers[key] = 1
+
+def AddAllImageHandlers():
+    wx.InitAllImageHandlers()
+
+class Image(wx.Image, waxyobject.WaxyObject):
+
+    def __init__(self, filename, type=None, autoinstall=False):
+        lfilename = filename.lower()
+        t = 0
+
+        # if type isn't set, try to grok it from the filename.
+        if not type:
+            if lfilename.endswith(".bmp"):
+                type = 'bmp'
+            elif lfilename.endswith(".gif"):
+                type = 'gif'
+            elif lfilename.endswith(".png"):
+                type = 'png'
+            elif lfilename.endswith(".jpg") or lfilename.endswith(".jpeg"):
+                type = 'jpg'
+            elif lfilename.endswith(".pcx"):
+                type = 'pcx'
+            elif lfilename.endswith(".ico"):
+                type = 'ico'
+
+        t = {
+            "bmp": wx.BITMAP_TYPE_BMP,
+            "gif": wx.BITMAP_TYPE_GIF,
+            "png": wx.BITMAP_TYPE_PNG,
+            "jpg": wx.BITMAP_TYPE_JPEG,
+            "jpeg": wx.BITMAP_TYPE_JPEG,
+            "pcx": wx.BITMAP_TYPE_PCX,
+            "ico": wx.BITMAP_TYPE_ICO,
+        }.get(type.lower(), 0)
+
+        if not t:
+            raise ValueError, "Could not determine bitmap type of '%s'" % (
+                  filename,)
+
+        # if autoinstall is true, install handler on demand
+        if autoinstall:
+            if not _handlers.has_key(type):
+                AddImageHandler(type)
+
+        wx.Image.__init__(self, filename, t)
+
+
+def ImageAsBitmap(filename, *args, **kwargs):
+    return Image(filename, *args, **kwargs).ConvertToBitmap()
+
+class ImagePanel(wx.Panel, waxyobject.WaxyObject):
+
+    def __init__(self,parent,image_filename,size=(200,200),pos=(0,0)):
+    
+        wx.Panel.__init__(self,parent, size=size,pos=pos)
+       
+        if isinstance(image_filename,str):
+        
+            self.image=Image(image_filename)
+        else:
+            self.image=image_filename
+        
+        self.bitmap=wx.StaticBitmap(self, -1, self.image.ConvertToBitmap(),
+                                    style=wx.TAB_TRAVERSAL|wx.SIMPLE_BORDER)
+        self.update()
+
+    def SetImage(self,image):
+        
+        if isinstance(image,str):
+            image=Image(image)
+            
+        self.image=image
+        self.update()
+
+    def update(self):
+    
+        size=self.GetSizeTuple()
+        
+        imsize=(self.image.GetWidth(),self.image.GetHeight())
+        
+        if (float(imsize[0])/float(size[0]))>(float(imsize[1])/float(size[1])):
+            scale=(float(imsize[0])/float(size[0]))
+        else:
+            scale=(float(imsize[1])/float(size[1]))
+            
+        newsize=(int(imsize[0]/scale),int(imsize[1]/scale))
+        newpos=( (size[0]-newsize[0])/2, (size[1]-newsize[1])/2)
+        self.bitmap.SetBitmap(self.image.Rescale(newsize[0],newsize[1]).ConvertToBitmap())
+        self.bitmap.SetPosition(newpos);        
+
diff --git a/pynxc/waxy/imagelist.py b/pynxc/waxy/imagelist.py
new file mode 100644
index 0000000..f23c91d
--- /dev/null
+++ b/pynxc/waxy/imagelist.py
@@ -0,0 +1,38 @@
+"""\
+imagelist.py
+
+Wax's version of the wxImageList is a bit more user-friendly:
+
+Rather than forcing you to keep the indexes around or know them by heart,
+you can (optionally) add names for the images you add, then look them up to
+retrieve the index:
+
+  imagelist.Add(bitmap, 'folder')
+  imagelist.Add(bitmap, 'folder_open')
+
+  somecontrol.SetItemImage(node, imagelist['folder'])
+
+"""
+
+import wx
+
+class ImageList(wx.ImageList):
+
+    def __init__(self, *args, **kwargs):
+        wx.ImageList.__init__(self, *args, **kwargs)
+        self._names = {}
+
+    def Add(self, bitmap, name=None):
+        if isinstance(bitmap, str) or isinstance(bitmap, unicode):
+            bitmap = wx.BitmapFromImage(wx.Image(bitmap))
+           
+        index = wx.ImageList.Add(self, bitmap)
+        if name:
+            self._names[name] = index
+
+        return index
+    def GetIndexByName(self, name):
+        return self._names[name]
+
+    def __getitem__(self, name):
+        return self.GetIndexByName(name)
diff --git a/pynxc/waxy/imagepanel.py b/pynxc/waxy/imagepanel.py
new file mode 100644
index 0000000..d04609c
--- /dev/null
+++ b/pynxc/waxy/imagepanel.py
@@ -0,0 +1,34 @@
+import wx
+
+class ImagePanel(wx.Panel):
+
+    def __init__(self,parent,id,size=(200,200),image=None,pos=(0,0)):
+    
+        wx.Panel.__init__(self,parent, id,size=size,pos=pos)
+       
+        self.image=image
+        
+        self.bitmap=wx.StaticBitmap(self, -1, image.ConvertToBitmap(),
+                                    style=wx.TAB_TRAVERSAL|wx.SIMPLE_BORDER)
+        self.update()
+
+    def SetImage(self,image):
+        self.image=image
+        self.update()
+
+    def update(self):
+    
+        size=self.GetSizeTuple()
+        imsize=(self.image.GetWidth(),self.image.GetHeight())
+        
+        if (float(imsize[0])/float(size[0]))>(float(imsize[1])/float(size[1])):
+            scale=(float(imsize[0])/float(size[0]))
+        else:
+            scale=(float(imsize[1])/float(size[1]))
+            
+        newsize=(int(imsize[0]/scale),int(imsize[1]/scale))
+        newpos=( (size[0]-newsize[0])/2, (size[1]-newsize[1])/2)
+        self.bitmap.SetBitmap(self.image.Rescale(newsize[0],newsize[1]).ConvertToBitmap())
+        self.bitmap.SetPosition(newpos);        
+
+        
diff --git a/pynxc/waxy/imagepanel.py~ b/pynxc/waxy/imagepanel.py~
new file mode 100644
index 0000000..af2081f
--- /dev/null
+++ b/pynxc/waxy/imagepanel.py~
@@ -0,0 +1,33 @@
+import wx
+
+class ImagePanel(wx.Panel):
+
+    def __init__(self,parent,id,size=(200,200),image=None,pos=(0,0)):
+    
+        wx.Panel.__init__(self,parent, id,size=size,pos=pos)
+       
+        self.image=image
+        
+        self.bitmap=wx.StaticBitmap(self, -1, image.ConvertToBitmap(),
+                                    style=wx.TAB_TRAVERSAL|wx.SIMPLE_BORDER)
+        self.update()
+
+    def SetImage(self,image):
+        self.image=image
+        self.update()
+
+    def update(self):
+    
+        size=self.GetSizeTuple()
+        imsize=(self.image.GetWidth(),self.image.GetHeight())
+        
+        if (float(imsize[0])/float(size[0]))>(float(imsize[1])/float(size[1])):
+            scale=(float(imsize[0])/float(size[0]))
+        else:
+            scale=(float(imsize[1])/float(size[1]))
+            
+        newsize=(int(imsize[0]/scale),int(imsize[1]/scale))
+        newpos=( (size[0]-newsize[0])/2, (size[1]-newsize[1])/2)
+        self.bitmap.SetBitmap(self.image.Rescale(newsize[0],newsize[1]).ConvertToBitmap())
+        self.bitmap.SetPosition(newpos);        
+
diff --git a/pynxc/waxy/keys.py b/pynxc/waxy/keys.py
new file mode 100644
index 0000000..dc3b355
--- /dev/null
+++ b/pynxc/waxy/keys.py
@@ -0,0 +1,44 @@
+# keys.py
+
+import wx
+
+class keys:
+    enter = wx.WXK_RETURN
+    # 'return' is not valid; reserved word
+
+    alt = wx.WXK_ALT
+    control = ctrl = wx.WXK_CONTROL
+    shift = wx.WXK_SHIFT
+
+    f1 = F1 = wx.WXK_F1
+    f2 = F2 = wx.WXK_F2
+    f3 = F3 = wx.WXK_F3
+    f4 = F4 = wx.WXK_F4
+    f5 = F5 = wx.WXK_F5
+    f6 = F6 = wx.WXK_F6
+    f7 = F7 = wx.WXK_F7
+    f8 = F8 = wx.WXK_F8
+    f9 = F9 = wx.WXK_F9
+    f10 = F10 = wx.WXK_F10
+    f11 = F11 = wx.WXK_F11
+    f12 = F12 = wx.WXK_F12
+
+    insert = wx.WXK_INSERT
+    delete = wx.WXK_DELETE
+    home = wx.WXK_HOME
+    end = wx.WXK_END
+
+    up = cursor_up = wx.WXK_UP
+    down = cursor_down = wx.WXK_DOWN
+    left = cursor_left = wx.WXK_LEFT
+    right = cursor_right = wx.WXK_RIGHT
+
+    pageup = pgup = wx.WXK_PRIOR   # not: wx.WXK_PAGEUP
+    pagedown = pgdown = pgdn = wx.WXK_NEXT # not: wx.WXK_PAGEDOWN
+
+    tab = wx.WXK_TAB
+    backspace = bsp = wx.WXK_BACK
+    esc = escape = wx.WXK_ESCAPE
+
+    # XXX more later...?
+
diff --git a/pynxc/waxy/label.py b/pynxc/waxy/label.py
new file mode 100644
index 0000000..ed77117
--- /dev/null
+++ b/pynxc/waxy/label.py
@@ -0,0 +1,33 @@
+# label.py
+
+import wx
+import containers
+import waxyobject
+import styles
+
+class Label(wx.StaticText, waxyobject.WaxyObject):
+
+    def __init__(self, parent, text="", size=None, **kwargs):
+        #assert isinstance(parent, containers.Container)
+
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.StaticText.__init__(self, parent, wx.NewId(), text,
+         size=size or (-1,-1), style=style)
+        styles.properties(self, kwargs)
+
+    #
+    # style parameters
+
+    __styles__ = {
+        'align': ({
+            'left': wx.ALIGN_LEFT,
+            'right': wx.ALIGN_RIGHT,
+            'center': wx.ALIGN_CENTRE,
+            'centre': wx.ALIGN_CENTRE,
+        }, styles.DICTSTART),
+        'noresize': (wx.ST_NO_AUTORESIZE, styles.NORMAL),
+    }
+    
diff --git a/pynxc/waxy/label.py~ b/pynxc/waxy/label.py~
new file mode 100644
index 0000000..eb2e266
--- /dev/null
+++ b/pynxc/waxy/label.py~
@@ -0,0 +1,33 @@
+# label.py
+
+import wx
+import containers
+import waxyobject
+import styles
+
+class Label(wx.StaticText, waxyobject.WaxObject):
+
+    def __init__(self, parent, text="", size=None, **kwargs):
+        #assert isinstance(parent, containers.Container)
+
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.StaticText.__init__(self, parent, wx.NewId(), text,
+         size=size or (-1,-1), style=style)
+        styles.properties(self, kwargs)
+
+    #
+    # style parameters
+
+    __styles__ = {
+        'align': ({
+            'left': wx.ALIGN_LEFT,
+            'right': wx.ALIGN_RIGHT,
+            'center': wx.ALIGN_CENTRE,
+            'centre': wx.ALIGN_CENTRE,
+        }, styles.DICTSTART),
+        'noresize': (wx.ST_NO_AUTORESIZE, styles.NORMAL),
+    }
+    
diff --git a/pynxc/waxy/line.py b/pynxc/waxy/line.py
new file mode 100644
index 0000000..f25448c
--- /dev/null
+++ b/pynxc/waxy/line.py
@@ -0,0 +1,18 @@
+# line.py
+
+import wx
+import waxyobject
+
+class Line(wx.StaticLine, waxyobject.WaxyObject):
+
+    def __init__(self, parent, size=(20,-1), direction='horizontal'):
+        style = 0
+        if direction.lower().startswith('h'):
+            style |= wx.LI_HORIZONTAL
+        elif direction.lower().startswith('v'):
+            style |= wx.LI_HORIZONTAL
+        else:
+            raise ValueError, "direction should be horizontal or vertical"
+
+        wx.StaticLine.__init__(self, parent, wx.NewId(), size=size, style=style)
+
diff --git a/pynxc/waxy/line.py~ b/pynxc/waxy/line.py~
new file mode 100644
index 0000000..6653a3e
--- /dev/null
+++ b/pynxc/waxy/line.py~
@@ -0,0 +1,18 @@
+# line.py
+
+import wx
+import waxyobject
+
+class Line(wx.StaticLine, waxyobject.WaxObject):
+
+    def __init__(self, parent, size=(20,-1), direction='horizontal'):
+        style = 0
+        if direction.lower().startswith('h'):
+            style |= wx.LI_HORIZONTAL
+        elif direction.lower().startswith('v'):
+            style |= wx.LI_HORIZONTAL
+        else:
+            raise ValueError, "direction should be horizontal or vertical"
+
+        wx.StaticLine.__init__(self, parent, wx.NewId(), size=size, style=style)
+
diff --git a/pynxc/waxy/listbox.py b/pynxc/waxy/listbox.py
new file mode 100644
index 0000000..c1283cc
--- /dev/null
+++ b/pynxc/waxy/listbox.py
@@ -0,0 +1,92 @@
+# listbox.py
+
+import wx
+import containers
+import waxyobject
+import styles
+
+class ListBox(wx.ListBox, waxyobject.WaxyObject):
+
+    __events__ = {
+        'Click': wx.EVT_LISTBOX,
+        'DoubleClick': wx.EVT_LISTBOX_DCLICK,
+    }
+
+    def __init__(self, parent, choices=[], size=None, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.ListBox.__init__(self, parent, wx.NewId(), size=size or (-1,-1),
+         choices=choices, style=style)
+
+        self.BindEvents()
+
+        styles.properties(self, kwargs)
+
+    def SetSelectionType(self, selection):
+        style = 0
+        selection = selection.lower()
+        if selection == "single":
+            style |= wx.LB_SINGLE
+        elif selection == "multiple":
+            style |= wx.LB_MULTIPLE
+        elif selection == "extended":
+            style |= wx.LB_EXTENDED
+        else:
+            raise ValueError, "selection must be single, multiple or extended"
+        return style
+
+    def SetItems(self, items):
+        """ Clear the internal list of items, and set new items.  <items> is
+            a list of 2-tuples (string, data). """
+        self.Clear()
+        for s, data in items:
+            self.Append(s, data)
+
+    def Fill(self, items):
+        """ Like SetItems, but just uses a list of strings. """
+        self.Clear()
+        for s in items:
+            self.Append(s)
+
+    def GetItems(self):
+        """ Return a list of 2-tuples (string, data). """
+        items = []
+        for i in range(self.GetCount()):
+            s = self.GetString(i)
+            data = self.GetClientData(i)
+            items.append((s, data))
+        return items
+
+    # TODO:
+    # Add __getitem__, __setitem__, __delitem__
+    # These should probably work with tuples (string, data).
+    # 1-tuples can be used, in which case data are left alone.
+    # Non-tuples are not allowed.
+
+    # We should also be able to iterate over a ListBox...
+    # Although for (s, data) in listbox.GetItems() would work too.
+
+    #
+    # style parameters
+
+    _listbox_selection = {
+        'single': wx.LB_SINGLE,
+        'multiple': wx.LB_MULTIPLE,
+        'extended': wx.LB_EXTENDED,
+    }
+
+    _listbox_scrollbar = {
+        'always': wx.LB_ALWAYS_SB,
+        'needed': wx.LB_NEEDED_SB,
+    }
+
+    def _params(self, kwargs):
+        flags = 0
+        flags |= styles.styledictstart('selection', self._listbox_selection, kwargs)
+        flags |= styles.styledictstart('scrollbar', self._listbox_scrollbar, kwargs)
+        flags |= styles.stylebool('sort', wx.LB_SORT, kwargs)
+        flags |= styles.stylebool('horizontal_scrollbar', wx.LB_HSCROLL, kwargs)
+
+        return flags
diff --git a/pynxc/waxy/listbox.py~ b/pynxc/waxy/listbox.py~
new file mode 100644
index 0000000..377694a
--- /dev/null
+++ b/pynxc/waxy/listbox.py~
@@ -0,0 +1,92 @@
+# listbox.py
+
+import wx
+import containers
+import waxobject
+import styles
+
+class ListBox(wx.ListBox, waxyobject.WaxyObject):
+
+    __events__ = {
+        'Click': wx.EVT_LISTBOX,
+        'DoubleClick': wx.EVT_LISTBOX_DCLICK,
+    }
+
+    def __init__(self, parent, choices=[], size=None, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.ListBox.__init__(self, parent, wx.NewId(), size=size or (-1,-1),
+         choices=choices, style=style)
+
+        self.BindEvents()
+
+        styles.properties(self, kwargs)
+
+    def SetSelectionType(self, selection):
+        style = 0
+        selection = selection.lower()
+        if selection == "single":
+            style |= wx.LB_SINGLE
+        elif selection == "multiple":
+            style |= wx.LB_MULTIPLE
+        elif selection == "extended":
+            style |= wx.LB_EXTENDED
+        else:
+            raise ValueError, "selection must be single, multiple or extended"
+        return style
+
+    def SetItems(self, items):
+        """ Clear the internal list of items, and set new items.  <items> is
+            a list of 2-tuples (string, data). """
+        self.Clear()
+        for s, data in items:
+            self.Append(s, data)
+
+    def Fill(self, items):
+        """ Like SetItems, but just uses a list of strings. """
+        self.Clear()
+        for s in items:
+            self.Append(s)
+
+    def GetItems(self):
+        """ Return a list of 2-tuples (string, data). """
+        items = []
+        for i in range(self.GetCount()):
+            s = self.GetString(i)
+            data = self.GetClientData(i)
+            items.append((s, data))
+        return items
+
+    # TODO:
+    # Add __getitem__, __setitem__, __delitem__
+    # These should probably work with tuples (string, data).
+    # 1-tuples can be used, in which case data are left alone.
+    # Non-tuples are not allowed.
+
+    # We should also be able to iterate over a ListBox...
+    # Although for (s, data) in listbox.GetItems() would work too.
+
+    #
+    # style parameters
+
+    _listbox_selection = {
+        'single': wx.LB_SINGLE,
+        'multiple': wx.LB_MULTIPLE,
+        'extended': wx.LB_EXTENDED,
+    }
+
+    _listbox_scrollbar = {
+        'always': wx.LB_ALWAYS_SB,
+        'needed': wx.LB_NEEDED_SB,
+    }
+
+    def _params(self, kwargs):
+        flags = 0
+        flags |= styles.styledictstart('selection', self._listbox_selection, kwargs)
+        flags |= styles.styledictstart('scrollbar', self._listbox_scrollbar, kwargs)
+        flags |= styles.stylebool('sort', wx.LB_SORT, kwargs)
+        flags |= styles.stylebool('horizontal_scrollbar', wx.LB_HSCROLL, kwargs)
+
+        return flags
diff --git a/pynxc/waxy/menu.py b/pynxc/waxy/menu.py
new file mode 100644
index 0000000..ef587fc
--- /dev/null
+++ b/pynxc/waxy/menu.py
@@ -0,0 +1,135 @@
+# menu.py
+
+import wx
+import waxyobject
+import string
+
+class Menu(wx.Menu, waxyobject.WaxyObject):
+
+    def __init__(self, parent, autoevents=1):
+        wx.Menu.__init__(self)
+        self.parent = parent    # necessary for hooking up events
+        self.autoevents = autoevents
+
+    def Append(self, title, event=None, tooltip="", type="", hotkey="",special=''):
+        # Note: the order is different from wx.Menu.Append!
+        style = 0
+        style |= {
+            "r": wx.ITEM_RADIO,
+            "c": wx.ITEM_CHECK,
+        }.get(type.lower()[:1], wx.ITEM_NORMAL)
+
+        if hotkey:
+            title = title + "\t" + hotkey
+
+        if special.lower()=='about':
+            id=wx.ID_ABOUT
+        elif special.lower()=='exit':
+            id=wx.ID_EXIT
+        else:
+            id = wx.NewId()
+            
+        item = wx.Menu.Append(self, id, title, tooltip, style)
+        if event:
+            # you *can* choose to specify no event, but that doesn't seem very
+            # useful
+            wx.EVT_MENU(self.parent, id, event)
+        elif self.autoevents:
+            wx.EVT_MENU(self.parent, id, self.HandleAutoEvent)
+
+        return item
+
+    def AppendMenu(self, title, menu):
+        id = wx.NewId()
+        return wx.Menu.AppendMenu(self, id, title, menu)
+        # I suppose there's room for an event here, but why bother...?
+
+    def GetItem(self, title):
+        """ Find item by title, bypassing the internal id. """
+        id = self.FindItem(title)
+        item = self.FindItemById(id)
+        return item
+
+    def Delete(self, obj):
+        # according to the wxWindows reference, wx.Menu.Delete() also accepts
+        # MenuItems... but apparently that isn't true, at least not in wxPython.
+        # So let's fix it:
+        if isinstance(obj, wx.MenuItem):
+            id = obj.GetId()
+            return wx.Menu.Delete(self, id)
+        else:
+            # assume it's a number
+            return wx.Menu.Delete(self, obj)
+
+    def HandleAutoEvent(self, event):
+        id = event.GetId()
+        menuitem = self.FindItemById(id)
+
+        def GetFullTitle(id):
+            menubar = self.parent.GetMenuBar()
+            if menubar:
+                for mwitem in menubar.Walk():
+                    if mwitem.items and mwitem.items[-1].GetId() == id:
+                        title = mwitem.name
+                        for menuitem in mwitem.items:
+                            title = title + " " + menuitem.GetLabel()
+                        return title
+            return None
+
+        title = GetFullTitle(id)
+        if title:
+            methodname = "Menu_" + genmethodname(title)
+            #print "Looking for:", methodname
+            if hasattr(self.parent, methodname):
+                f = getattr(self.parent, methodname)
+                f(event)
+
+    # these aliases make sense...
+    Add = Append
+    AddMenu = AppendMenu
+
+    def Walk(self):
+        for menuitem in self.GetMenuItems():
+            yield [menuitem]
+            submenu = menuitem.GetSubMenu()
+            if submenu:
+                for subitem in submenu.Walk():
+                    yield [menuitem] + subitem
+
+    # TODO: Is it possible to write a better GetTitle() or GetRealTitle()
+    # or something, that gives us the actual label of the menu?
+
+class MenuBar(wx.MenuBar, waxyobject.WaxyObject):
+    def __init__(self, parent=None, *args, **kwargs):
+        wx.MenuBar.__init__(self, *args, **kwargs)
+        if parent: parent.SetMenuBar(self)
+
+    def Append(self, menu, text):
+        wx.MenuBar.Append(self, menu, text)
+
+    def Walk(self):
+        for i in range(self.GetMenuCount()):
+            menu = self.GetMenu(i)
+            for items in menu.Walk():
+                menuwalkitem = _MenuWalkItem()
+                menuwalkitem.name = self.GetLabelTop(i)
+                menuwalkitem.menu = menu
+                menuwalkitem.items = items
+                yield menuwalkitem
+
+class _MenuWalkItem:
+    pass
+
+#
+# auxiliary methods
+
+def genmethodname(title):
+    allowed = string.letters + string.digits + "_"
+    name = ""
+    for char in title:
+        if char in allowed:
+            name = name + char
+        elif char == ' ':
+            name = name + '_'
+    return name
+
diff --git a/pynxc/waxy/menu.py~ b/pynxc/waxy/menu.py~
new file mode 100644
index 0000000..2cab266
--- /dev/null
+++ b/pynxc/waxy/menu.py~
@@ -0,0 +1,129 @@
+# menu.py
+
+import wx
+import waxyobject
+import string
+
+class Menu(wx.Menu, waxyobject.WaxyObject):
+
+    def __init__(self, parent, autoevents=1):
+        wx.Menu.__init__(self)
+        self.parent = parent    # necessary for hooking up events
+        self.autoevents = autoevents
+
+    def Append(self, title, event=None, tooltip="", type="", hotkey=""):
+        # Note: the order is different from wx.Menu.Append!
+        style = 0
+        style |= {
+            "r": wx.ITEM_RADIO,
+            "c": wx.ITEM_CHECK,
+        }.get(type.lower()[:1], wx.ITEM_NORMAL)
+
+        if hotkey:
+            title = title + "\t" + hotkey
+
+        id = wx.NewId()
+        item = wx.Menu.Append(self, id, title, tooltip, style)
+        if event:
+            # you *can* choose to specify no event, but that doesn't seem very
+            # useful
+            wx.EVT_MENU(self.parent, id, event)
+        elif self.autoevents:
+            wx.EVT_MENU(self.parent, id, self.HandleAutoEvent)
+
+        return item
+
+    def AppendMenu(self, title, menu):
+        id = wx.NewId()
+        return wx.Menu.AppendMenu(self, id, title, menu)
+        # I suppose there's room for an event here, but why bother...?
+
+    def GetItem(self, title):
+        """ Find item by title, bypassing the internal id. """
+        id = self.FindItem(title)
+        item = self.FindItemById(id)
+        return item
+
+    def Delete(self, obj):
+        # according to the wxWindows reference, wx.Menu.Delete() also accepts
+        # MenuItems... but apparently that isn't true, at least not in wxPython.
+        # So let's fix it:
+        if isinstance(obj, wx.MenuItem):
+            id = obj.GetId()
+            return wx.Menu.Delete(self, id)
+        else:
+            # assume it's a number
+            return wx.Menu.Delete(self, obj)
+
+    def HandleAutoEvent(self, event):
+        id = event.GetId()
+        menuitem = self.FindItemById(id)
+
+        def GetFullTitle(id):
+            menubar = self.parent.GetMenuBar()
+            if menubar:
+                for mwitem in menubar.Walk():
+                    if mwitem.items and mwitem.items[-1].GetId() == id:
+                        title = mwitem.name
+                        for menuitem in mwitem.items:
+                            title = title + " " + menuitem.GetLabel()
+                        return title
+            return None
+
+        title = GetFullTitle(id)
+        if title:
+            methodname = "Menu_" + genmethodname(title)
+            #print "Looking for:", methodname
+            if hasattr(self.parent, methodname):
+                f = getattr(self.parent, methodname)
+                f(event)
+
+    # these aliases make sense...
+    Add = Append
+    AddMenu = AppendMenu
+
+    def Walk(self):
+        for menuitem in self.GetMenuItems():
+            yield [menuitem]
+            submenu = menuitem.GetSubMenu()
+            if submenu:
+                for subitem in submenu.Walk():
+                    yield [menuitem] + subitem
+
+    # TODO: Is it possible to write a better GetTitle() or GetRealTitle()
+    # or something, that gives us the actual label of the menu?
+
+class MenuBar(wx.MenuBar, waxobject.WaxObject):
+    def __init__(self, parent=None, *args, **kwargs):
+        wx.MenuBar.__init__(self, *args, **kwargs)
+        if parent: parent.SetMenuBar(self)
+
+    def Append(self, menu, text):
+        wx.MenuBar.Append(self, menu, text)
+
+    def Walk(self):
+        for i in range(self.GetMenuCount()):
+            menu = self.GetMenu(i)
+            for items in menu.Walk():
+                menuwalkitem = _MenuWalkItem()
+                menuwalkitem.name = self.GetLabelTop(i)
+                menuwalkitem.menu = menu
+                menuwalkitem.items = items
+                yield menuwalkitem
+
+class _MenuWalkItem:
+    pass
+
+#
+# auxiliary methods
+
+def genmethodname(title):
+    allowed = string.letters + string.digits + "_"
+    name = ""
+    for char in title:
+        if char in allowed:
+            name = name + char
+        elif char == ' ':
+            name = name + '_'
+    return name
+
diff --git a/pynxc/waxy/messagedialog.py b/pynxc/waxy/messagedialog.py
new file mode 100644
index 0000000..534878b
--- /dev/null
+++ b/pynxc/waxy/messagedialog.py
@@ -0,0 +1,70 @@
+# messagedialog.py
+
+import wx
+import waxyobject
+import core
+
+class MessageDialog(wx.MessageDialog, waxyobject.WaxyObject):
+    """Displays a message dialog.  Title, text, buttons (OK/Cancel/Yes/No),
+       and icon are configurable.
+    """
+
+    _icons = {
+        'asterisk': wx.ICON_ASTERISK,
+        'error': wx.ICON_ERROR,
+        'exclamation': wx.ICON_EXCLAMATION,
+        'hand': wx.ICON_HAND,
+        'information': wx.ICON_INFORMATION,
+        'mask': wx.ICON_MASK,
+        'question': wx.ICON_QUESTION,
+        'stop': wx.ICON_STOP,
+        'warning': wx.ICON_WARNING,
+    }
+
+    def __init__(self, parent, title="Message", text="A message", ok=0,
+                 cancel=0, yes_no=0, icon=""):
+        style = 0
+        if ok: style |= wx.OK
+        if cancel: style |= wx.CANCEL
+        if yes_no: style |= wx.YES_NO
+
+        # set icon... some of these values show the same icon, at least on
+        # Windows.
+        icon = self._icons.get(icon.lower(), None)
+        if icon:
+            style |= icon
+
+        # use a sensible default
+        if not (ok or cancel or yes_no):
+            style |= wx.OK
+
+        wx.MessageDialog.__init__(self, parent, text, title, style)
+
+    def ShowModal(self):
+        r = wx.MessageDialog.ShowModal(self)
+        return {
+            wx.ID_OK: 'ok',
+            wx.ID_CANCEL: 'cancel',
+            wx.ID_YES: 'yes',
+            wx.ID_NO: 'no',
+        }.get(r, "?")
+
+
+def ShowMessage(title, text, icon=""):
+    """ Displays a message with an OK button.  A bit like Delphi's ShowMessage
+        procedure. """
+    parent = core.GetActiveWindow()
+    dlg = MessageDialog(parent, title, text, ok=1, icon=icon)
+    try:
+        dlg.ShowModal()
+    finally:
+        dlg.Destroy()
+
+
+def Error(msg,parent=None):
+
+    dlg = MessageDialog(parent, "Error",
+            msg,icon='error')
+    dlg.ShowModal()
+    dlg.Destroy()
+
diff --git a/pynxc/waxy/messagedialog.py~ b/pynxc/waxy/messagedialog.py~
new file mode 100644
index 0000000..896d33b
--- /dev/null
+++ b/pynxc/waxy/messagedialog.py~
@@ -0,0 +1,63 @@
+# messagedialog.py
+
+import wx
+import waxyobject
+import core
+
+class MessageDialog(wx.MessageDialog, waxyobject.WaxyObject):
+    """Displays a message dialog.  Title, text, buttons (OK/Cancel/Yes/No),
+       and icon are configurable.
+    """
+
+    _icons = {
+        'asterisk': wx.ICON_ASTERISK,
+        'error': wx.ICON_ERROR,
+        'exclamation': wx.ICON_EXCLAMATION,
+        'hand': wx.ICON_HAND,
+        'information': wx.ICON_INFORMATION,
+        'mask': wx.ICON_MASK,
+        'question': wx.ICON_QUESTION,
+        'stop': wx.ICON_STOP,
+        'warning': wx.ICON_WARNING,
+    }
+
+    def __init__(self, parent, title="Message", text="A message", ok=0,
+                 cancel=0, yes_no=0, icon=""):
+        style = 0
+        if ok: style |= wx.OK
+        if cancel: style |= wx.CANCEL
+        if yes_no: style |= wx.YES_NO
+
+        # set icon... some of these values show the same icon, at least on
+        # Windows.
+        icon = self._icons.get(icon.lower(), None)
+        if icon:
+            style |= icon
+
+        # use a sensible default
+        if not (ok or cancel or yes_no):
+            style |= wx.OK
+
+        wx.MessageDialog.__init__(self, parent, text, title, style)
+        self.SetDefaultFont()
+
+    def ShowModal(self):
+        r = wx.MessageDialog.ShowModal(self)
+        return {
+            wx.ID_OK: 'ok',
+            wx.ID_CANCEL: 'cancel',
+            wx.ID_YES: 'yes',
+            wx.ID_NO: 'no',
+        }.get(r, "?")
+
+
+def ShowMessage(title, text, icon=""):
+    """ Displays a message with an OK button.  A bit like Delphi's ShowMessage
+        procedure. """
+    parent = core.GetActiveWindow()
+    dlg = MessageDialog(parent, title, text, ok=1, icon=icon)
+    try:
+        dlg.ShowModal()
+    finally:
+        dlg.Destroy()
+
diff --git a/pynxc/waxy/mousepointer.py b/pynxc/waxy/mousepointer.py
new file mode 100644
index 0000000..7809cc3
--- /dev/null
+++ b/pynxc/waxy/mousepointer.py
@@ -0,0 +1,95 @@
+# mousepointer.py
+
+# TODO:
+# - remove code duplication in LoadImage/LoadStream
+
+import wx
+import colordb
+import os
+import sys
+import utils
+
+POINTERS = {
+    "arrow" : wx.CURSOR_ARROW,
+    "arrowright" : wx.CURSOR_RIGHT_ARROW,
+    "bullseye" : wx.CURSOR_BULLSEYE,
+    "char" : wx.CURSOR_CHAR,
+    "cross" : wx.CURSOR_CROSS,
+    "hand" : wx.CURSOR_HAND,
+    "ibeam" : wx.CURSOR_IBEAM,
+    "buttonleft" : wx.CURSOR_LEFT_BUTTON,
+    "magnifier" : wx.CURSOR_MAGNIFIER,
+    "buttonmiddle" : wx.CURSOR_MIDDLE_BUTTON,
+    "noentry" : wx.CURSOR_NO_ENTRY,
+    "paintbrush" : wx.CURSOR_PAINT_BRUSH,
+    "pencil" : wx.CURSOR_PENCIL,
+    "pointleft" : wx.CURSOR_POINT_LEFT,
+    "pointright" : wx.CURSOR_POINT_RIGHT,
+    "arrowquestion" : wx.CURSOR_QUESTION_ARROW,
+    "buttonright" : wx.CURSOR_RIGHT_BUTTON,
+    "sizenesw" : wx.CURSOR_SIZENESW,
+    "sizens" : wx.CURSOR_SIZENS,
+    "sizenwse" : wx.CURSOR_SIZENWSE,
+    "sizewe" : wx.CURSOR_SIZEWE,
+    "sizing" : wx.CURSOR_SIZING,
+    "spraycan" : wx.CURSOR_SPRAYCAN,
+    "wait" : wx.CURSOR_WAIT,
+    "watch" : wx.CURSOR_WATCH,
+    "blank" : wx.CURSOR_BLANK,
+    "default" : wx.CURSOR_DEFAULT,
+    "arrowcopy" : wx.CURSOR_COPY_ARROW,
+    "arrowwait" : wx.CURSOR_ARROWWAIT,
+    }
+
+class MousePointerRegistry:
+    def __init__(self):
+        self.custom = {}
+    def Get(self, name):
+        if POINTERS.has_key(name):
+            return wx.StockCursor(POINTERS[name]) # return a cursor
+        elif self.custom.has_key(name):
+            return self.custom[name] # return an image-as-cursor
+        else:
+            raise KeyError, "Unknown pointer name: %s" % (name,)
+    def Set(self, name, value):
+        self.custom[name] = value
+    Register = Set
+    def GetBuiltinNames(self):
+        return POINTERS.keys()
+    def GetCustomNames(self):
+        return self.custom.keys()
+    def GetNames(self):
+        return self.GetBuiltinNames() + self.GetCustomNames()
+
+    def _RegisterImage(self, name, image, maskcolor='white', hotx=None, hoty=None):
+        """ Register a wx.Image as a cursor. """
+        if sys.platform =='win32':
+            #cursors fixed size 32,32
+            xratio = image.GetWidth() / 32
+            yratio = image.GetHeight() / 32
+        else:
+            xratio = yratio = 1
+        if not image.HasMask():
+            c = colordb.convert_color(maskcolor)
+            image.SetMaskColour(c[0], c[1], c[2])
+        if not hotx:
+            hotx = image.GetWidth() / 2
+        hotx = hotx / xratio
+        image.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_X, hotx)
+        if not hoty:
+            hoty = image.GetHeight() / 2
+        hoty = hoty / yratio
+        image.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_Y, hoty)
+        self.custom[name] = wx.CursorFromImage(image)
+
+    def RegisterImage(self, name, filename, maskcolor='white', hotx=None, hoty=None):
+        i = wx.Image(utils.opj(filename), wx.BITMAP_TYPE_ANY)
+        self._RegisterImage(name, i, maskcolor, hotx, hoty)
+
+    def RegisterStream(self, name, stream, maskcolor='white', hotx=None, hoty=None):
+        i = wx.ImageFromStream(stream)
+        self._RegisterImage(name, i, maskcolor, hotx, hoty)
+
+
+# global registry
+MousePointers = MousePointerRegistry()
diff --git a/pynxc/waxy/multichoicedialog.py b/pynxc/waxy/multichoicedialog.py
new file mode 100644
index 0000000..e0ec608
--- /dev/null
+++ b/pynxc/waxy/multichoicedialog.py
@@ -0,0 +1,29 @@
+import wx
+import waxyobject
+from font import Font
+
+# would be nice with a select all or something
+
+class MultiChoiceDialog(wx.MultiChoiceDialog, waxyobject.WaxyObject):
+
+    def __init__(self, parent,lst,text='Choose',title='Multi Choice Dialog'):
+        wx.MultiChoiceDialog.__init__(self, parent,text,title,lst)
+
+        self.lst=lst
+        
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.MultiChoiceDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
+
+    def GetChosenItems(self):
+        selections = self.GetSelections()
+        strings = [self.lst[x] for x in selections]
+        
+        return strings
+
+    
+        
diff --git a/pynxc/waxy/multichoicedialog.py~ b/pynxc/waxy/multichoicedialog.py~
new file mode 100644
index 0000000..564e0fc
--- /dev/null
+++ b/pynxc/waxy/multichoicedialog.py~
@@ -0,0 +1,27 @@
+import wx
+import waxyobject
+from font import Font
+
+class MultiChoiceDialog(wx.MultiChoiceDialog, waxyobject.WaxyObject):
+
+    def __init__(self, parent,lst,text='Choose',title='Multi Choice Dialog'):
+        wx.MultiChoiceDialog.__init__(self, parent,text,title,lst)
+
+        self.lst=lst
+        
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.MultiChoiceDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
+
+    def GetChosenItems(self):
+        selections = self.GetSelections()
+        strings = [self.lst[x] for x in selections]
+        
+        return strings
+
+    
+        
diff --git a/pynxc/waxy/notebook.py b/pynxc/waxy/notebook.py
new file mode 100644
index 0000000..5ef5515
--- /dev/null
+++ b/pynxc/waxy/notebook.py
@@ -0,0 +1,51 @@
+# notebook.py
+
+import waxyobject
+import wx
+import styles
+import utils
+
+class NoteBook(wx.Notebook, waxyobject.WaxyObject):
+
+    __events__ = {
+        'PageChanging': wx.EVT_NOTEBOOK_PAGE_CHANGING,
+        'PageChanged': wx.EVT_NOTEBOOK_PAGE_CHANGED,
+    }
+
+    def __init__(self, parent, size=(640,480), **kwargs):
+
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        self.id = wx.NewId()
+        wx.Notebook.__init__(self, parent, self.id, style=style, size=size)
+        self.BindEvents()
+        styles.properties(self, kwargs)
+
+#    def AddPage(self, window, *args, **kwargs):
+#        wx.Notebook.AddPage(self, window, *args, **kwargs)
+
+    def GetCurrentPage(self):
+        idx = self.GetSelection()
+        if idx == -1:
+            raise ValueError, "NoteBook currently has no pages"
+        else:
+            return self.GetPage(idx)
+
+    #
+    # style parameters
+
+    _notebook_orientation = {
+        "left": wx.NB_LEFT,
+        "right": wx.NB_RIGHT,
+        "bottom": wx.NB_BOTTOM,
+        "top": 0,
+    }
+
+    def _params(self, kwargs):
+        flags = 0
+        flags |= styles.styledictstart('orientation', self._notebook_orientation, kwargs)
+        flags |= styles.stylebool('fixedwidth', wx.NB_FIXEDWIDTH, kwargs)
+        flags |= styles.stylebool('multiline', wx.NB_MULTILINE, kwargs)
+        return flags
diff --git a/pynxc/waxy/notebook.py~ b/pynxc/waxy/notebook.py~
new file mode 100644
index 0000000..66024a0
--- /dev/null
+++ b/pynxc/waxy/notebook.py~
@@ -0,0 +1,51 @@
+# notebook.py
+
+import waxyobject
+import wx
+import styles
+import utils
+
+class NoteBook(wx.Notebook, waxyobject.WaxyObject):
+
+    __events__ = {
+        'PageChanging': wx.EVT_NOTEBOOK_PAGE_CHANGING,
+        'PageChanged': wx.EVT_NOTEBOOK_PAGE_CHANGED,
+    }
+
+    def __init__(self, parent, size=(640,480), **kwargs):
+
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        self.id = wx.NewId()
+        wx.Notebook.__init__(self, parent, self.id, style=style, size=size)
+        self.BindEvents()
+        styles.properties(self, kwargs)
+
+    def AddPage(self, window, *args, **kwargs):
+        wx.Notebook.AddPage(self, window, *args, **kwargs)
+
+    def GetCurrentPage(self):
+        idx = self.GetSelection()
+        if idx == -1:
+            raise ValueError, "NoteBook currently has no pages"
+        else:
+            return self.GetPage(idx)
+
+    #
+    # style parameters
+
+    _notebook_orientation = {
+        "left": wx.NB_LEFT,
+        "right": wx.NB_RIGHT,
+        "bottom": wx.NB_BOTTOM,
+        "top": 0,
+    }
+
+    def _params(self, kwargs):
+        flags = 0
+        flags |= styles.styledictstart('orientation', self._notebook_orientation, kwargs)
+        flags |= styles.stylebool('fixedwidth', wx.NB_FIXEDWIDTH, kwargs)
+        flags |= styles.stylebool('multiline', wx.NB_MULTILINE, kwargs)
+        return flags
diff --git a/pynxc/waxy/notes.txt b/pynxc/waxy/notes.txt
new file mode 100644
index 0000000..bc6a7be
--- /dev/null
+++ b/pynxc/waxy/notes.txt
@@ -0,0 +1,21 @@
+removing references to fonts
+removed the autoinstall on the Image type (memory leak?)
+added aboutbox
+added colourdialog, and colordialog
+added multichoicedialog
+added singlechoicedialog
+
+code to look at:
+canvas.py
+
+
+demos to do:
+
+artprovider
+bitmap
+bitmapbutton
+checkbox
+checklistbox
+combobox
+customdialog
+listbox
diff --git a/pynxc/waxy/notes.txt~ b/pynxc/waxy/notes.txt~
new file mode 100644
index 0000000..df69f54
--- /dev/null
+++ b/pynxc/waxy/notes.txt~
@@ -0,0 +1,20 @@
+removing references to fonts
+removed the autoinstall on the Image type (memory leak?)
+added aboutbox
+added colourdialog, and colordialog
+added multichoicedialog
+added singlechoicedialog
+
+code to look at:
+canvas.py
+
+
+demos to do:
+
+artprovider
+bitmap
+bitmapbutton
+checkbox
+checklistbox
+combobox
+customdialog
diff --git a/pynxc/waxy/panel.py b/pynxc/waxy/panel.py
new file mode 100644
index 0000000..a4222cb
--- /dev/null
+++ b/pynxc/waxy/panel.py
@@ -0,0 +1,27 @@
+# panel.py
+
+import wx
+import containers
+import styles
+
+class Panel(wx.Panel, containers.Container):
+    """ Sub-level containers inside a frame, used for layout. """
+    def __init__(self, parent, direction="H", size=None, **kwargs):
+        style = 0
+        style |= styles.window(kwargs)
+        wx.Panel.__init__(self, parent, wx.NewId(), size=size or (-1,-1),
+         style=style)
+
+        self.BindEvents()
+        self._create_sizer(direction)
+        styles.properties(self, kwargs)
+        self.Body()
+
+class HorizontalPanel(Panel):
+    def __init__(self, parent, **kwargs):
+        Panel.__init__(self, parent, direction='h', **kwargs)
+
+class VerticalPanel(Panel):
+    def __init__(self, parent, **kwargs):
+        Panel.__init__(self, parent, direction='v', **kwargs)
+
diff --git a/pynxc/waxy/panel.py~ b/pynxc/waxy/panel.py~
new file mode 100644
index 0000000..c6992fa
--- /dev/null
+++ b/pynxc/waxy/panel.py~
@@ -0,0 +1,28 @@
+# panel.py
+
+import wx
+import containers
+import styles
+
+class Panel(wx.Panel, containers.Container):
+    """ Sub-level containers inside a frame, used for layout. """
+    def __init__(self, parent, direction="H", size=None, **kwargs):
+        style = 0
+        style |= styles.window(kwargs)
+        wx.Panel.__init__(self, parent, wx.NewId(), size=size or (-1,-1),
+         style=style)
+
+        self.BindEvents()
+        self._create_sizer(direction)
+        self.SetDefaultFont()
+        styles.properties(self, kwargs)
+        self.Body()
+
+class HorizontalPanel(Panel):
+    def __init__(self, parent, **kwargs):
+        Panel.__init__(self, parent, direction='h', **kwargs)
+
+class VerticalPanel(Panel):
+    def __init__(self, parent, **kwargs):
+        Panel.__init__(self, parent, direction='v', **kwargs)
+
diff --git a/pynxc/waxy/progressdialog.py b/pynxc/waxy/progressdialog.py
new file mode 100644
index 0000000..e43f96e
--- /dev/null
+++ b/pynxc/waxy/progressdialog.py
@@ -0,0 +1,28 @@
+# progressdialog.py
+
+import wx
+import waxyobject
+
+class ProgressDialog(wx.ProgressDialog, waxyobject.WaxyObject):
+
+    def __init__(self,parent=None,title="Progress", message="Progress", 
+                  maximum=100,abort=1,modal=1,show_elapsed_time=1,show_remaining_time=1):
+        style = 0
+        if abort:
+            style |= wx.PD_CAN_ABORT
+        if modal:
+            style |= wx.PD_APP_MODAL
+        if show_elapsed_time:
+            style |= wx.PD_ELAPSED_TIME
+        if show_remaining_time:
+            style |= wx.PD_REMAINING_TIME
+        wx.ProgressDialog.__init__(self, title, message,
+                        maximum, parent,style)
+
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.ProgressDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
diff --git a/pynxc/waxy/progressdialog.py~ b/pynxc/waxy/progressdialog.py~
new file mode 100644
index 0000000..17f44a5
--- /dev/null
+++ b/pynxc/waxy/progressdialog.py~
@@ -0,0 +1,28 @@
+# progressdialog.py
+
+import wx
+import waxyobject
+
+class ProgressDialog(wx.ProgressDialog, waxyobject.WaxyObject):
+
+    def __init__(self,parent=None,title="Progress", message="Progress", 
+                  maximum=100,abort=1,modal=1,show_elapsed_time=1,show_remaining_time=1):
+        style = 0
+        if abort:
+            style |= wx.PD_CAN_ABORT
+        if modal:
+            style |= wx.PD_APP_MODAL
+        if elapsed:
+            style |= wx.PD_ELAPSED_TIME
+        if remaining:
+            style |= wx.PD_REMAINING_TIME
+        wx.ProgressDialog.__init__(self, title, message,
+                        maximum, parent,style)
+
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.ProgressDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
diff --git a/pynxc/waxy/singlechoicedialog.py b/pynxc/waxy/singlechoicedialog.py
new file mode 100644
index 0000000..e6dffdc
--- /dev/null
+++ b/pynxc/waxy/singlechoicedialog.py
@@ -0,0 +1,29 @@
+import wx
+import waxyobject
+from font import Font
+
+# would be nice with a select all or something
+
+class SingleChoiceDialog(wx.SingleChoiceDialog, waxyobject.WaxyObject):
+
+    def __init__(self, parent,lst,text='Choose',title='Single Choice Dialog'):
+        wx.SingleChoiceDialog.__init__(self, parent,text,title,lst)
+
+        self.lst=lst
+        
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.SingleChoiceDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
+
+    def GetChosenItem(self):
+        s = self.GetStringSelection()
+        
+        
+        return s
+
+    
+        
diff --git a/pynxc/waxy/singlechoicedialog.py~ b/pynxc/waxy/singlechoicedialog.py~
new file mode 100644
index 0000000..2941dbc
--- /dev/null
+++ b/pynxc/waxy/singlechoicedialog.py~
@@ -0,0 +1,29 @@
+import wx
+import waxyobject
+from font import Font
+
+# would be nice with a select all or something
+
+class SingleChoiceDialog(wx.SingleChoiceDialog, waxyobject.WaxyObject):
+
+    def __init__(self, parent,lst,text='Choose',title='Single Choice Dialog'):
+        wx.SingleChoiceDialog.__init__(self, parent,text,title,lst)
+
+        self.lst=lst
+        
+    def ShowModal(self):
+        """ Simplified ShowModal(), returning strings 'ok' or 'cancel'. """
+        result = wx.SingleChoiceDialog.ShowModal(self)
+        if result == wx.ID_OK:
+            return 'ok'
+        else:
+            return 'cancel'
+
+    def GetChosenItems(self):
+        selections = self.GetSelections()
+        strings = [self.lst[x] for x in selections]
+        
+        return strings
+
+    
+        
diff --git a/pynxc/waxy/slider.py b/pynxc/waxy/slider.py
new file mode 100644
index 0000000..1f70e64
--- /dev/null
+++ b/pynxc/waxy/slider.py
@@ -0,0 +1,104 @@
+# slider.py
+
+import wx
+import containers
+import waxyobject
+import styles
+from panel import Panel
+from label import Label
+
+class Slider(wx.Slider, waxyobject.WaxyObject):
+    __events__ = {
+        'Scroll': wx.EVT_SCROLL,
+    }
+
+    def __init__(self, parent, tickfreq=5, min=0, max=100, event=None, size=None, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+        
+        wx.Slider.__init__(self, parent, wx.NewId(), size=size or (-1,-1), style=style)
+        self.SetTickFreq(tickfreq)
+        self.SetRange(min, max)
+        
+        self.BindEvents()
+        if event:
+            self.OnScroll = event
+        styles.properties(self, kwargs)
+
+    #
+    # style parameters
+    
+    __styles__ = {
+        'labels': (wx.SL_LABELS, styles.NORMAL),
+        'ticks': ({
+            "left": wx.SL_LEFT | wx.SL_AUTOTICKS,
+            "right": wx.SL_RIGHT | wx.SL_AUTOTICKS,
+            "top": wx.SL_TOP | wx.SL_AUTOTICKS,
+            "bottom": wx.SL_BOTTOM | wx.SL_AUTOTICKS,
+        }, styles.DICTSTART),
+        'orientation': ({
+            "horizontal": wx.SL_HORIZONTAL,
+            "vertical": wx.SL_VERTICAL,
+        }, styles.DICTSTART),
+    }
+
+
+class FloatSlider(Panel):
+
+    def __init__(self, parent, tickfreq=0.5, min=-5.0, max=5.0, format='%.1f',event=None, size=None, **kwargs):
+
+        if 'labels' in kwargs:
+            labels=kwargs['labels']
+            kwargs['labels']=False
+
+        Panel.__init__(self,parent,direction='v')
+
+
+        intmin=0
+        intmax=int(float(max-min)/tickfreq)
+        inttickfreq=1
+
+        self.min=min
+        self.max=max
+        self.tickfreq=tickfreq
+        self.format=format
+
+        self.slider=Slider(self, inttickfreq,intmin,intmax,event,size,**kwargs)
+        self.slider.SetValue(self.slider.GetMax()/2)
+        self.slider.OnScroll=self.OnScroll
+        self.AddComponent(self.slider,stretch=True,border=10)
+
+        if labels:
+            p=Panel(self,direction='h')
+            self.text1=Label(p,self.format % self.min,align='left')
+            self.text2=Label(p,self.format % self.max,align='right')
+            self.text3=Label(p,self.format % self.GetValue(),align='center')
+            p.AddComponent(self.text1,expand=True,border=3)
+            p.AddComponent(self.text3,expand=False,border=3)
+            p.AddComponent(self.text2,expand=True,border=3)
+            p.Pack()
+
+            self.AddComponent(p,stretch=True)
+
+
+
+        self.Pack()
+
+    def OnScroll(self,event):
+        self.text3.SetLabel(self.format % self.GetValue())
+        self.text3.SetExtraStyle(wx.ALIGN_CENTER)
+        self.OnUpdate()
+        
+    def OnUpdate(self):
+        pass
+        
+    def GetValue(self):
+
+        intval=float(self.slider.GetValue())
+        intmax=float(self.slider.GetMax())
+
+        val=(intval*self.tickfreq)+self.min
+
+        return val
+
diff --git a/pynxc/waxy/splitter.py b/pynxc/waxy/splitter.py
new file mode 100644
index 0000000..4afcb4b
--- /dev/null
+++ b/pynxc/waxy/splitter.py
@@ -0,0 +1,56 @@
+# splitter.py
+
+import wx
+import waxyobject
+import styles
+import utils
+
+class Splitter(wx.SplitterWindow, waxyobject.WaxyObject):
+
+    __events__ = {
+        'SashPosChanging': wx.EVT_SPLITTER_SASH_POS_CHANGING,
+        'SashPosChanged': wx.EVT_SPLITTER_SASH_POS_CHANGED,
+        'Unsplit': wx.EVT_SPLITTER_UNSPLIT,
+        'DoubleClick': wx.EVT_SPLITTER_DCLICK,
+    }
+
+    def __init__(self, parent, size=None, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+        wx.SplitterWindow.__init__(self, parent, wx.NewId(), style=style)
+
+        if size:
+            self.SetSize(size)
+
+        self.BindEvents()
+        styles.properties(self, kwargs)
+
+        # I would have liked to add the windows to the constructor, but it's
+        # not possible because the Splitter needs to be present as the
+        # windows' parent... hmm...
+
+    def Split(self, window1, window2, direction="horizontal", sashposition=100,
+              minsize=20):
+
+        if direction.lower().startswith("h"):
+            self.SplitHorizontally(window1, window2, sashposition)
+        elif direction.lower().startswith("v"):
+            self.SplitVertically(window1, window2, sashposition)
+        else:
+            raise ValueError, "direction must be horizontal or vertical"
+
+        self.SetMinimumPaneSize(minsize)
+
+    #
+    # style parameters
+
+    def _params(self, kwargs):
+        flags = 0
+        flags |= styles.stylebool('permit_unsplit', wx.SP_PERMIT_UNSPLIT, kwargs)
+        flags |= styles.stylebool('live_update', wx.SP_LIVE_UPDATE, kwargs)
+        flags |= styles.stylebool('no_xp_theme', wx.SP_NO_XP_THEME, kwargs)
+        flags |= styles.stylebool('border', wx.SP_BORDER, kwargs)
+        flags |= styles.stylebool('sash3d', wx.SP_3DSASH, kwargs)
+        flags |= styles.stylebool('all3d', wx.SP_3D, kwargs)
+        return flags
diff --git a/pynxc/waxy/splitter.py~ b/pynxc/waxy/splitter.py~
new file mode 100644
index 0000000..e1fac80
--- /dev/null
+++ b/pynxc/waxy/splitter.py~
@@ -0,0 +1,62 @@
+# splitter.py
+
+import wx
+import waxyobject
+import styles
+import utils
+
+class Splitter(wx.SplitterWindow, waxyobject.WaxyObject):
+
+    __events__ = {
+        'SashPosChanging': wx.EVT_SPLITTER_SASH_POS_CHANGING,
+        'SashPosChanged': wx.EVT_SPLITTER_SASH_POS_CHANGED,
+        'Unsplit': wx.EVT_SPLITTER_UNSPLIT,
+        'DoubleClick': wx.EVT_SPLITTER_DCLICK,
+    }
+
+    def __init__(self, parent, size=None, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+        wx.SplitterWindow.__init__(self, parent, wx.NewId(), style=style)
+
+        if size:
+            self.SetSize(size)
+
+        self.BindEvents()
+        styles.properties(self, kwargs)
+
+        # I would have liked to add the windows to the constructor, but it's
+        # not possible because the Splitter needs to be present as the
+        # windows' parent... hmm...
+
+    def Split(self, window1, window2, direction="horizontal", sashposition=100,
+              minsize=20):
+        # check parents
+        if waxconfig.WaxConfig.check_parent:
+            if window1.GetParent() is not self:
+                utils.parent_warning(window1, self)
+            if window2.GetParent() is not self:
+                utils.parent_warning(window2, self)
+
+        if direction.lower().startswith("h"):
+            self.SplitHorizontally(window1, window2, sashposition)
+        elif direction.lower().startswith("v"):
+            self.SplitVertically(window1, window2, sashposition)
+        else:
+            raise ValueError, "direction must be horizontal or vertical"
+
+        self.SetMinimumPaneSize(minsize)
+
+    #
+    # style parameters
+
+    def _params(self, kwargs):
+        flags = 0
+        flags |= styles.stylebool('permit_unsplit', wx.SP_PERMIT_UNSPLIT, kwargs)
+        flags |= styles.stylebool('live_update', wx.SP_LIVE_UPDATE, kwargs)
+        flags |= styles.stylebool('no_xp_theme', wx.SP_NO_XP_THEME, kwargs)
+        flags |= styles.stylebool('border', wx.SP_BORDER, kwargs)
+        flags |= styles.stylebool('sash3d', wx.SP_3DSASH, kwargs)
+        flags |= styles.stylebool('all3d', wx.SP_3D, kwargs)
+        return flags
diff --git a/pynxc/waxy/statusbar.py b/pynxc/waxy/statusbar.py
new file mode 100644
index 0000000..ba9643c
--- /dev/null
+++ b/pynxc/waxy/statusbar.py
@@ -0,0 +1,37 @@
+# statusbar.py
+
+import wx
+import waxyobject
+import styles
+
+class StatusBar(wx.StatusBar, waxyobject.WaxyObject):
+
+    def __init__(self, parent, numpanels=1, add=1, **kwargs):
+        # note: does not support the 'size' parameter
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.StatusBar.__init__(self, parent, wx.NewId(), style=style)
+
+#        self.SetDefaultFont()
+        self.SetFieldsCount(numpanels)
+        if add:
+            parent.SetStatusBar(self)
+
+        self.BindEvents()
+        styles.properties(self, kwargs)
+
+
+    # allows for: statusbar[0] = "text"
+    def __setitem__(self, index, text):
+        self.SetStatusText(text, index)
+
+    #
+    # style parameters
+
+    def _params(self, kwargs):
+        flags = 0
+        flags |= styles.stylebool('sizegrip', wx.ST_SIZEGRIP, kwargs)
+        return flags
+
diff --git a/pynxc/waxy/styles.py b/pynxc/waxy/styles.py
new file mode 100644
index 0000000..d89b0f2
--- /dev/null
+++ b/pynxc/waxy/styles.py
@@ -0,0 +1,160 @@
+# styles.py
+
+import wx
+
+
+NORMAL    = 0
+EXCLUDE   = 1
+DICT      = 2
+DICTSTART = 3
+REVERSE   = 32
+
+
+def styledict(name, dict, kwargs, default=0):
+    flags = 0
+    if kwargs.has_key(name):
+        value = kwargs[name]
+        try:
+            value = value.lower()
+        except AttributeError:
+            pass
+        flags |= dict.get(value, default)
+        del kwargs[name]
+    return flags
+
+def styledictstart(name, dict, kwargs, default=0):
+    """ Like styledict, but matches the first letter(s) rather than the
+        complete value.  For example, if "lower" is the only key in the dict
+        starting with "l", then by passing the value "l" we match "lower".
+        Used e.g. in _button_align.
+    """
+    flags = 0
+    if kwargs.has_key(name):
+        value = kwargs[name].lower()
+        # note that we traverse the dict pair by pair, so ambiguous matches
+        # *are* possible
+        for key, flag in dict.items():
+            if key.startswith(value):
+                flags |= flag
+                break
+        else:
+            flags |= default
+        del kwargs[name]
+    return flags
+
+def stylebool(name, flag, kwargs, reverse=0):
+    """ If <name> is in kwargs and is true, then return <flag>.
+        If <reverse> is set, then the condition needs to be false in order
+        for the flag to be returned.
+        (E.g. stylebool('lines', wx.BLAH_NOLINES, kwargs, reverse=1)
+        will return wx.BLAH_NOLINES if lines==0, not if lines==1.)
+    """
+    flags = 0
+    if kwargs.has_key(name):
+        value = kwargs[name]
+        if reverse:
+            value = not value
+        if value:
+            flags |= flag
+        del kwargs[name]
+    return flags
+
+def styleboolexclude(name, flag, kwargs, reverse=0):
+    flags = 0
+    if kwargs.has_key(name):
+        value = kwargs[name]
+        if reverse:
+            value = not value
+        if value:
+            flags |= flag
+        del kwargs[name]
+    return flags
+
+def stylebooleither(name, flagtrue, flagfalse, kwargs):
+    flags = 0
+    if kwargs.has_key(name):
+        value = kwargs[name]
+        if value:
+            flags |= flagtrue
+        else:
+            flags |= flagfalse
+        del kwargs[name]
+    return flags
+
+# not sure if this can be used...
+def stylefunc(name, func, kwargs):
+    if kwargs.has_key(name):
+        value = kwargs[name]
+        func(value)
+        del kwargs[value]
+    return 0
+
+#
+#
+#
+def dostyle(styledict, kwargs):
+    """ Set styles for a given control, using a "style dict".  Return the 
+        eventual flag value.  Mostly for internal use. """
+    flags = 0
+    for k, (style, type) in styledict.items():
+        #style, type = styledict[k]
+        # First check for reversing
+        reverse = 0
+        if (type & REVERSE) == REVERSE:
+            reverse = 1
+        # Get everything but the `reverse` bits
+        type = type & (reverse - 1)
+        # Now see what we're dealing with
+        if type == NORMAL:
+            flags |= stylebool(k, style, kwargs, reverse=reverse)
+        elif type == DICT:
+            flags |= styledict(k, style, kwargs)
+        elif type == DICTSTART:
+            flags |= styledictstart(k, style, kwargs)
+        elif type == EXCLUDE:
+            flags &= ~styleboolexclude(k, style, kwargs, reverse=reverse)
+
+    return flags
+#
+# the following functions do not handle flags
+
+def properties(obj, kwargs):
+    """ Called by constructors to set properties from a dict.  Must be called
+        *after* the parent's constructor (unlike most of the other styles
+        functions). """
+    if kwargs.has_key('properties'):
+        d = kwargs['properties']
+        for key, value in d.items():
+            setattr(obj, key, value)  # attempt to set property
+        del kwargs['properties']
+
+    # attempt to set the remaining attributes as properties (this will raise
+    # an error if an invalid property name is specified).
+    obj.SetProperties(**kwargs)
+
+    # XXX could be a method in WaxyObject... if it doesn't already exist?
+
+
+#
+# window styles
+
+_window_border = {
+    "simple": wx.SIMPLE_BORDER,
+    "double": wx.DOUBLE_BORDER,
+    "sunken": wx.SUNKEN_BORDER,
+    "raised": wx.RAISED_BORDER,
+    "static": wx.STATIC_BORDER,
+    "no": wx.NO_BORDER,
+    "none": wx.NO_BORDER,
+}
+
+def window(kwargs):
+    """ Styles applicable to any wx.Window descendant. """
+    flags = 0
+    flags |= styledict('border', _window_border, kwargs)
+    flags |= stylebool('transparent', wx.TRANSPARENT_WINDOW, kwargs)
+    flags |= stylebool('tab_traversal', wx.TAB_TRAVERSAL, kwargs)
+    flags |= stylebool('wants_chars', wx.WANTS_CHARS, kwargs)
+
+    return flags
+
diff --git a/pynxc/waxy/styles.py~ b/pynxc/waxy/styles.py~
new file mode 100644
index 0000000..ed39f77
--- /dev/null
+++ b/pynxc/waxy/styles.py~
@@ -0,0 +1,160 @@
+# styles.py
+
+import wx
+
+
+NORMAL    = 0
+EXCLUDE   = 1
+DICT      = 2
+DICTSTART = 3
+REVERSE   = 32
+
+
+def styledict(name, dict, kwargs, default=0):
+    flags = 0
+    if kwargs.has_key(name):
+        value = kwargs[name]
+        try:
+            value = value.lower()
+        except AttributeError:
+            pass
+        flags |= dict.get(value, default)
+        del kwargs[name]
+    return flags
+
+def styledictstart(name, dict, kwargs, default=0):
+    """ Like styledict, but matches the first letter(s) rather than the
+        complete value.  For example, if "lower" is the only key in the dict
+        starting with "l", then by passing the value "l" we match "lower".
+        Used e.g. in _button_align.
+    """
+    flags = 0
+    if kwargs.has_key(name):
+        value = kwargs[name].lower()
+        # note that we traverse the dict pair by pair, so ambiguous matches
+        # *are* possible
+        for key, flag in dict.items():
+            if key.startswith(value):
+                flags |= flag
+                break
+        else:
+            flags |= default
+        del kwargs[name]
+    return flags
+
+def stylebool(name, flag, kwargs, reverse=0):
+    """ If <name> is in kwargs and is true, then return <flag>.
+        If <reverse> is set, then the condition needs to be false in order
+        for the flag to be returned.
+        (E.g. stylebool('lines', wx.BLAH_NOLINES, kwargs, reverse=1)
+        will return wx.BLAH_NOLINES if lines==0, not if lines==1.)
+    """
+    flags = 0
+    if kwargs.has_key(name):
+        value = kwargs[name]
+        if reverse:
+            value = not value
+        if value:
+            flags |= flag
+        del kwargs[name]
+    return flags
+
+def styleboolexclude(name, flag, kwargs, reverse=0):
+    flags = 0
+    if kwargs.has_key(name):
+        value = kwargs[name]
+        if reverse:
+            value = not value
+        if value:
+            flags |= flag
+        del kwargs[name]
+    return flags
+
+def stylebooleither(name, flagtrue, flagfalse, kwargs):
+    flags = 0
+    if kwargs.has_key(name):
+        value = kwargs[name]
+        if value:
+            flags |= flagtrue
+        else:
+            flags |= flagfalse
+        del kwargs[name]
+    return flags
+
+# not sure if this can be used...
+def stylefunc(name, func, kwargs):
+    if kwargs.has_key(name):
+        value = kwargs[name]
+        func(value)
+        del kwargs[value]
+    return 0
+
+#
+#
+#
+def dostyle(styledict, kwargs):
+    """ Set styles for a given control, using a "style dict".  Return the 
+        eventual flag value.  Mostly for internal use. """
+    flags = 0
+    for k, (style, type) in styledict.items():
+        #style, type = styledict[k]
+        # First check for reversing
+        reverse = 0
+        if (type & REVERSE) == REVERSE:
+            reverse = 1
+        # Get everything but the `reverse` bits
+        type = type & (reverse - 1)
+        # Now see what we're dealing with
+        if type == NORMAL:
+            flags |= stylebool(k, style, kwargs, reverse=reverse)
+        elif type == DICT:
+            flags |= styledict(k, style, kwargs)
+        elif type == DICTSTART:
+            flags |= styledictstart(k, style, kwargs)
+        elif type == EXCLUDE:
+            flags &= ~styleboolexclude(k, style, kwargs, reverse=reverse)
+
+    return flags
+#
+# the following functions do not handle flags
+
+def properties(obj, kwargs):
+    """ Called by constructors to set properties from a dict.  Must be called
+        *after* the parent's constructor (unlike most of the other styles
+        functions). """
+    if kwargs.has_key('properties'):
+        d = kwargs['properties']
+        for key, value in d.items():
+            setattr(obj, key, value)  # attempt to set property
+        del kwargs['properties']
+
+    # attempt to set the remaining attributes as properties (this will raise
+    # an error if an invalid property name is specified).
+    obj.SetProperties(**kwargs)
+
+    # XXX could be a method in WaxObject... if it doesn't already exist?
+
+
+#
+# window styles
+
+_window_border = {
+    "simple": wx.SIMPLE_BORDER,
+    "double": wx.DOUBLE_BORDER,
+    "sunken": wx.SUNKEN_BORDER,
+    "raised": wx.RAISED_BORDER,
+    "static": wx.STATIC_BORDER,
+    "no": wx.NO_BORDER,
+    "none": wx.NO_BORDER,
+}
+
+def window(kwargs):
+    """ Styles applicable to any wx.Window descendant. """
+    flags = 0
+    flags |= styledict('border', _window_border, kwargs)
+    flags |= stylebool('transparent', wx.TRANSPARENT_WINDOW, kwargs)
+    flags |= stylebool('tab_traversal', wx.TAB_TRAVERSAL, kwargs)
+    flags |= stylebool('wants_chars', wx.WANTS_CHARS, kwargs)
+
+    return flags
+
diff --git a/pynxc/waxy/textbox.py b/pynxc/waxy/textbox.py
new file mode 100644
index 0000000..7595b5a
--- /dev/null
+++ b/pynxc/waxy/textbox.py
@@ -0,0 +1,128 @@
+# textbox.py

+

+import waxyobject

+import wx

+import core

+import styles

+

+class TextBox(wx.TextCtrl, waxyobject.WaxyObject):

+

+    __events__ = {

+        'Char': wx.EVT_CHAR,    # do all controls have this?

+        'MaxLength': wx.EVT_TEXT_MAXLEN,  # alias for TextMaxLen

+        'Text': wx.EVT_TEXT,

+        'TextEnter': wx.EVT_TEXT_ENTER,

+        'TextMaxLen': wx.EVT_TEXT_MAXLEN,

+        'TextURL': wx.EVT_TEXT_URL,

+    }

+

+    def __init__(self, parent, text="", size=None, **kwargs):

+        style = 0

+        style |= self._params(kwargs)

+        style |= styles.window(kwargs)

+

+        wx.TextCtrl.__init__(self, parent, wx.NewId(), text,

+         size=size or (125,-1), style=style)

+

+        self.BindEvents()

+        styles.properties(self, kwargs)

+

+    def write(self, s):

+        # Added so we can use a TextBox as a file-like object and redirect

+        # stdout to it.

+        self.AppendText(s)

+        try:

+            core.Yield()

+        except:

+            pass

+

+    def GetCurrentLineNumber(self):

+        """ Return the current line number (i.e. the number of the line the

+            cursor is on). """

+        pos = self.GetInsertionPoint()

+        x, y = self.PositionToXY(pos)

+        return y

+

+    def GetLines(self):

+        """ Return the current text as a list of lines.  (Changing the list

+            does not affect the contents of the TextBox.) """

+        text = self.GetValue()

+        lines = text.split("\n")

+        return lines

+

+    def SetModified(self, modified):

+        if modified:

+            # set to modified by appending a dummy space and removing it again

+            self.AppendText(' ')

+            lastpos = self.GetLastPosition()

+            self.Remove(lastpos-1, lastpos)

+        else:

+            self.DiscardEdits()

+

+    def GetModified(self):

+        """ Returns true if the contents of the control were modified.  (Alias

+            for IsModified(). """

+        return self.IsModified()

+

+    def InsertText(self, pos, text):

+        """ Insert text at the given position. """

+        old_insertion_point = self.GetInsertionPoint()

+        self.SetInsertionPoint(pos)

+        self.WriteText(text)

+        # put cursor at original insertion point

+        if old_insertion_point <= pos:

+            self.SetInsertionPoint(old_insertion_point)

+        else:

+            self.SetInsertionPoint(old_insertion_point + len(text))

+

+    # ideas:

+    # should Remove support negative indexes? (like slices)

+    # should it support slicing?  e.g. del atextbox[10:20]

+

+    #

+    # style parameters

+

+    #_textbox_justify = {

+    #    "left": wx.TE_LEFT,

+    #    "center": wx.TE_CENTRE,

+    #    "centre": wx.TE_CENTRE,

+    #    "middle": wx.TE_CENTRE,

+    #    "right": wx.TE_RIGHT,

+    #}

+

+    __styles__ = {

+        'justify': ({

+            'left': wx.TE_LEFT,

+            'center': wx.TE_CENTRE,

+            'centre': wx.TE_CENTRE,

+            'middle': wx.TE_CENTRE,

+            'right': wx.TE_RIGHT,

+        }, styles.DICTSTART),

+        'multiline': (wx.TE_MULTILINE, styles.NORMAL),

+        'password': (wx.TE_PASSWORD, styles.NORMAL),

+        'readonly': (wx.TE_READONLY, styles.NORMAL),

+        'wrap': (wx.TE_DONTWRAP, styles.NORMAL | styles.REVERSE),

+        'process_enter': (wx.TE_PROCESS_ENTER, styles.NORMAL),

+        'process_tab': (wx.TE_PROCESS_TAB, styles.NORMAL),

+        'rich': (wx.TE_RICH, styles.NORMAL),

+        'rich2': (wx.TE_RICH2, styles.NORMAL),

+        'auto_url': (wx.TE_AUTO_URL, styles.NORMAL),

+        'hscroll': (wx.HSCROLL, styles.NORMAL),

+    }

+        

+    def _params(self, kwargs):

+        flags = 0 | wx.TE_NOHIDESEL # maybe add the option of changing this one

+        #flags |= styles.stylebool('multiline', wx.TE_MULTILINE, kwargs)

+        #flags |= styles.stylebool('password', wx.TE_PASSWORD, kwargs)

+        #flags |= styles.stylebool('readonly', wx.TE_READONLY, kwargs)

+        #flags |= styles.stylebool('wrap', wx.TE_DONTWRAP, kwargs, reverse=1)

+        #flags |= styles.stylebool('process_enter', wx.TE_PROCESS_ENTER, kwargs)

+        #flags |= styles.stylebool('process_tab', wx.TE_PROCESS_TAB, kwargs)

+        #flags |= styles.stylebool('rich', wx.TE_RICH, kwargs)

+        #flags |= styles.stylebool('rich2', wx.TE_RICH2, kwargs)

+        #flags |= styles.stylebool('auto_url', wx.TE_AUTO_URL, kwargs)

+        #flags |= styles.stylebool('hscroll', wx.HSCROLL, kwargs)

+        #flags |= styles.styledictstart('justify', self._textbox_justify, kwargs, 0)

+        flags |= styles.dostyle(self.__styles__, kwargs)

+        return flags

+

diff --git a/pynxc/waxy/textbox.py~ b/pynxc/waxy/textbox.py~
new file mode 100644
index 0000000..88d42b4
--- /dev/null
+++ b/pynxc/waxy/textbox.py~
@@ -0,0 +1,128 @@
+# textbox.py

+

+import waxyobject

+import wx

+import core

+import styles

+

+class TextBox(wx.TextCtrl, waxyobject.WaxObject):

+

+    __events__ = {

+        'Char': wx.EVT_CHAR,    # do all controls have this?

+        'MaxLength': wx.EVT_TEXT_MAXLEN,  # alias for TextMaxLen

+        'Text': wx.EVT_TEXT,

+        'TextEnter': wx.EVT_TEXT_ENTER,

+        'TextMaxLen': wx.EVT_TEXT_MAXLEN,

+        'TextURL': wx.EVT_TEXT_URL,

+    }

+

+    def __init__(self, parent, text="", size=None, **kwargs):

+        style = 0

+        style |= self._params(kwargs)

+        style |= styles.window(kwargs)

+

+        wx.TextCtrl.__init__(self, parent, wx.NewId(), text,

+         size=size or (125,-1), style=style)

+

+        self.BindEvents()

+        styles.properties(self, kwargs)

+

+    def write(self, s):

+        # Added so we can use a TextBox as a file-like object and redirect

+        # stdout to it.

+        self.AppendText(s)

+        try:

+            core.Yield()

+        except:

+            pass

+

+    def GetCurrentLineNumber(self):

+        """ Return the current line number (i.e. the number of the line the

+            cursor is on). """

+        pos = self.GetInsertionPoint()

+        x, y = self.PositionToXY(pos)

+        return y

+

+    def GetLines(self):

+        """ Return the current text as a list of lines.  (Changing the list

+            does not affect the contents of the TextBox.) """

+        text = self.GetValue()

+        lines = text.split("\n")

+        return lines

+

+    def SetModified(self, modified):

+        if modified:

+            # set to modified by appending a dummy space and removing it again

+            self.AppendText(' ')

+            lastpos = self.GetLastPosition()

+            self.Remove(lastpos-1, lastpos)

+        else:

+            self.DiscardEdits()

+

+    def GetModified(self):

+        """ Returns true if the contents of the control were modified.  (Alias

+            for IsModified(). """

+        return self.IsModified()

+

+    def InsertText(self, pos, text):

+        """ Insert text at the given position. """

+        old_insertion_point = self.GetInsertionPoint()

+        self.SetInsertionPoint(pos)

+        self.WriteText(text)

+        # put cursor at original insertion point

+        if old_insertion_point <= pos:

+            self.SetInsertionPoint(old_insertion_point)

+        else:

+            self.SetInsertionPoint(old_insertion_point + len(text))

+

+    # ideas:

+    # should Remove support negative indexes? (like slices)

+    # should it support slicing?  e.g. del atextbox[10:20]

+

+    #

+    # style parameters

+

+    #_textbox_justify = {

+    #    "left": wx.TE_LEFT,

+    #    "center": wx.TE_CENTRE,

+    #    "centre": wx.TE_CENTRE,

+    #    "middle": wx.TE_CENTRE,

+    #    "right": wx.TE_RIGHT,

+    #}

+

+    __styles__ = {

+        'justify': ({

+            'left': wx.TE_LEFT,

+            'center': wx.TE_CENTRE,

+            'centre': wx.TE_CENTRE,

+            'middle': wx.TE_CENTRE,

+            'right': wx.TE_RIGHT,

+        }, styles.DICTSTART),

+        'multiline': (wx.TE_MULTILINE, styles.NORMAL),

+        'password': (wx.TE_PASSWORD, styles.NORMAL),

+        'readonly': (wx.TE_READONLY, styles.NORMAL),

+        'wrap': (wx.TE_DONTWRAP, styles.NORMAL | styles.REVERSE),

+        'process_enter': (wx.TE_PROCESS_ENTER, styles.NORMAL),

+        'process_tab': (wx.TE_PROCESS_TAB, styles.NORMAL),

+        'rich': (wx.TE_RICH, styles.NORMAL),

+        'rich2': (wx.TE_RICH2, styles.NORMAL),

+        'auto_url': (wx.TE_AUTO_URL, styles.NORMAL),

+        'hscroll': (wx.HSCROLL, styles.NORMAL),

+    }

+        

+    def _params(self, kwargs):

+        flags = 0 | wx.TE_NOHIDESEL # maybe add the option of changing this one

+        #flags |= styles.stylebool('multiline', wx.TE_MULTILINE, kwargs)

+        #flags |= styles.stylebool('password', wx.TE_PASSWORD, kwargs)

+        #flags |= styles.stylebool('readonly', wx.TE_READONLY, kwargs)

+        #flags |= styles.stylebool('wrap', wx.TE_DONTWRAP, kwargs, reverse=1)

+        #flags |= styles.stylebool('process_enter', wx.TE_PROCESS_ENTER, kwargs)

+        #flags |= styles.stylebool('process_tab', wx.TE_PROCESS_TAB, kwargs)

+        #flags |= styles.stylebool('rich', wx.TE_RICH, kwargs)

+        #flags |= styles.stylebool('rich2', wx.TE_RICH2, kwargs)

+        #flags |= styles.stylebool('auto_url', wx.TE_AUTO_URL, kwargs)

+        #flags |= styles.stylebool('hscroll', wx.HSCROLL, kwargs)

+        #flags |= styles.styledictstart('justify', self._textbox_justify, kwargs, 0)

+        flags |= styles.dostyle(self.__styles__, kwargs)

+        return flags

+

diff --git a/pynxc/waxy/textentrydialog.py b/pynxc/waxy/textentrydialog.py
new file mode 100644
index 0000000..afe31ca
--- /dev/null
+++ b/pynxc/waxy/textentrydialog.py
@@ -0,0 +1,179 @@
+# textentrydialog.py
+# Simple dialog for entering a string.
+# Note: Not based on wxPython's TextEntryDialog.
+
+from dialog import Dialog
+from textbox import TextBox
+from label import Label
+from keys import keys
+import string
+
+class TextEntryDialog(Dialog):
+
+    def __init__(self, parent, title="Enter some text", prompt="Enter some text",
+     default="", cancel_button=1):
+        self.prompt = prompt
+        self.default = default
+        Dialog.__init__(self, parent, title, cancel_button=cancel_button)
+
+    def Body(self):
+        label = Label(self, self.prompt)
+        self.AddComponent(label, expand='h', border=7)
+
+        self.text = TextBox(self, size=(100,25), process_enter=1)
+        self.text.SetValue(self.default)
+        self.text.OnChar = self.OnTextBoxChar
+        self.AddComponent(self.text, expand='h', border=5)
+
+    def OnTextBoxChar(self, event=None):
+        # pressing Enter in the TextBox is the same as clicking OK
+        if event.GetKeyCode() == keys.enter:
+            self.OnClickOKButton(event)
+        else:
+            event.Skip()
+
+    def GetValue(self):
+        return self.text.GetValue()
+
+
+
+
+class IntegerInputDialog(TextEntryDialog):
+
+    def __init__(self, parent, title='Enter some text', 
+                 prompt='Enter some text', default='', cancel_button=1):
+
+        TextEntryDialog.__init__(self, parent, title=title,
+                 prompt=prompt, default=str(default), 
+                 cancel_button=cancel_button)
+
+
+    def GetValue(self):
+
+        try:
+            val=TextEntryDialog.GetValue(self)
+        except ValueError:
+            return None
+
+        try:
+            int_val=eval("int("+val+")")
+        except (SyntaxError,NameError):
+            int_val=None
+
+        return int_val
+
+
+    def OnCharHook(self, event):
+        key = event.KeyCode()
+
+        if key == wx.WXK_ESCAPE:
+            self.OnClickCancelButton()
+
+        if key < wx.WXK_SPACE or key == wx.WXK_DELETE or key > 255:
+            event.Skip()
+            return
+
+
+        good_chars=string.digits+'+*-()'
+        if chr(key) in good_chars:
+            event.Skip()
+            return
+
+        if not wx.Validator_IsSilent():
+            wx.Bell()
+
+        # Returning without calling even.Skip eats the event before it
+        # gets to the text control
+        return
+
+
+
+    def Validate(self):
+        val = TextEntryDialog.GetValue(self)  # make sure the get a string
+
+        good_chars=string.digits+'+*-()'
+        for x in val:
+            if x not in good_chars:
+                return False
+
+        try:
+            int_val=eval("int("+val+")")
+        except (SyntaxError,NameError):
+            Error("Syntax Error")
+            return False
+
+        return True
+
+
+def Input_Integer(title,
+                 prompt, default=None,parent=None):
+
+
+    a=IntegerInputDialog(parent,title,prompt,default)
+    result=a.ShowModal()
+
+    if result=='ok':
+        r=a.GetValue()
+    else:
+        r=None
+
+    a.Destroy()
+
+    return r
+
+
+class FloatInputDialog(TextEntryDialog):
+
+    def __init__(self, parent, title='Enter some text', 
+                 prompt='Enter some text', default=None, cancel_button=1):
+
+        TextEntryDialog.__init__(self, parent, title=title,
+                 prompt=prompt, default=str(default), 
+                 cancel_button=cancel_button)
+
+
+    def GetValue(self):
+
+        try:
+            val=TextEntryDialog.GetValue(self)
+        except ValueError:
+            return None
+
+        try:
+            float_val=eval("float("+val+")")
+        except SyntaxError:
+            float_val=None
+
+        return float_val
+
+
+
+    def Validate(self):
+        val = TextEntryDialog.GetValue(self)  # make sure the get a string
+
+        try:
+            float_val=eval("float("+val+")")
+        except (SyntaxError,NameError):
+            Error("Syntax Error")
+            return False
+
+        return True
+
+
+
+def Input_Float(title,
+                 prompt, default=None,parent=None):
+
+    a=FloatInputDialog(parent,title,prompt,default)
+    result=a.ShowModal()
+
+    if result=='ok':
+        r=a.GetValue()
+    else:
+        r=None
+
+    a.Destroy()
+
+    return r
+
+
diff --git a/pynxc/waxy/treelistview.py b/pynxc/waxy/treelistview.py
new file mode 100644
index 0000000..e4d3d40
--- /dev/null
+++ b/pynxc/waxy/treelistview.py
@@ -0,0 +1,28 @@
+# treelistview.py
+
+import styles
+import wx
+import wx.gizmos as gizmos
+import waxyobject
+import treeview
+
+class TreeListView(gizmos.TreeListCtrl, waxyobject.WaxyObject):
+
+    def __init__(self, parent, columns=(), size=None, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+        gizmos.TreeListCtrl.__init__(self, parent, wx.NewId(),
+         size=size or (-1,-1), style=style)
+
+        for name in columns:
+            self.AddColumn(name)
+
+        self.BindEvents()
+        styles.properties(self, kwargs)
+
+    # some deviltry to copy styles stuff from TreeView...
+    _treeview_selection = treeview.TreeView._treeview_selection
+    _params = treeview.TreeView._params.im_func
+    # I'll come up with a better solution later.
+
diff --git a/pynxc/waxy/treeview.py b/pynxc/waxy/treeview.py
new file mode 100644
index 0000000..eea90ca
--- /dev/null
+++ b/pynxc/waxy/treeview.py
@@ -0,0 +1,119 @@
+# treeview.py
+
+# todo: can we access tree like a dict?
+
+from __future__ import generators
+import wx
+import waxyobject
+import styles
+import types
+import utils
+
+class TreeView(wx.TreeCtrl, waxyobject.WaxyObject):
+
+    __events__ = {
+        'ItemExpanded': wx.EVT_TREE_ITEM_EXPANDED,
+        'ItemExpanding': wx.EVT_TREE_ITEM_EXPANDING,
+        'ItemCollapsed': wx.EVT_TREE_ITEM_COLLAPSED,
+        'ItemCollapsing': wx.EVT_TREE_ITEM_COLLAPSING,
+        'SelectionChanged': wx.EVT_TREE_SEL_CHANGED,
+        'BeginEdit': wx.EVT_TREE_BEGIN_LABEL_EDIT,
+        'EndEdit': wx.EVT_TREE_END_LABEL_EDIT,
+        'ItemActivated': wx.EVT_TREE_ITEM_ACTIVATED,
+        'BeginDrag': wx.EVT_TREE_BEGIN_DRAG,
+        'BeginRightDrag': wx.EVT_TREE_BEGIN_RDRAG,
+        'DeleteItem': wx.EVT_TREE_DELETE_ITEM,
+    }
+
+    def __init__(self, parent, size=None, **kwargs):
+        style = 0
+        style |= self._params(kwargs)
+        style |= styles.window(kwargs)
+
+        wx.TreeCtrl.__init__(self, parent, wx.NewId(), size=size or (-1,-1),
+         style=style)
+
+        self.BindEvents()
+        styles.properties(self, kwargs)
+
+    def GetChildNodes(self, node):
+        """ Generator returning a node's children. <node> has to be a tree
+            node, e.g. the root, or any item. """
+        child, cookie = self.GetFirstChild(node)
+        while child.IsOk():
+            yield child
+            child, cookie = self.GetNextChild(node, cookie)
+
+    def HasChildren(self, node):
+        child, cookie = self.GetFirstChild(node)
+        return child.IsOk()
+
+    def Clear(self):
+        self.DeleteAllItems()
+        # Clear() is used for other controls, so it makes sense to use it here
+        # as well.
+
+    def LoadFromDict(self, node, adict):
+        # XXX extend this to work with objects
+        items = adict.items()
+        items.sort()
+        for key, value in items:
+            if isinstance(value, dict):
+                child = self.AppendItem(node, utils.asstring(key))
+                self.SetPyData(child, None) # hmm...
+                self.LoadFromDict(child, value)
+            else:
+                child = self.AppendItem(node, utils.asstring(key))
+                self.SetPyData(child, value)
+
+    def LoadFromNestedList(self, root, list):
+        """
+        loads a nested list of (key, value, [children]) tuples (or lists)
+        as children of the given root node. preserves the
+        order of elements as they appear in the list.
+        """
+        for item in list:
+            if (type(item) not in (types.TupleType, types.ListType)
+            or len(item) not in (0, 3)):
+                raise Exception, "LoadFromNestedList requires a list of (key, value, children) tuples"
+            (key, value, children) = item
+            node = self.AppendItem(root, utils.asstring(key))
+            self.SetPyData(node, value)
+            if type(children) == types.ListType:
+                self.LoadFromNestedList(node, children)
+
+    def SetImageList(self, imagelist):
+        wx.TreeCtrl.SetImageList(self, imagelist)
+        self._imagelist = imagelist
+        # a copy must be kept around, or the images will be freed
+
+    def SetItemImage(self, node, index, expanded=0):
+        return wx.TreeCtrl.SetItemImage(self, node, index, [wx.TreeItemIcon_Normal, wx.TreeItemIcon_Expanded][expanded])
+
+    #
+    # style parameters
+
+    _treeview_selection = {
+        'single': wx.TR_SINGLE,
+        'multiple': wx.TR_MULTIPLE,
+        'extended': wx.TR_EXTENDED,
+    }
+
+    def _params(self, kwargs):
+        flags = wx.TR_DEFAULT_STYLE
+        flags |= styles.stylebool('edit_labels', wx.TR_EDIT_LABELS, kwargs)
+        flags |= styles.stylebool('twist_buttons', wx.TR_TWIST_BUTTONS, kwargs)
+        flags |= styles.stylebool('lines', wx.TR_NO_LINES, kwargs, reverse=1)
+        flags |= styles.stylebool('hide_root', wx.TR_HIDE_ROOT, kwargs)
+        flags |= styles.styledictstart('selection', self._treeview_selection, kwargs)
+
+        # has_buttons requires special code:
+        if kwargs.has_key('has_buttons'):
+            if kwargs['has_buttons']:
+                flags |= wx.TR_HAS_BUTTONS
+            else:
+                flags &= ~wx.TR_HAS_BUTTONS # make sure flag is NOT set
+            del kwargs['has_buttons']
+        # Note that TR_NO_BUTTONS is useless... it's 0!
+
+        return flags
diff --git a/pynxc/waxy/utils.py b/pynxc/waxy/utils.py
new file mode 100644
index 0000000..467b325
--- /dev/null
+++ b/pynxc/waxy/utils.py
@@ -0,0 +1,29 @@
+# tools.py
+# Miscellaneous utility functions.
+
+import os
+import warnings
+
+def asstring(x):
+    """ Ensure that x is a string, i.e. if it's not of the str or unicode
+        types, convert it with str.  Otherwise, leave it unchanged. """
+    if not (isinstance(x, str) or isinstance(x, unicode)):
+        x = str(x)
+    return x
+
+def opj(path):
+    """Convert paths to the platform-specific separator"""
+    str = apply(os.path.join, tuple(path.split('/')))
+    # HACK: on Linux, a leading / gets lost...
+    if path.startswith('/'):
+        str = '/' + str
+    return str
+
+class CheckParentWarning(Warning):
+    pass
+
+def parent_warning(obj, container):
+    s = "obj %r has parent %r, but is added to container %r" % (
+        obj, obj.GetParent(), container)
+    warnings.warn(s, CheckParentWarning)
+
diff --git a/pynxc/waxy/waxyobject.py b/pynxc/waxy/waxyobject.py
new file mode 100644
index 0000000..952dd27
--- /dev/null
+++ b/pynxc/waxy/waxyobject.py
@@ -0,0 +1,246 @@
+# waxyobject.py
+
+import wx
+import core
+import colordb
+import events
+import mousepointer
+import styles
+
+class MetaWaxyObject(type):
+
+##    def inject_SetFont(cls):
+##        if hasattr(cls, "SetFont"):
+##            real_SetFont = getattr(cls, "SetFont")
+##            def SetFont(self, obj):
+##                if isinstance(obj, tuple):
+##                    import font
+##                    obj = font.Font(*obj)
+##                real_SetFont(self, obj)
+##            SetFont.__doc__ = real_SetFont.__doc__
+##            setattr(cls, "SetFont", SetFont)
+##            if core.DEBUG:
+##                print "%s: SetFont replaced" % (cls,)
+##
+##    def inject_GetFont(cls):
+##        if hasattr(cls, "GetFont"):
+##            real_GetFont = getattr(cls, "GetFont")
+##            import font
+##            def GetFont(self):
+##                wxfont = real_GetFont(self)
+##                wxfont.__class__ = font.Font
+##                return wxfont
+##            GetFont.__doc__ = real_GetFont.__doc__
+##            setattr(cls, "GetFont", GetFont)
+##            if core.DEBUG:
+##                print "%s: GetFont replaced" % (cls,)
+
+    def inject_SetCursor(cls):
+        if hasattr(cls, "SetCursor"):
+            real_SetCursor = getattr(cls, "SetCursor")
+            def SetCursor(self, x):
+                if isinstance(x, basestring):
+                    c = mousepointer.MousePointers.Get(x)
+                    real_SetCursor(self, c)
+                else:
+                    real_SetCursor(self, x)
+            SetCursor.__doc__ = real_SetCursor.__doc__
+            setattr(cls, "SetCursor", SetCursor)
+            if core.DEBUG:
+                print "%s: SetCursor replaced" % (cls,)
+
+    def inject_SetWindowStyle(cls):
+        if hasattr(cls, "SetWindowStyle"):
+            real_SetWindowStyle = getattr(cls, "SetWindowStyle")
+            def SetWindowStyle(self, __default__=0, **kwargs):
+                """ Wax-style SetWindowStyle that supports the old way of
+                    setting styles (using an integer flag value), and/or
+                    named keywords, depending on the class's _params method.
+                """
+                flags = __default__
+                flags |= self._params(kwargs)
+                if isinstance(self, wx.Window):
+                    flags |= styles.window(kwargs)
+                real_SetWindowStyle(self, flags)
+            setattr(cls, "SetWindowStyle", SetWindowStyle)
+            if core.DEBUG:
+                print "%s: SetWindowStyle replaced" % (cls,)
+
+    def inject_ColorMethods(cls):
+        if hasattr(cls, "SetBackgroundColour"):
+            real_SetBackgroundColour = getattr(cls, "SetBackgroundColour")
+            real_SetForegroundColour = getattr(cls, "SetForegroundColour")
+
+            def SetForegroundColour(self, color):
+                color = colordb.convert_color(color)
+                real_SetForegroundColour(self, color)
+            SetForegroundColour.__doc__ = real_SetForegroundColour.__doc__
+            setattr(cls, "SetForegroundColour", SetForegroundColour)
+
+            def SetBackgroundColour(self, color):
+                color = colordb.convert_color(color)
+                real_SetBackgroundColour(self, color)
+            SetBackgroundColour.__doc__ = real_SetBackgroundColour.__doc__
+            setattr(cls, "SetBackgroundColour", SetBackgroundColour)
+
+            # make aliases for "Color"
+            setattr(cls, "SetBackgroundColor", cls.SetBackgroundColour)
+            setattr(cls, "SetForegroundColor", cls.SetForegroundColour)
+            setattr(cls, "GetBackgroundColor", cls.GetBackgroundColour)
+            setattr(cls, "GetForegroundColor", cls.GetForegroundColour)
+
+            if core.DEBUG:
+                print "%s: SetForegroundColour/SetBackgroundColour replaced" % (cls,)
+
+    def __init__(cls, name, bases, dict):
+#        cls.inject_SetFont()
+#        cls.inject_GetFont()
+        cls.inject_SetCursor()
+        cls.inject_ColorMethods()
+        cls.inject_SetWindowStyle()
+
+
+class WaxyObject:
+    """ Mixin class for Wax controls.
+        Stick attributes and methods here that every Wax control should have.
+    """
+    __metaclass__ = MetaWaxyObject
+    # yes, I don't like metaclasses, but they're actually useful here :-)
+
+    __events__ = {}
+    __styles__ = {}
+
+##    def SetDefaultFont(self):
+##        if hasattr(self, 'SetFont'):
+##            self.SetFont(waxconfig.WaxConfig.default_font)
+
+    def SetSizeX(self, ix):
+        x, y = self.GetSize()
+        self.SetSize((ix, y))
+
+    def SetSizeY(self, iy):
+        x, y = self.GetSize()
+        self.SetSize((x, iy))
+        
+    def GetSizeX(self):
+        return self.GetSize()[0]
+        
+    def GetSizeY(self):
+        return self.GetSize()[1]
+
+    def BindEvents(self):
+        items = []
+        if hasattr(self, "__events__"):
+            items = getattr(self, "__events__").items()
+        items.extend(events.events.items())
+        for name, wxevent in items:
+            if hasattr(self, "On" + name):
+                f = getattr(self, "On" + name)
+                self.Bind(wxevent, f)
+                if core.DEBUG:
+                    print "Binding %s to %s" % (name, f)
+
+    def GetAllChildren(self):
+        """ Return a generator returning all children, grandchildren, etc,
+            of the given widget.  The widgets are traversed depth-first.
+        """
+        if hasattr(self, 'GetChildren'):
+            for child in self.GetChildren():
+                yield child
+                for grandchild in child.GetAllChildren():
+                    yield grandchild
+
+    #
+    # pseudo-properties
+
+    def __getattr__(self, name):
+        if hasattr(self.__class__, "Get" + name):
+            # use self.__class__ rather than self to avoid recursion
+            f = getattr(self, "Get" + name)
+            return f()
+        else:
+            raise AttributeError, name
+
+    def __setattr__(self, name, value):
+        if hasattr(self, "Set" + name):
+            f = getattr(self, "Set" + name)
+            return f(value)
+        elif name.startswith("On"):
+            shortname = name[2:]
+            if self.__events__.has_key(shortname):
+                wxevent = self.__events__[shortname]
+            elif events.events.has_key(shortname):
+                wxevent = events.events[shortname]
+            else:
+                wxevent = None
+            self.__dict__[name] = value
+            if wxevent:
+                self.Bind(wxevent, value)
+                if core.DEBUG:
+                    print "Binding %s to %s" % (name, value)
+        else:
+            self.__dict__[name] = value
+
+    def SetAttributes(self, **kwargs):
+        """ Set a number of attributes at once.  E.g.
+            widget.SetAttributes(Font=MYFONT, Size=(100,200))
+        """
+        for (key, value) in kwargs.items():
+            self.__setattr__(key, value)
+
+    def SetProperties(self, **kwargs):
+        """ As SetAttributes, but raises an error if an unknown property name
+            is specified. """
+        for (key, value) in kwargs.items():
+            f = getattr(self, "Set" + key, None)
+            if f:
+                f(value)
+            else:
+                raise AttributeError, "Unknown property: %s" % (key,)
+
+    def _params(self, kwargs, thesestyles={}):
+        # default method for those controls that don't have a _params()
+        if thesestyles:
+            return styles.dostyle(thesestyles, kwargs)
+        else:
+            return styles.dostyle(self.__styles__, kwargs)
+
+    def HasStyle(self, style, substyle=None):
+        """ Returns whether or not a style is set for this object. """
+        try:
+            sval = self.__styles__[style][0]
+            if isinstance(sval, dict):
+                # The style returned is a complex style so...
+                if substyle:
+                    # ...checking for a specific substyle, return if it's set
+                    subval = sval[substyle]
+                    ws = self.GetWindowStyle()
+                    # If we're dealing with a zero based style, things
+                    #  get a bit trickier
+                    if subval == 0:
+                        for k in sval:
+                            temp = sval[k]
+                            if k != substyle and (ws & temp) == temp:
+                                return False
+                    return (ws & subval) == subval
+                else:
+                    # ...not checking for specific, so see if either is set and
+                    #  return the key value associated with what is set
+                    mystyle = self.GetWindowStyle()
+                    for k in sval:
+                        v = sval[k]
+                        if (mystyle & v) == v:
+                            return k
+                    return False
+            else:
+                # Style is not complex, return if it is set or not
+                return (self.GetWindowStyle() & sval) == sval
+        except:
+            return False
+
+    def GetStyleDict(self):
+        """ Returns a dictionary with style info for this object. """
+        ret = {}
+        for k in self.__styles__:
+            ret[k] = self.HasStyle(k)
+        return ret
diff --git a/pynxc/waxy/waxyobject.py~ b/pynxc/waxy/waxyobject.py~
new file mode 100644
index 0000000..a11937e
--- /dev/null
+++ b/pynxc/waxy/waxyobject.py~
@@ -0,0 +1,246 @@
+# waxobject.py
+
+import wx
+import core
+import colordb
+import events
+import mousepointer
+import styles
+
+class MetaWaxyObject(type):
+
+##    def inject_SetFont(cls):
+##        if hasattr(cls, "SetFont"):
+##            real_SetFont = getattr(cls, "SetFont")
+##            def SetFont(self, obj):
+##                if isinstance(obj, tuple):
+##                    import font
+##                    obj = font.Font(*obj)
+##                real_SetFont(self, obj)
+##            SetFont.__doc__ = real_SetFont.__doc__
+##            setattr(cls, "SetFont", SetFont)
+##            if core.DEBUG:
+##                print "%s: SetFont replaced" % (cls,)
+##
+##    def inject_GetFont(cls):
+##        if hasattr(cls, "GetFont"):
+##            real_GetFont = getattr(cls, "GetFont")
+##            import font
+##            def GetFont(self):
+##                wxfont = real_GetFont(self)
+##                wxfont.__class__ = font.Font
+##                return wxfont
+##            GetFont.__doc__ = real_GetFont.__doc__
+##            setattr(cls, "GetFont", GetFont)
+##            if core.DEBUG:
+##                print "%s: GetFont replaced" % (cls,)
+
+    def inject_SetCursor(cls):
+        if hasattr(cls, "SetCursor"):
+            real_SetCursor = getattr(cls, "SetCursor")
+            def SetCursor(self, x):
+                if isinstance(x, basestring):
+                    c = mousepointer.MousePointers.Get(x)
+                    real_SetCursor(self, c)
+                else:
+                    real_SetCursor(self, x)
+            SetCursor.__doc__ = real_SetCursor.__doc__
+            setattr(cls, "SetCursor", SetCursor)
+            if core.DEBUG:
+                print "%s: SetCursor replaced" % (cls,)
+
+    def inject_SetWindowStyle(cls):
+        if hasattr(cls, "SetWindowStyle"):
+            real_SetWindowStyle = getattr(cls, "SetWindowStyle")
+            def SetWindowStyle(self, __default__=0, **kwargs):
+                """ Wax-style SetWindowStyle that supports the old way of
+                    setting styles (using an integer flag value), and/or
+                    named keywords, depending on the class's _params method.
+                """
+                flags = __default__
+                flags |= self._params(kwargs)
+                if isinstance(self, wx.Window):
+                    flags |= styles.window(kwargs)
+                real_SetWindowStyle(self, flags)
+            setattr(cls, "SetWindowStyle", SetWindowStyle)
+            if core.DEBUG:
+                print "%s: SetWindowStyle replaced" % (cls,)
+
+    def inject_ColorMethods(cls):
+        if hasattr(cls, "SetBackgroundColour"):
+            real_SetBackgroundColour = getattr(cls, "SetBackgroundColour")
+            real_SetForegroundColour = getattr(cls, "SetForegroundColour")
+
+            def SetForegroundColour(self, color):
+                color = colordb.convert_color(color)
+                real_SetForegroundColour(self, color)
+            SetForegroundColour.__doc__ = real_SetForegroundColour.__doc__
+            setattr(cls, "SetForegroundColour", SetForegroundColour)
+
+            def SetBackgroundColour(self, color):
+                color = colordb.convert_color(color)
+                real_SetBackgroundColour(self, color)
+            SetBackgroundColour.__doc__ = real_SetBackgroundColour.__doc__
+            setattr(cls, "SetBackgroundColour", SetBackgroundColour)
+
+            # make aliases for "Color"
+            setattr(cls, "SetBackgroundColor", cls.SetBackgroundColour)
+            setattr(cls, "SetForegroundColor", cls.SetForegroundColour)
+            setattr(cls, "GetBackgroundColor", cls.GetBackgroundColour)
+            setattr(cls, "GetForegroundColor", cls.GetForegroundColour)
+
+            if core.DEBUG:
+                print "%s: SetForegroundColour/SetBackgroundColour replaced" % (cls,)
+
+    def __init__(cls, name, bases, dict):
+#        cls.inject_SetFont()
+#        cls.inject_GetFont()
+        cls.inject_SetCursor()
+        cls.inject_ColorMethods()
+        cls.inject_SetWindowStyle()
+
+
+class WaxyObject:
+    """ Mixin class for Wax controls.
+        Stick attributes and methods here that every Wax control should have.
+    """
+    __metaclass__ = MetaWaxyObject
+    # yes, I don't like metaclasses, but they're actually useful here :-)
+
+    __events__ = {}
+    __styles__ = {}
+
+##    def SetDefaultFont(self):
+##        if hasattr(self, 'SetFont'):
+##            self.SetFont(waxconfig.WaxConfig.default_font)
+
+    def SetSizeX(self, ix):
+        x, y = self.GetSize()
+        self.SetSize((ix, y))
+
+    def SetSizeY(self, iy):
+        x, y = self.GetSize()
+        self.SetSize((x, iy))
+        
+    def GetSizeX(self):
+        return self.GetSize()[0]
+        
+    def GetSizeY(self):
+        return self.GetSize()[1]
+
+    def BindEvents(self):
+        items = []
+        if hasattr(self, "__events__"):
+            items = getattr(self, "__events__").items()
+        items.extend(events.events.items())
+        for name, wxevent in items:
+            if hasattr(self, "On" + name):
+                f = getattr(self, "On" + name)
+                self.Bind(wxevent, f)
+                if core.DEBUG:
+                    print "Binding %s to %s" % (name, f)
+
+    def GetAllChildren(self):
+        """ Return a generator returning all children, grandchildren, etc,
+            of the given widget.  The widgets are traversed depth-first.
+        """
+        if hasattr(self, 'GetChildren'):
+            for child in self.GetChildren():
+                yield child
+                for grandchild in child.GetAllChildren():
+                    yield grandchild
+
+    #
+    # pseudo-properties
+
+    def __getattr__(self, name):
+        if hasattr(self.__class__, "Get" + name):
+            # use self.__class__ rather than self to avoid recursion
+            f = getattr(self, "Get" + name)
+            return f()
+        else:
+            raise AttributeError, name
+
+    def __setattr__(self, name, value):
+        if hasattr(self, "Set" + name):
+            f = getattr(self, "Set" + name)
+            return f(value)
+        elif name.startswith("On"):
+            shortname = name[2:]
+            if self.__events__.has_key(shortname):
+                wxevent = self.__events__[shortname]
+            elif events.events.has_key(shortname):
+                wxevent = events.events[shortname]
+            else:
+                wxevent = None
+            self.__dict__[name] = value
+            if wxevent:
+                self.Bind(wxevent, value)
+                if core.DEBUG:
+                    print "Binding %s to %s" % (name, value)
+        else:
+            self.__dict__[name] = value
+
+    def SetAttributes(self, **kwargs):
+        """ Set a number of attributes at once.  E.g.
+            widget.SetAttributes(Font=MYFONT, Size=(100,200))
+        """
+        for (key, value) in kwargs.items():
+            self.__setattr__(key, value)
+
+    def SetProperties(self, **kwargs):
+        """ As SetAttributes, but raises an error if an unknown property name
+            is specified. """
+        for (key, value) in kwargs.items():
+            f = getattr(self, "Set" + key, None)
+            if f:
+                f(value)
+            else:
+                raise AttributeError, "Unknown property: %s" % (key,)
+
+    def _params(self, kwargs, thesestyles={}):
+        # default method for those controls that don't have a _params()
+        if thesestyles:
+            return styles.dostyle(thesestyles, kwargs)
+        else:
+            return styles.dostyle(self.__styles__, kwargs)
+
+    def HasStyle(self, style, substyle=None):
+        """ Returns whether or not a style is set for this object. """
+        try:
+            sval = self.__styles__[style][0]
+            if isinstance(sval, dict):
+                # The style returned is a complex style so...
+                if substyle:
+                    # ...checking for a specific substyle, return if it's set
+                    subval = sval[substyle]
+                    ws = self.GetWindowStyle()
+                    # If we're dealing with a zero based style, things
+                    #  get a bit trickier
+                    if subval == 0:
+                        for k in sval:
+                            temp = sval[k]
+                            if k != substyle and (ws & temp) == temp:
+                                return False
+                    return (ws & subval) == subval
+                else:
+                    # ...not checking for specific, so see if either is set and
+                    #  return the key value associated with what is set
+                    mystyle = self.GetWindowStyle()
+                    for k in sval:
+                        v = sval[k]
+                        if (mystyle & v) == v:
+                            return k
+                    return False
+            else:
+                # Style is not complex, return if it is set or not
+                return (self.GetWindowStyle() & sval) == sval
+        except:
+            return False
+
+    def GetStyleDict(self):
+        """ Returns a dictionary with style info for this object. """
+        ret = {}
+        for k in self.__styles__:
+            ret[k] = self.HasStyle(k)
+        return ret
diff --git a/pynxc/yaml/__init__.py b/pynxc/yaml/__init__.py
new file mode 100644
index 0000000..c0fd1f3
--- /dev/null
+++ b/pynxc/yaml/__init__.py
@@ -0,0 +1,288 @@
+
+from error import *
+
+from tokens import *
+from events import *
+from nodes import *
+
+from loader import *
+from dumper import *
+
+__version__ = '3.09'
+
+try:
+    from cyaml import *
+    __with_libyaml__ = True
+except ImportError:
+    __with_libyaml__ = False
+
+def scan(stream, Loader=Loader):
+    """
+    Scan a YAML stream and produce scanning tokens.
+    """
+    loader = Loader(stream)
+    while loader.check_token():
+        yield loader.get_token()
+
+def parse(stream, Loader=Loader):
+    """
+    Parse a YAML stream and produce parsing events.
+    """
+    loader = Loader(stream)
+    while loader.check_event():
+        yield loader.get_event()
+
+def compose(stream, Loader=Loader):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding representation tree.
+    """
+    loader = Loader(stream)
+    return loader.get_single_node()
+
+def compose_all(stream, Loader=Loader):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding representation trees.
+    """
+    loader = Loader(stream)
+    while loader.check_node():
+        yield loader.get_node()
+
+def load(stream, Loader=Loader):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding Python object.
+    """
+    loader = Loader(stream)
+    return loader.get_single_data()
+
+def load_all(stream, Loader=Loader):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding Python objects.
+    """
+    loader = Loader(stream)
+    while loader.check_data():
+        yield loader.get_data()
+
+def safe_load(stream):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding Python object.
+    Resolve only basic YAML tags.
+    """
+    return load(stream, SafeLoader)
+
+def safe_load_all(stream):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding Python objects.
+    Resolve only basic YAML tags.
+    """
+    return load_all(stream, SafeLoader)
+
+def emit(events, stream=None, Dumper=Dumper,
+        canonical=None, indent=None, width=None,
+        allow_unicode=None, line_break=None):
+    """
+    Emit YAML parsing events into a stream.
+    If stream is None, return the produced string instead.
+    """
+    getvalue = None
+    if stream is None:
+        from StringIO import StringIO
+        stream = StringIO()
+        getvalue = stream.getvalue
+    dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
+            allow_unicode=allow_unicode, line_break=line_break)
+    for event in events:
+        dumper.emit(event)
+    if getvalue:
+        return getvalue()
+
+def serialize_all(nodes, stream=None, Dumper=Dumper,
+        canonical=None, indent=None, width=None,
+        allow_unicode=None, line_break=None,
+        encoding='utf-8', explicit_start=None, explicit_end=None,
+        version=None, tags=None):
+    """
+    Serialize a sequence of representation trees into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    getvalue = None
+    if stream is None:
+        if encoding is None:
+            from StringIO import StringIO
+        else:
+            from cStringIO import StringIO
+        stream = StringIO()
+        getvalue = stream.getvalue
+    dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
+            allow_unicode=allow_unicode, line_break=line_break,
+            encoding=encoding, version=version, tags=tags,
+            explicit_start=explicit_start, explicit_end=explicit_end)
+    dumper.open()
+    for node in nodes:
+        dumper.serialize(node)
+    dumper.close()
+    if getvalue:
+        return getvalue()
+
+def serialize(node, stream=None, Dumper=Dumper, **kwds):
+    """
+    Serialize a representation tree into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    return serialize_all([node], stream, Dumper=Dumper, **kwds)
+
+def dump_all(documents, stream=None, Dumper=Dumper,
+        default_style=None, default_flow_style=None,
+        canonical=None, indent=None, width=None,
+        allow_unicode=None, line_break=None,
+        encoding='utf-8', explicit_start=None, explicit_end=None,
+        version=None, tags=None):
+    """
+    Serialize a sequence of Python objects into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    getvalue = None
+    if stream is None:
+        if encoding is None:
+            from StringIO import StringIO
+        else:
+            from cStringIO import StringIO
+        stream = StringIO()
+        getvalue = stream.getvalue
+    dumper = Dumper(stream, default_style=default_style,
+            default_flow_style=default_flow_style,
+            canonical=canonical, indent=indent, width=width,
+            allow_unicode=allow_unicode, line_break=line_break,
+            encoding=encoding, version=version, tags=tags,
+            explicit_start=explicit_start, explicit_end=explicit_end)
+    dumper.open()
+    for data in documents:
+        dumper.represent(data)
+    dumper.close()
+    if getvalue:
+        return getvalue()
+
+def dump(data, stream=None, Dumper=Dumper, **kwds):
+    """
+    Serialize a Python object into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    return dump_all([data], stream, Dumper=Dumper, **kwds)
+
+def safe_dump_all(documents, stream=None, **kwds):
+    """
+    Serialize a sequence of Python objects into a YAML stream.
+    Produce only basic YAML tags.
+    If stream is None, return the produced string instead.
+    """
+    return dump_all(documents, stream, Dumper=SafeDumper, **kwds)
+
+def safe_dump(data, stream=None, **kwds):
+    """
+    Serialize a Python object into a YAML stream.
+    Produce only basic YAML tags.
+    If stream is None, return the produced string instead.
+    """
+    return dump_all([data], stream, Dumper=SafeDumper, **kwds)
+
+def add_implicit_resolver(tag, regexp, first=None,
+        Loader=Loader, Dumper=Dumper):
+    """
+    Add an implicit scalar detector.
+    If an implicit scalar value matches the given regexp,
+    the corresponding tag is assigned to the scalar.
+    first is a sequence of possible initial characters or None.
+    """
+    Loader.add_implicit_resolver(tag, regexp, first)
+    Dumper.add_implicit_resolver(tag, regexp, first)
+
+def add_path_resolver(tag, path, kind=None, Loader=Loader, Dumper=Dumper):
+    """
+    Add a path based resolver for the given tag.
+    A path is a list of keys that forms a path
+    to a node in the representation tree.
+    Keys can be string values, integers, or None.
+    """
+    Loader.add_path_resolver(tag, path, kind)
+    Dumper.add_path_resolver(tag, path, kind)
+
+def add_constructor(tag, constructor, Loader=Loader):
+    """
+    Add a constructor for the given tag.
+    Constructor is a function that accepts a Loader instance
+    and a node object and produces the corresponding Python object.
+    """
+    Loader.add_constructor(tag, constructor)
+
+def add_multi_constructor(tag_prefix, multi_constructor, Loader=Loader):
+    """
+    Add a multi-constructor for the given tag prefix.
+    Multi-constructor is called for a node if its tag starts with tag_prefix.
+    Multi-constructor accepts a Loader instance, a tag suffix,
+    and a node object and produces the corresponding Python object.
+    """
+    Loader.add_multi_constructor(tag_prefix, multi_constructor)
+
+def add_representer(data_type, representer, Dumper=Dumper):
+    """
+    Add a representer for the given type.
+    Representer is a function accepting a Dumper instance
+    and an instance of the given data type
+    and producing the corresponding representation node.
+    """
+    Dumper.add_representer(data_type, representer)
+
+def add_multi_representer(data_type, multi_representer, Dumper=Dumper):
+    """
+    Add a representer for the given type.
+    Multi-representer is a function accepting a Dumper instance
+    and an instance of the given data type or subtype
+    and producing the corresponding representation node.
+    """
+    Dumper.add_multi_representer(data_type, multi_representer)
+
+class YAMLObjectMetaclass(type):
+    """
+    The metaclass for YAMLObject.
+    """
+    def __init__(cls, name, bases, kwds):
+        super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds)
+        if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None:
+            cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml)
+            cls.yaml_dumper.add_representer(cls, cls.to_yaml)
+
+class YAMLObject(object):
+    """
+    An object that can dump itself to a YAML stream
+    and load itself from a YAML stream.
+    """
+
+    __metaclass__ = YAMLObjectMetaclass
+    __slots__ = ()  # no direct instantiation, so allow immutable subclasses
+
+    yaml_loader = Loader
+    yaml_dumper = Dumper
+
+    yaml_tag = None
+    yaml_flow_style = None
+
+    def from_yaml(cls, loader, node):
+        """
+        Convert a representation node to a Python object.
+        """
+        return loader.construct_yaml_object(node, cls)
+    from_yaml = classmethod(from_yaml)
+
+    def to_yaml(cls, dumper, data):
+        """
+        Convert a Python object to a representation node.
+        """
+        return dumper.represent_yaml_object(cls.yaml_tag, data, cls,
+                flow_style=cls.yaml_flow_style)
+    to_yaml = classmethod(to_yaml)
+
diff --git a/pynxc/yaml/composer.py b/pynxc/yaml/composer.py
new file mode 100644
index 0000000..06e5ac7
--- /dev/null
+++ b/pynxc/yaml/composer.py
@@ -0,0 +1,139 @@
+
+__all__ = ['Composer', 'ComposerError']
+
+from error import MarkedYAMLError
+from events import *
+from nodes import *
+
+class ComposerError(MarkedYAMLError):
+    pass
+
+class Composer(object):
+
+    def __init__(self):
+        self.anchors = {}
+
+    def check_node(self):
+        # Drop the STREAM-START event.
+        if self.check_event(StreamStartEvent):
+            self.get_event()
+
+        # If there are more documents available?
+        return not self.check_event(StreamEndEvent)
+
+    def get_node(self):
+        # Get the root node of the next document.
+        if not self.check_event(StreamEndEvent):
+            return self.compose_document()
+
+    def get_single_node(self):
+        # Drop the STREAM-START event.
+        self.get_event()
+
+        # Compose a document if the stream is not empty.
+        document = None
+        if not self.check_event(StreamEndEvent):
+            document = self.compose_document()
+
+        # Ensure that the stream contains no more documents.
+        if not self.check_event(StreamEndEvent):
+            event = self.get_event()
+            raise ComposerError("expected a single document in the stream",
+                    document.start_mark, "but found another document",
+                    event.start_mark)
+
+        # Drop the STREAM-END event.
+        self.get_event()
+
+        return document
+
+    def compose_document(self):
+        # Drop the DOCUMENT-START event.
+        self.get_event()
+
+        # Compose the root node.
+        node = self.compose_node(None, None)
+
+        # Drop the DOCUMENT-END event.
+        self.get_event()
+
+        self.anchors = {}
+        return node
+
+    def compose_node(self, parent, index):
+        if self.check_event(AliasEvent):
+            event = self.get_event()
+            anchor = event.anchor
+            if anchor not in self.anchors:
+                raise ComposerError(None, None, "found undefined alias %r"
+                        % anchor.encode('utf-8'), event.start_mark)
+            return self.anchors[anchor]
+        event = self.peek_event()
+        anchor = event.anchor
+        if anchor is not None:
+            if anchor in self.anchors:
+                raise ComposerError("found duplicate anchor %r; first occurence"
+                        % anchor.encode('utf-8'), self.anchors[anchor].start_mark,
+                        "second occurence", event.start_mark)
+        self.descend_resolver(parent, index)
+        if self.check_event(ScalarEvent):
+            node = self.compose_scalar_node(anchor)
+        elif self.check_event(SequenceStartEvent):
+            node = self.compose_sequence_node(anchor)
+        elif self.check_event(MappingStartEvent):
+            node = self.compose_mapping_node(anchor)
+        self.ascend_resolver()
+        return node
+
+    def compose_scalar_node(self, anchor):
+        event = self.get_event()
+        tag = event.tag
+        if tag is None or tag == u'!':
+            tag = self.resolve(ScalarNode, event.value, event.implicit)
+        node = ScalarNode(tag, event.value,
+                event.start_mark, event.end_mark, style=event.style)
+        if anchor is not None:
+            self.anchors[anchor] = node
+        return node
+
+    def compose_sequence_node(self, anchor):
+        start_event = self.get_event()
+        tag = start_event.tag
+        if tag is None or tag == u'!':
+            tag = self.resolve(SequenceNode, None, start_event.implicit)
+        node = SequenceNode(tag, [],
+                start_event.start_mark, None,
+                flow_style=start_event.flow_style)
+        if anchor is not None:
+            self.anchors[anchor] = node
+        index = 0
+        while not self.check_event(SequenceEndEvent):
+            node.value.append(self.compose_node(node, index))
+            index += 1
+        end_event = self.get_event()
+        node.end_mark = end_event.end_mark
+        return node
+
+    def compose_mapping_node(self, anchor):
+        start_event = self.get_event()
+        tag = start_event.tag
+        if tag is None or tag == u'!':
+            tag = self.resolve(MappingNode, None, start_event.implicit)
+        node = MappingNode(tag, [],
+                start_event.start_mark, None,
+                flow_style=start_event.flow_style)
+        if anchor is not None:
+            self.anchors[anchor] = node
+        while not self.check_event(MappingEndEvent):
+            #key_event = self.peek_event()
+            item_key = self.compose_node(node, None)
+            #if item_key in node.value:
+            #    raise ComposerError("while composing a mapping", start_event.start_mark,
+            #            "found duplicate key", key_event.start_mark)
+            item_value = self.compose_node(node, item_key)
+            #node.value[item_key] = item_value
+            node.value.append((item_key, item_value))
+        end_event = self.get_event()
+        node.end_mark = end_event.end_mark
+        return node
+
diff --git a/pynxc/yaml/constructor.py b/pynxc/yaml/constructor.py
new file mode 100644
index 0000000..420c434
--- /dev/null
+++ b/pynxc/yaml/constructor.py
@@ -0,0 +1,684 @@
+
+__all__ = ['BaseConstructor', 'SafeConstructor', 'Constructor',
+    'ConstructorError']
+
+from error import *
+from nodes import *
+
+import datetime
+
+try:
+    set
+except NameError:
+    from sets import Set as set
+
+import binascii, re, sys, types
+
+class ConstructorError(MarkedYAMLError):
+    pass
+
+class BaseConstructor(object):
+
+    yaml_constructors = {}
+    yaml_multi_constructors = {}
+
+    def __init__(self):
+        self.constructed_objects = {}
+        self.recursive_objects = {}
+        self.state_generators = []
+        self.deep_construct = False
+
+    def check_data(self):
+        # If there are more documents available?
+        return self.check_node()
+
+    def get_data(self):
+        # Construct and return the next document.
+        if self.check_node():
+            return self.construct_document(self.get_node())
+
+    def get_single_data(self):
+        # Ensure that the stream contains a single document and construct it.
+        node = self.get_single_node()
+        if node is not None:
+            return self.construct_document(node)
+        return None
+
+    def construct_document(self, node):
+        data = self.construct_object(node)
+        while self.state_generators:
+            state_generators = self.state_generators
+            self.state_generators = []
+            for generator in state_generators:
+                for dummy in generator:
+                    pass
+        self.constructed_objects = {}
+        self.recursive_objects = {}
+        self.deep_construct = False
+        return data
+
+    def construct_object(self, node, deep=False):
+        if deep:
+            old_deep = self.deep_construct
+            self.deep_construct = True
+        if node in self.constructed_objects:
+            return self.constructed_objects[node]
+        if node in self.recursive_objects:
+            raise ConstructorError(None, None,
+                    "found unconstructable recursive node", node.start_mark)
+        self.recursive_objects[node] = None
+        constructor = None
+        tag_suffix = None
+        if node.tag in self.yaml_constructors:
+            constructor = self.yaml_constructors[node.tag]
+        else:
+            for tag_prefix in self.yaml_multi_constructors:
+                if node.tag.startswith(tag_prefix):
+                    tag_suffix = node.tag[len(tag_prefix):]
+                    constructor = self.yaml_multi_constructors[tag_prefix]
+                    break
+            else:
+                if None in self.yaml_multi_constructors:
+                    tag_suffix = node.tag
+                    constructor = self.yaml_multi_constructors[None]
+                elif None in self.yaml_constructors:
+                    constructor = self.yaml_constructors[None]
+                elif isinstance(node, ScalarNode):
+                    constructor = self.__class__.construct_scalar
+                elif isinstance(node, SequenceNode):
+                    constructor = self.__class__.construct_sequence
+                elif isinstance(node, MappingNode):
+                    constructor = self.__class__.construct_mapping
+        if tag_suffix is None:
+            data = constructor(self, node)
+        else:
+            data = constructor(self, tag_suffix, node)
+        if isinstance(data, types.GeneratorType):
+            generator = data
+            data = generator.next()
+            if self.deep_construct:
+                for dummy in generator:
+                    pass
+            else:
+                self.state_generators.append(generator)
+        self.constructed_objects[node] = data
+        del self.recursive_objects[node]
+        if deep:
+            self.deep_construct = old_deep
+        return data
+
+    def construct_scalar(self, node):
+        if not isinstance(node, ScalarNode):
+            raise ConstructorError(None, None,
+                    "expected a scalar node, but found %s" % node.id,
+                    node.start_mark)
+        return node.value
+
+    def construct_sequence(self, node, deep=False):
+        if not isinstance(node, SequenceNode):
+            raise ConstructorError(None, None,
+                    "expected a sequence node, but found %s" % node.id,
+                    node.start_mark)
+        return [self.construct_object(child, deep=deep)
+                for child in node.value]
+
+    def construct_mapping(self, node, deep=False):
+        if not isinstance(node, MappingNode):
+            raise ConstructorError(None, None,
+                    "expected a mapping node, but found %s" % node.id,
+                    node.start_mark)
+        mapping = {}
+        for key_node, value_node in node.value:
+            key = self.construct_object(key_node, deep=deep)
+            try:
+                hash(key)
+            except TypeError, exc:
+                raise ConstructorError("while constructing a mapping", node.start_mark,
+                        "found unacceptable key (%s)" % exc, key_node.start_mark)
+            value = self.construct_object(value_node, deep=deep)
+            mapping[key] = value
+        return mapping
+
+    def construct_pairs(self, node, deep=False):
+        if not isinstance(node, MappingNode):
+            raise ConstructorError(None, None,
+                    "expected a mapping node, but found %s" % node.id,
+                    node.start_mark)
+        pairs = []
+        for key_node, value_node in node.value:
+            key = self.construct_object(key_node, deep=deep)
+            value = self.construct_object(value_node, deep=deep)
+            pairs.append((key, value))
+        return pairs
+
+    def add_constructor(cls, tag, constructor):
+        if not 'yaml_constructors' in cls.__dict__:
+            cls.yaml_constructors = cls.yaml_constructors.copy()
+        cls.yaml_constructors[tag] = constructor
+    add_constructor = classmethod(add_constructor)
+
+    def add_multi_constructor(cls, tag_prefix, multi_constructor):
+        if not 'yaml_multi_constructors' in cls.__dict__:
+            cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy()
+        cls.yaml_multi_constructors[tag_prefix] = multi_constructor
+    add_multi_constructor = classmethod(add_multi_constructor)
+
+class SafeConstructor(BaseConstructor):
+
+    def construct_scalar(self, node):
+        if isinstance(node, MappingNode):
+            for key_node, value_node in node.value:
+                if key_node.tag == u'tag:yaml.org,2002:value':
+                    return self.construct_scalar(value_node)
+        return BaseConstructor.construct_scalar(self, node)
+
+    def flatten_mapping(self, node):
+        merge = []
+        index = 0
+        while index < len(node.value):
+            key_node, value_node = node.value[index]
+            if key_node.tag == u'tag:yaml.org,2002:merge':
+                del node.value[index]
+                if isinstance(value_node, MappingNode):
+                    self.flatten_mapping(value_node)
+                    merge.extend(value_node.value)
+                elif isinstance(value_node, SequenceNode):
+                    submerge = []
+                    for subnode in value_node.value:
+                        if not isinstance(subnode, MappingNode):
+                            raise ConstructorError("while constructing a mapping",
+                                    node.start_mark,
+                                    "expected a mapping for merging, but found %s"
+                                    % subnode.id, subnode.start_mark)
+                        self.flatten_mapping(subnode)
+                        submerge.append(subnode.value)
+                    submerge.reverse()
+                    for value in submerge:
+                        merge.extend(value)
+                else:
+                    raise ConstructorError("while constructing a mapping", node.start_mark,
+                            "expected a mapping or list of mappings for merging, but found %s"
+                            % value_node.id, value_node.start_mark)
+            elif key_node.tag == u'tag:yaml.org,2002:value':
+                key_node.tag = u'tag:yaml.org,2002:str'
+                index += 1
+            else:
+                index += 1
+        if merge:
+            node.value = merge + node.value
+
+    def construct_mapping(self, node, deep=False):
+        if isinstance(node, MappingNode):
+            self.flatten_mapping(node)
+        return BaseConstructor.construct_mapping(self, node, deep=deep)
+
+    def construct_yaml_null(self, node):
+        self.construct_scalar(node)
+        return None
+
+    bool_values = {
+        u'yes':     True,
+        u'no':      False,
+        u'true':    True,
+        u'false':   False,
+        u'on':      True,
+        u'off':     False,
+    }
+
+    def construct_yaml_bool(self, node):
+        value = self.construct_scalar(node)
+        return self.bool_values[value.lower()]
+
+    def construct_yaml_int(self, node):
+        value = str(self.construct_scalar(node))
+        value = value.replace('_', '')
+        sign = +1
+        if value[0] == '-':
+            sign = -1
+        if value[0] in '+-':
+            value = value[1:]
+        if value == '0':
+            return 0
+        elif value.startswith('0b'):
+            return sign*int(value[2:], 2)
+        elif value.startswith('0x'):
+            return sign*int(value[2:], 16)
+        elif value[0] == '0':
+            return sign*int(value, 8)
+        elif ':' in value:
+            digits = [int(part) for part in value.split(':')]
+            digits.reverse()
+            base = 1
+            value = 0
+            for digit in digits:
+                value += digit*base
+                base *= 60
+            return sign*value
+        else:
+            return sign*int(value)
+
+    inf_value = 1e300
+    while inf_value != inf_value*inf_value:
+        inf_value *= inf_value
+    nan_value = -inf_value/inf_value   # Trying to make a quiet NaN (like C99).
+
+    def construct_yaml_float(self, node):
+        value = str(self.construct_scalar(node))
+        value = value.replace('_', '').lower()
+        sign = +1
+        if value[0] == '-':
+            sign = -1
+        if value[0] in '+-':
+            value = value[1:]
+        if value == '.inf':
+            return sign*self.inf_value
+        elif value == '.nan':
+            return self.nan_value
+        elif ':' in value:
+            digits = [float(part) for part in value.split(':')]
+            digits.reverse()
+            base = 1
+            value = 0.0
+            for digit in digits:
+                value += digit*base
+                base *= 60
+            return sign*value
+        else:
+            return sign*float(value)
+
+    def construct_yaml_binary(self, node):
+        value = self.construct_scalar(node)
+        try:
+            return str(value).decode('base64')
+        except (binascii.Error, UnicodeEncodeError), exc:
+            raise ConstructorError(None, None,
+                    "failed to decode base64 data: %s" % exc, node.start_mark) 
+
+    timestamp_regexp = re.compile(
+            ur'''^(?P<year>[0-9][0-9][0-9][0-9])
+                -(?P<month>[0-9][0-9]?)
+                -(?P<day>[0-9][0-9]?)
+                (?:(?:[Tt]|[ \t]+)
+                (?P<hour>[0-9][0-9]?)
+                :(?P<minute>[0-9][0-9])
+                :(?P<second>[0-9][0-9])
+                (?:\.(?P<fraction>[0-9]*))?
+                (?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)
+                (?::(?P<tz_minute>[0-9][0-9]))?))?)?$''', re.X)
+
+    def construct_yaml_timestamp(self, node):
+        value = self.construct_scalar(node)
+        match = self.timestamp_regexp.match(node.value)
+        values = match.groupdict()
+        year = int(values['year'])
+        month = int(values['month'])
+        day = int(values['day'])
+        if not values['hour']:
+            return datetime.date(year, month, day)
+        hour = int(values['hour'])
+        minute = int(values['minute'])
+        second = int(values['second'])
+        fraction = 0
+        if values['fraction']:
+            fraction = values['fraction'][:6]
+            while len(fraction) < 6:
+                fraction += '0'
+            fraction = int(fraction)
+        delta = None
+        if values['tz_sign']:
+            tz_hour = int(values['tz_hour'])
+            tz_minute = int(values['tz_minute'] or 0)
+            delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute)
+            if values['tz_sign'] == '-':
+                delta = -delta
+        data = datetime.datetime(year, month, day, hour, minute, second, fraction)
+        if delta:
+            data -= delta
+        return data
+
+    def construct_yaml_omap(self, node):
+        # Note: we do not check for duplicate keys, because it's too
+        # CPU-expensive.
+        omap = []
+        yield omap
+        if not isinstance(node, SequenceNode):
+            raise ConstructorError("while constructing an ordered map", node.start_mark,
+                    "expected a sequence, but found %s" % node.id, node.start_mark)
+        for subnode in node.value:
+            if not isinstance(subnode, MappingNode):
+                raise ConstructorError("while constructing an ordered map", node.start_mark,
+                        "expected a mapping of length 1, but found %s" % subnode.id,
+                        subnode.start_mark)
+            if len(subnode.value) != 1:
+                raise ConstructorError("while constructing an ordered map", node.start_mark,
+                        "expected a single mapping item, but found %d items" % len(subnode.value),
+                        subnode.start_mark)
+            key_node, value_node = subnode.value[0]
+            key = self.construct_object(key_node)
+            value = self.construct_object(value_node)
+            omap.append((key, value))
+
+    def construct_yaml_pairs(self, node):
+        # Note: the same code as `construct_yaml_omap`.
+        pairs = []
+        yield pairs
+        if not isinstance(node, SequenceNode):
+            raise ConstructorError("while constructing pairs", node.start_mark,
+                    "expected a sequence, but found %s" % node.id, node.start_mark)
+        for subnode in node.value:
+            if not isinstance(subnode, MappingNode):
+                raise ConstructorError("while constructing pairs", node.start_mark,
+                        "expected a mapping of length 1, but found %s" % subnode.id,
+                        subnode.start_mark)
+            if len(subnode.value) != 1:
+                raise ConstructorError("while constructing pairs", node.start_mark,
+                        "expected a single mapping item, but found %d items" % len(subnode.value),
+                        subnode.start_mark)
+            key_node, value_node = subnode.value[0]
+            key = self.construct_object(key_node)
+            value = self.construct_object(value_node)
+            pairs.append((key, value))
+
+    def construct_yaml_set(self, node):
+        data = set()
+        yield data
+        value = self.construct_mapping(node)
+        data.update(value)
+
+    def construct_yaml_str(self, node):
+        value = self.construct_scalar(node)
+        try:
+            return value.encode('ascii')
+        except UnicodeEncodeError:
+            return value
+
+    def construct_yaml_seq(self, node):
+        data = []
+        yield data
+        data.extend(self.construct_sequence(node))
+
+    def construct_yaml_map(self, node):
+        data = {}
+        yield data
+        value = self.construct_mapping(node)
+        data.update(value)
+
+    def construct_yaml_object(self, node, cls):
+        data = cls.__new__(cls)
+        yield data
+        if hasattr(data, '__setstate__'):
+            state = self.construct_mapping(node, deep=True)
+            data.__setstate__(state)
+        else:
+            state = self.construct_mapping(node)
+            data.__dict__.update(state)
+
+    def construct_undefined(self, node):
+        raise ConstructorError(None, None,
+                "could not determine a constructor for the tag %r" % node.tag.encode('utf-8'),
+                node.start_mark)
+
+SafeConstructor.add_constructor(
+        u'tag:yaml.org,2002:null',
+        SafeConstructor.construct_yaml_null)
+
+SafeConstructor.add_constructor(
+        u'tag:yaml.org,2002:bool',
+        SafeConstructor.construct_yaml_bool)
+
+SafeConstructor.add_constructor(
+        u'tag:yaml.org,2002:int',
+        SafeConstructor.construct_yaml_int)
+
+SafeConstructor.add_constructor(
+        u'tag:yaml.org,2002:float',
+        SafeConstructor.construct_yaml_float)
+
+SafeConstructor.add_constructor(
+        u'tag:yaml.org,2002:binary',
+        SafeConstructor.construct_yaml_binary)
+
+SafeConstructor.add_constructor(
+        u'tag:yaml.org,2002:timestamp',
+        SafeConstructor.construct_yaml_timestamp)
+
+SafeConstructor.add_constructor(
+        u'tag:yaml.org,2002:omap',
+        SafeConstructor.construct_yaml_omap)
+
+SafeConstructor.add_constructor(
+        u'tag:yaml.org,2002:pairs',
+        SafeConstructor.construct_yaml_pairs)
+
+SafeConstructor.add_constructor(
+        u'tag:yaml.org,2002:set',
+        SafeConstructor.construct_yaml_set)
+
+SafeConstructor.add_constructor(
+        u'tag:yaml.org,2002:str',
+        SafeConstructor.construct_yaml_str)
+
+SafeConstructor.add_constructor(
+        u'tag:yaml.org,2002:seq',
+        SafeConstructor.construct_yaml_seq)
+
+SafeConstructor.add_constructor(
+        u'tag:yaml.org,2002:map',
+        SafeConstructor.construct_yaml_map)
+
+SafeConstructor.add_constructor(None,
+        SafeConstructor.construct_undefined)
+
+class Constructor(SafeConstructor):
+
+    def construct_python_str(self, node):
+        return self.construct_scalar(node).encode('utf-8')
+
+    def construct_python_unicode(self, node):
+        return self.construct_scalar(node)
+
+    def construct_python_long(self, node):
+        return long(self.construct_yaml_int(node))
+
+    def construct_python_complex(self, node):
+       return complex(self.construct_scalar(node))
+
+    def construct_python_tuple(self, node):
+        return tuple(self.construct_sequence(node))
+
+    def find_python_module(self, name, mark):
+        if not name:
+            raise ConstructorError("while constructing a Python module", mark,
+                    "expected non-empty name appended to the tag", mark)
+        try:
+            __import__(name)
+        except ImportError, exc:
+            raise ConstructorError("while constructing a Python module", mark,
+                    "cannot find module %r (%s)" % (name.encode('utf-8'), exc), mark)
+        return sys.modules[name]
+
+    def find_python_name(self, name, mark):
+        if not name:
+            raise ConstructorError("while constructing a Python object", mark,
+                    "expected non-empty name appended to the tag", mark)
+        if u'.' in name:
+            # Python 2.4 only
+            #module_name, object_name = name.rsplit('.', 1)
+            items = name.split('.')
+            object_name = items.pop()
+            module_name = '.'.join(items)
+        else:
+            module_name = '__builtin__'
+            object_name = name
+        try:
+            __import__(module_name)
+        except ImportError, exc:
+            raise ConstructorError("while constructing a Python object", mark,
+                    "cannot find module %r (%s)" % (module_name.encode('utf-8'), exc), mark)
+        module = sys.modules[module_name]
+        if not hasattr(module, object_name):
+            raise ConstructorError("while constructing a Python object", mark,
+                    "cannot find %r in the module %r" % (object_name.encode('utf-8'),
+                        module.__name__), mark)
+        return getattr(module, object_name)
+
+    def construct_python_name(self, suffix, node):
+        value = self.construct_scalar(node)
+        if value:
+            raise ConstructorError("while constructing a Python name", node.start_mark,
+                    "expected the empty value, but found %r" % value.encode('utf-8'),
+                    node.start_mark)
+        return self.find_python_name(suffix, node.start_mark)
+
+    def construct_python_module(self, suffix, node):
+        value = self.construct_scalar(node)
+        if value:
+            raise ConstructorError("while constructing a Python module", node.start_mark,
+                    "expected the empty value, but found %r" % value.encode('utf-8'),
+                    node.start_mark)
+        return self.find_python_module(suffix, node.start_mark)
+
+    class classobj: pass
+
+    def make_python_instance(self, suffix, node,
+            args=None, kwds=None, newobj=False):
+        if not args:
+            args = []
+        if not kwds:
+            kwds = {}
+        cls = self.find_python_name(suffix, node.start_mark)
+        if newobj and isinstance(cls, type(self.classobj))  \
+                and not args and not kwds:
+            instance = self.classobj()
+            instance.__class__ = cls
+            return instance
+        elif newobj and isinstance(cls, type):
+            return cls.__new__(cls, *args, **kwds)
+        else:
+            return cls(*args, **kwds)
+
+    def set_python_instance_state(self, instance, state):
+        if hasattr(instance, '__setstate__'):
+            instance.__setstate__(state)
+        else:
+            slotstate = {}
+            if isinstance(state, tuple) and len(state) == 2:
+                state, slotstate = state
+            if hasattr(instance, '__dict__'):
+                instance.__dict__.update(state)
+            elif state:
+                slotstate.update(state)
+            for key, value in slotstate.items():
+                setattr(object, key, value)
+
+    def construct_python_object(self, suffix, node):
+        # Format:
+        #   !!python/object:module.name { ... state ... }
+        instance = self.make_python_instance(suffix, node, newobj=True)
+        yield instance
+        deep = hasattr(instance, '__setstate__')
+        state = self.construct_mapping(node, deep=deep)
+        self.set_python_instance_state(instance, state)
+
+    def construct_python_object_apply(self, suffix, node, newobj=False):
+        # Format:
+        #   !!python/object/apply       # (or !!python/object/new)
+        #   args: [ ... arguments ... ]
+        #   kwds: { ... keywords ... }
+        #   state: ... state ...
+        #   listitems: [ ... listitems ... ]
+        #   dictitems: { ... dictitems ... }
+        # or short format:
+        #   !!python/object/apply [ ... arguments ... ]
+        # The difference between !!python/object/apply and !!python/object/new
+        # is how an object is created, check make_python_instance for details.
+        if isinstance(node, SequenceNode):
+            args = self.construct_sequence(node, deep=True)
+            kwds = {}
+            state = {}
+            listitems = []
+            dictitems = {}
+        else:
+            value = self.construct_mapping(node, deep=True)
+            args = value.get('args', [])
+            kwds = value.get('kwds', {})
+            state = value.get('state', {})
+            listitems = value.get('listitems', [])
+            dictitems = value.get('dictitems', {})
+        instance = self.make_python_instance(suffix, node, args, kwds, newobj)
+        if state:
+            self.set_python_instance_state(instance, state)
+        if listitems:
+            instance.extend(listitems)
+        if dictitems:
+            for key in dictitems:
+                instance[key] = dictitems[key]
+        return instance
+
+    def construct_python_object_new(self, suffix, node):
+        return self.construct_python_object_apply(suffix, node, newobj=True)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/none',
+    Constructor.construct_yaml_null)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/bool',
+    Constructor.construct_yaml_bool)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/str',
+    Constructor.construct_python_str)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/unicode',
+    Constructor.construct_python_unicode)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/int',
+    Constructor.construct_yaml_int)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/long',
+    Constructor.construct_python_long)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/float',
+    Constructor.construct_yaml_float)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/complex',
+    Constructor.construct_python_complex)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/list',
+    Constructor.construct_yaml_seq)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/tuple',
+    Constructor.construct_python_tuple)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/dict',
+    Constructor.construct_yaml_map)
+
+Constructor.add_multi_constructor(
+    u'tag:yaml.org,2002:python/name:',
+    Constructor.construct_python_name)
+
+Constructor.add_multi_constructor(
+    u'tag:yaml.org,2002:python/module:',
+    Constructor.construct_python_module)
+
+Constructor.add_multi_constructor(
+    u'tag:yaml.org,2002:python/object:',
+    Constructor.construct_python_object)
+
+Constructor.add_multi_constructor(
+    u'tag:yaml.org,2002:python/object/apply:',
+    Constructor.construct_python_object_apply)
+
+Constructor.add_multi_constructor(
+    u'tag:yaml.org,2002:python/object/new:',
+    Constructor.construct_python_object_new)
+
diff --git a/pynxc/yaml/cyaml.py b/pynxc/yaml/cyaml.py
new file mode 100644
index 0000000..68dcd75
--- /dev/null
+++ b/pynxc/yaml/cyaml.py
@@ -0,0 +1,85 @@
+
+__all__ = ['CBaseLoader', 'CSafeLoader', 'CLoader',
+        'CBaseDumper', 'CSafeDumper', 'CDumper']
+
+from _yaml import CParser, CEmitter
+
+from constructor import *
+
+from serializer import *
+from representer import *
+
+from resolver import *
+
+class CBaseLoader(CParser, BaseConstructor, BaseResolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        BaseConstructor.__init__(self)
+        BaseResolver.__init__(self)
+
+class CSafeLoader(CParser, SafeConstructor, Resolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        SafeConstructor.__init__(self)
+        Resolver.__init__(self)
+
+class CLoader(CParser, Constructor, Resolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        Constructor.__init__(self)
+        Resolver.__init__(self)
+
+class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=None,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None):
+        CEmitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width, encoding=encoding,
+                allow_unicode=allow_unicode, line_break=line_break,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style)
+        Resolver.__init__(self)
+
+class CSafeDumper(CEmitter, SafeRepresenter, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=None,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None):
+        CEmitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width, encoding=encoding,
+                allow_unicode=allow_unicode, line_break=line_break,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        SafeRepresenter.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style)
+        Resolver.__init__(self)
+
+class CDumper(CEmitter, Serializer, Representer, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=None,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None):
+        CEmitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width, encoding=encoding,
+                allow_unicode=allow_unicode, line_break=line_break,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style)
+        Resolver.__init__(self)
+
diff --git a/pynxc/yaml/dumper.py b/pynxc/yaml/dumper.py
new file mode 100644
index 0000000..f811d2c
--- /dev/null
+++ b/pynxc/yaml/dumper.py
@@ -0,0 +1,62 @@
+
+__all__ = ['BaseDumper', 'SafeDumper', 'Dumper']
+
+from emitter import *
+from serializer import *
+from representer import *
+from resolver import *
+
+class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=None,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None):
+        Emitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width,
+                allow_unicode=allow_unicode, line_break=line_break)
+        Serializer.__init__(self, encoding=encoding,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style)
+        Resolver.__init__(self)
+
+class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=None,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None):
+        Emitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width,
+                allow_unicode=allow_unicode, line_break=line_break)
+        Serializer.__init__(self, encoding=encoding,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        SafeRepresenter.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style)
+        Resolver.__init__(self)
+
+class Dumper(Emitter, Serializer, Representer, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=None,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None):
+        Emitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width,
+                allow_unicode=allow_unicode, line_break=line_break)
+        Serializer.__init__(self, encoding=encoding,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style)
+        Resolver.__init__(self)
+
diff --git a/pynxc/yaml/emitter.py b/pynxc/yaml/emitter.py
new file mode 100644
index 0000000..4cb2c8a
--- /dev/null
+++ b/pynxc/yaml/emitter.py
@@ -0,0 +1,1135 @@
+
+# Emitter expects events obeying the following grammar:
+# stream ::= STREAM-START document* STREAM-END
+# document ::= DOCUMENT-START node DOCUMENT-END
+# node ::= SCALAR | sequence | mapping
+# sequence ::= SEQUENCE-START node* SEQUENCE-END
+# mapping ::= MAPPING-START (node node)* MAPPING-END
+
+__all__ = ['Emitter', 'EmitterError']
+
+from error import YAMLError
+from events import *
+
+class EmitterError(YAMLError):
+    pass
+
+class ScalarAnalysis(object):
+    def __init__(self, scalar, empty, multiline,
+            allow_flow_plain, allow_block_plain,
+            allow_single_quoted, allow_double_quoted,
+            allow_block):
+        self.scalar = scalar
+        self.empty = empty
+        self.multiline = multiline
+        self.allow_flow_plain = allow_flow_plain
+        self.allow_block_plain = allow_block_plain
+        self.allow_single_quoted = allow_single_quoted
+        self.allow_double_quoted = allow_double_quoted
+        self.allow_block = allow_block
+
+class Emitter(object):
+
+    DEFAULT_TAG_PREFIXES = {
+        u'!' : u'!',
+        u'tag:yaml.org,2002:' : u'!!',
+    }
+
+    def __init__(self, stream, canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None):
+
+        # The stream should have the methods `write` and possibly `flush`.
+        self.stream = stream
+
+        # Encoding can be overriden by STREAM-START.
+        self.encoding = None
+
+        # Emitter is a state machine with a stack of states to handle nested
+        # structures.
+        self.states = []
+        self.state = self.expect_stream_start
+
+        # Current event and the event queue.
+        self.events = []
+        self.event = None
+
+        # The current indentation level and the stack of previous indents.
+        self.indents = []
+        self.indent = None
+
+        # Flow level.
+        self.flow_level = 0
+
+        # Contexts.
+        self.root_context = False
+        self.sequence_context = False
+        self.mapping_context = False
+        self.simple_key_context = False
+
+        # Characteristics of the last emitted character:
+        #  - current position.
+        #  - is it a whitespace?
+        #  - is it an indention character
+        #    (indentation space, '-', '?', or ':')?
+        self.line = 0
+        self.column = 0
+        self.whitespace = True
+        self.indention = True
+
+        # Whether the document requires an explicit document indicator
+        self.open_ended = False
+
+        # Formatting details.
+        self.canonical = canonical
+        self.allow_unicode = allow_unicode
+        self.best_indent = 2
+        if indent and 1 < indent < 10:
+            self.best_indent = indent
+        self.best_width = 80
+        if width and width > self.best_indent*2:
+            self.best_width = width
+        self.best_line_break = u'\n'
+        if line_break in [u'\r', u'\n', u'\r\n']:
+            self.best_line_break = line_break
+
+        # Tag prefixes.
+        self.tag_prefixes = None
+
+        # Prepared anchor and tag.
+        self.prepared_anchor = None
+        self.prepared_tag = None
+
+        # Scalar analysis and style.
+        self.analysis = None
+        self.style = None
+
+    def emit(self, event):
+        self.events.append(event)
+        while not self.need_more_events():
+            self.event = self.events.pop(0)
+            self.state()
+            self.event = None
+
+    # In some cases, we wait for a few next events before emitting.
+
+    def need_more_events(self):
+        if not self.events:
+            return True
+        event = self.events[0]
+        if isinstance(event, DocumentStartEvent):
+            return self.need_events(1)
+        elif isinstance(event, SequenceStartEvent):
+            return self.need_events(2)
+        elif isinstance(event, MappingStartEvent):
+            return self.need_events(3)
+        else:
+            return False
+
+    def need_events(self, count):
+        level = 0
+        for event in self.events[1:]:
+            if isinstance(event, (DocumentStartEvent, CollectionStartEvent)):
+                level += 1
+            elif isinstance(event, (DocumentEndEvent, CollectionEndEvent)):
+                level -= 1
+            elif isinstance(event, StreamEndEvent):
+                level = -1
+            if level < 0:
+                return False
+        return (len(self.events) < count+1)
+
+    def increase_indent(self, flow=False, indentless=False):
+        self.indents.append(self.indent)
+        if self.indent is None:
+            if flow:
+                self.indent = self.best_indent
+            else:
+                self.indent = 0
+        elif not indentless:
+            self.indent += self.best_indent
+
+    # States.
+
+    # Stream handlers.
+
+    def expect_stream_start(self):
+        if isinstance(self.event, StreamStartEvent):
+            if self.event.encoding and not getattr(self.stream, 'encoding', None):
+                self.encoding = self.event.encoding
+            self.write_stream_start()
+            self.state = self.expect_first_document_start
+        else:
+            raise EmitterError("expected StreamStartEvent, but got %s"
+                    % self.event)
+
+    def expect_nothing(self):
+        raise EmitterError("expected nothing, but got %s" % self.event)
+
+    # Document handlers.
+
+    def expect_first_document_start(self):
+        return self.expect_document_start(first=True)
+
+    def expect_document_start(self, first=False):
+        if isinstance(self.event, DocumentStartEvent):
+            if (self.event.version or self.event.tags) and self.open_ended:
+                self.write_indicator(u'...', True)
+                self.write_indent()
+            if self.event.version:
+                version_text = self.prepare_version(self.event.version)
+                self.write_version_directive(version_text)
+            self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy()
+            if self.event.tags:
+                handles = self.event.tags.keys()
+                handles.sort()
+                for handle in handles:
+                    prefix = self.event.tags[handle]
+                    self.tag_prefixes[prefix] = handle
+                    handle_text = self.prepare_tag_handle(handle)
+                    prefix_text = self.prepare_tag_prefix(prefix)
+                    self.write_tag_directive(handle_text, prefix_text)
+            implicit = (first and not self.event.explicit and not self.canonical
+                    and not self.event.version and not self.event.tags
+                    and not self.check_empty_document())
+            if not implicit:
+                self.write_indent()
+                self.write_indicator(u'---', True)
+                if self.canonical:
+                    self.write_indent()
+            self.state = self.expect_document_root
+        elif isinstance(self.event, StreamEndEvent):
+            if self.open_ended:
+                self.write_indicator(u'...', True)
+                self.write_indent()
+            self.write_stream_end()
+            self.state = self.expect_nothing
+        else:
+            raise EmitterError("expected DocumentStartEvent, but got %s"
+                    % self.event)
+
+    def expect_document_end(self):
+        if isinstance(self.event, DocumentEndEvent):
+            self.write_indent()
+            if self.event.explicit:
+                self.write_indicator(u'...', True)
+                self.write_indent()
+            self.flush_stream()
+            self.state = self.expect_document_start
+        else:
+            raise EmitterError("expected DocumentEndEvent, but got %s"
+                    % self.event)
+
+    def expect_document_root(self):
+        self.states.append(self.expect_document_end)
+        self.expect_node(root=True)
+
+    # Node handlers.
+
+    def expect_node(self, root=False, sequence=False, mapping=False,
+            simple_key=False):
+        self.root_context = root
+        self.sequence_context = sequence
+        self.mapping_context = mapping
+        self.simple_key_context = simple_key
+        if isinstance(self.event, AliasEvent):
+            self.expect_alias()
+        elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)):
+            self.process_anchor(u'&')
+            self.process_tag()
+            if isinstance(self.event, ScalarEvent):
+                self.expect_scalar()
+            elif isinstance(self.event, SequenceStartEvent):
+                if self.flow_level or self.canonical or self.event.flow_style   \
+                        or self.check_empty_sequence():
+                    self.expect_flow_sequence()
+                else:
+                    self.expect_block_sequence()
+            elif isinstance(self.event, MappingStartEvent):
+                if self.flow_level or self.canonical or self.event.flow_style   \
+                        or self.check_empty_mapping():
+                    self.expect_flow_mapping()
+                else:
+                    self.expect_block_mapping()
+        else:
+            raise EmitterError("expected NodeEvent, but got %s" % self.event)
+
+    def expect_alias(self):
+        if self.event.anchor is None:
+            raise EmitterError("anchor is not specified for alias")
+        self.process_anchor(u'*')
+        self.state = self.states.pop()
+
+    def expect_scalar(self):
+        self.increase_indent(flow=True)
+        self.process_scalar()
+        self.indent = self.indents.pop()
+        self.state = self.states.pop()
+
+    # Flow sequence handlers.
+
+    def expect_flow_sequence(self):
+        self.write_indicator(u'[', True, whitespace=True)
+        self.flow_level += 1
+        self.increase_indent(flow=True)
+        self.state = self.expect_first_flow_sequence_item
+
+    def expect_first_flow_sequence_item(self):
+        if isinstance(self.event, SequenceEndEvent):
+            self.indent = self.indents.pop()
+            self.flow_level -= 1
+            self.write_indicator(u']', False)
+            self.state = self.states.pop()
+        else:
+            if self.canonical or self.column > self.best_width:
+                self.write_indent()
+            self.states.append(self.expect_flow_sequence_item)
+            self.expect_node(sequence=True)
+
+    def expect_flow_sequence_item(self):
+        if isinstance(self.event, SequenceEndEvent):
+            self.indent = self.indents.pop()
+            self.flow_level -= 1
+            if self.canonical:
+                self.write_indicator(u',', False)
+                self.write_indent()
+            self.write_indicator(u']', False)
+            self.state = self.states.pop()
+        else:
+            self.write_indicator(u',', False)
+            if self.canonical or self.column > self.best_width:
+                self.write_indent()
+            self.states.append(self.expect_flow_sequence_item)
+            self.expect_node(sequence=True)
+
+    # Flow mapping handlers.
+
+    def expect_flow_mapping(self):
+        self.write_indicator(u'{', True, whitespace=True)
+        self.flow_level += 1
+        self.increase_indent(flow=True)
+        self.state = self.expect_first_flow_mapping_key
+
+    def expect_first_flow_mapping_key(self):
+        if isinstance(self.event, MappingEndEvent):
+            self.indent = self.indents.pop()
+            self.flow_level -= 1
+            self.write_indicator(u'}', False)
+            self.state = self.states.pop()
+        else:
+            if self.canonical or self.column > self.best_width:
+                self.write_indent()
+            if not self.canonical and self.check_simple_key():
+                self.states.append(self.expect_flow_mapping_simple_value)
+                self.expect_node(mapping=True, simple_key=True)
+            else:
+                self.write_indicator(u'?', True)
+                self.states.append(self.expect_flow_mapping_value)
+                self.expect_node(mapping=True)
+
+    def expect_flow_mapping_key(self):
+        if isinstance(self.event, MappingEndEvent):
+            self.indent = self.indents.pop()
+            self.flow_level -= 1
+            if self.canonical:
+                self.write_indicator(u',', False)
+                self.write_indent()
+            self.write_indicator(u'}', False)
+            self.state = self.states.pop()
+        else:
+            self.write_indicator(u',', False)
+            if self.canonical or self.column > self.best_width:
+                self.write_indent()
+            if not self.canonical and self.check_simple_key():
+                self.states.append(self.expect_flow_mapping_simple_value)
+                self.expect_node(mapping=True, simple_key=True)
+            else:
+                self.write_indicator(u'?', True)
+                self.states.append(self.expect_flow_mapping_value)
+                self.expect_node(mapping=True)
+
+    def expect_flow_mapping_simple_value(self):
+        self.write_indicator(u':', False)
+        self.states.append(self.expect_flow_mapping_key)
+        self.expect_node(mapping=True)
+
+    def expect_flow_mapping_value(self):
+        if self.canonical or self.column > self.best_width:
+            self.write_indent()
+        self.write_indicator(u':', True)
+        self.states.append(self.expect_flow_mapping_key)
+        self.expect_node(mapping=True)
+
+    # Block sequence handlers.
+
+    def expect_block_sequence(self):
+        indentless = (self.mapping_context and not self.indention)
+        self.increase_indent(flow=False, indentless=indentless)
+        self.state = self.expect_first_block_sequence_item
+
+    def expect_first_block_sequence_item(self):
+        return self.expect_block_sequence_item(first=True)
+
+    def expect_block_sequence_item(self, first=False):
+        if not first and isinstance(self.event, SequenceEndEvent):
+            self.indent = self.indents.pop()
+            self.state = self.states.pop()
+        else:
+            self.write_indent()
+            self.write_indicator(u'-', True, indention=True)
+            self.states.append(self.expect_block_sequence_item)
+            self.expect_node(sequence=True)
+
+    # Block mapping handlers.
+
+    def expect_block_mapping(self):
+        self.increase_indent(flow=False)
+        self.state = self.expect_first_block_mapping_key
+
+    def expect_first_block_mapping_key(self):
+        return self.expect_block_mapping_key(first=True)
+
+    def expect_block_mapping_key(self, first=False):
+        if not first and isinstance(self.event, MappingEndEvent):
+            self.indent = self.indents.pop()
+            self.state = self.states.pop()
+        else:
+            self.write_indent()
+            if self.check_simple_key():
+                self.states.append(self.expect_block_mapping_simple_value)
+                self.expect_node(mapping=True, simple_key=True)
+            else:
+                self.write_indicator(u'?', True, indention=True)
+                self.states.append(self.expect_block_mapping_value)
+                self.expect_node(mapping=True)
+
+    def expect_block_mapping_simple_value(self):
+        self.write_indicator(u':', False)
+        self.states.append(self.expect_block_mapping_key)
+        self.expect_node(mapping=True)
+
+    def expect_block_mapping_value(self):
+        self.write_indent()
+        self.write_indicator(u':', True, indention=True)
+        self.states.append(self.expect_block_mapping_key)
+        self.expect_node(mapping=True)
+
+    # Checkers.
+
+    def check_empty_sequence(self):
+        return (isinstance(self.event, SequenceStartEvent) and self.events
+                and isinstance(self.events[0], SequenceEndEvent))
+
+    def check_empty_mapping(self):
+        return (isinstance(self.event, MappingStartEvent) and self.events
+                and isinstance(self.events[0], MappingEndEvent))
+
+    def check_empty_document(self):
+        if not isinstance(self.event, DocumentStartEvent) or not self.events:
+            return False
+        event = self.events[0]
+        return (isinstance(event, ScalarEvent) and event.anchor is None
+                and event.tag is None and event.implicit and event.value == u'')
+
+    def check_simple_key(self):
+        length = 0
+        if isinstance(self.event, NodeEvent) and self.event.anchor is not None:
+            if self.prepared_anchor is None:
+                self.prepared_anchor = self.prepare_anchor(self.event.anchor)
+            length += len(self.prepared_anchor)
+        if isinstance(self.event, (ScalarEvent, CollectionStartEvent))  \
+                and self.event.tag is not None:
+            if self.prepared_tag is None:
+                self.prepared_tag = self.prepare_tag(self.event.tag)
+            length += len(self.prepared_tag)
+        if isinstance(self.event, ScalarEvent):
+            if self.analysis is None:
+                self.analysis = self.analyze_scalar(self.event.value)
+            length += len(self.analysis.scalar)
+        return (length < 128 and (isinstance(self.event, AliasEvent)
+            or (isinstance(self.event, ScalarEvent)
+                    and not self.analysis.empty and not self.analysis.multiline)
+            or self.check_empty_sequence() or self.check_empty_mapping()))
+
+    # Anchor, Tag, and Scalar processors.
+
+    def process_anchor(self, indicator):
+        if self.event.anchor is None:
+            self.prepared_anchor = None
+            return
+        if self.prepared_anchor is None:
+            self.prepared_anchor = self.prepare_anchor(self.event.anchor)
+        if self.prepared_anchor:
+            self.write_indicator(indicator+self.prepared_anchor, True)
+        self.prepared_anchor = None
+
+    def process_tag(self):
+        tag = self.event.tag
+        if isinstance(self.event, ScalarEvent):
+            if self.style is None:
+                self.style = self.choose_scalar_style()
+            if ((not self.canonical or tag is None) and
+                ((self.style == '' and self.event.implicit[0])
+                        or (self.style != '' and self.event.implicit[1]))):
+                self.prepared_tag = None
+                return
+            if self.event.implicit[0] and tag is None:
+                tag = u'!'
+                self.prepared_tag = None
+        else:
+            if (not self.canonical or tag is None) and self.event.implicit:
+                self.prepared_tag = None
+                return
+        if tag is None:
+            raise EmitterError("tag is not specified")
+        if self.prepared_tag is None:
+            self.prepared_tag = self.prepare_tag(tag)
+        if self.prepared_tag:
+            self.write_indicator(self.prepared_tag, True)
+        self.prepared_tag = None
+
+    def choose_scalar_style(self):
+        if self.analysis is None:
+            self.analysis = self.analyze_scalar(self.event.value)
+        if self.event.style == '"' or self.canonical:
+            return '"'
+        if not self.event.style and self.event.implicit[0]:
+            if (not (self.simple_key_context and
+                    (self.analysis.empty or self.analysis.multiline))
+                and (self.flow_level and self.analysis.allow_flow_plain
+                    or (not self.flow_level and self.analysis.allow_block_plain))):
+                return ''
+        if self.event.style and self.event.style in '|>':
+            if (not self.flow_level and not self.simple_key_context
+                    and self.analysis.allow_block):
+                return self.event.style
+        if not self.event.style or self.event.style == '\'':
+            if (self.analysis.allow_single_quoted and
+                    not (self.simple_key_context and self.analysis.multiline)):
+                return '\''
+        return '"'
+
+    def process_scalar(self):
+        if self.analysis is None:
+            self.analysis = self.analyze_scalar(self.event.value)
+        if self.style is None:
+            self.style = self.choose_scalar_style()
+        split = (not self.simple_key_context)
+        #if self.analysis.multiline and split    \
+        #        and (not self.style or self.style in '\'\"'):
+        #    self.write_indent()
+        if self.style == '"':
+            self.write_double_quoted(self.analysis.scalar, split)
+        elif self.style == '\'':
+            self.write_single_quoted(self.analysis.scalar, split)
+        elif self.style == '>':
+            self.write_folded(self.analysis.scalar)
+        elif self.style == '|':
+            self.write_literal(self.analysis.scalar)
+        else:
+            self.write_plain(self.analysis.scalar, split)
+        self.analysis = None
+        self.style = None
+
+    # Analyzers.
+
+    def prepare_version(self, version):
+        major, minor = version
+        if major != 1:
+            raise EmitterError("unsupported YAML version: %d.%d" % (major, minor))
+        return u'%d.%d' % (major, minor)
+
+    def prepare_tag_handle(self, handle):
+        if not handle:
+            raise EmitterError("tag handle must not be empty")
+        if handle[0] != u'!' or handle[-1] != u'!':
+            raise EmitterError("tag handle must start and end with '!': %r"
+                    % (handle.encode('utf-8')))
+        for ch in handle[1:-1]:
+            if not (u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'  \
+                    or ch in u'-_'):
+                raise EmitterError("invalid character %r in the tag handle: %r"
+                        % (ch.encode('utf-8'), handle.encode('utf-8')))
+        return handle
+
+    def prepare_tag_prefix(self, prefix):
+        if not prefix:
+            raise EmitterError("tag prefix must not be empty")
+        chunks = []
+        start = end = 0
+        if prefix[0] == u'!':
+            end = 1
+        while end < len(prefix):
+            ch = prefix[end]
+            if u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'   \
+                    or ch in u'-;/?!:@&=+$,_.~*\'()[]':
+                end += 1
+            else:
+                if start < end:
+                    chunks.append(prefix[start:end])
+                start = end = end+1
+                data = ch.encode('utf-8')
+                for ch in data:
+                    chunks.append(u'%%%02X' % ord(ch))
+        if start < end:
+            chunks.append(prefix[start:end])
+        return u''.join(chunks)
+
+    def prepare_tag(self, tag):
+        if not tag:
+            raise EmitterError("tag must not be empty")
+        if tag == u'!':
+            return tag
+        handle = None
+        suffix = tag
+        prefixes = self.tag_prefixes.keys()
+        prefixes.sort()
+        for prefix in prefixes:
+            if tag.startswith(prefix)   \
+                    and (prefix == u'!' or len(prefix) < len(tag)):
+                handle = self.tag_prefixes[prefix]
+                suffix = tag[len(prefix):]
+        chunks = []
+        start = end = 0
+        while end < len(suffix):
+            ch = suffix[end]
+            if u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'   \
+                    or ch in u'-;/?:@&=+$,_.~*\'()[]'   \
+                    or (ch == u'!' and handle != u'!'):
+                end += 1
+            else:
+                if start < end:
+                    chunks.append(suffix[start:end])
+                start = end = end+1
+                data = ch.encode('utf-8')
+                for ch in data:
+                    chunks.append(u'%%%02X' % ord(ch))
+        if start < end:
+            chunks.append(suffix[start:end])
+        suffix_text = u''.join(chunks)
+        if handle:
+            return u'%s%s' % (handle, suffix_text)
+        else:
+            return u'!<%s>' % suffix_text
+
+    def prepare_anchor(self, anchor):
+        if not anchor:
+            raise EmitterError("anchor must not be empty")
+        for ch in anchor:
+            if not (u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'  \
+                    or ch in u'-_'):
+                raise EmitterError("invalid character %r in the anchor: %r"
+                        % (ch.encode('utf-8'), anchor.encode('utf-8')))
+        return anchor
+
+    def analyze_scalar(self, scalar):
+
+        # Empty scalar is a special case.
+        if not scalar:
+            return ScalarAnalysis(scalar=scalar, empty=True, multiline=False,
+                    allow_flow_plain=False, allow_block_plain=True,
+                    allow_single_quoted=True, allow_double_quoted=True,
+                    allow_block=False)
+
+        # Indicators and special characters.
+        block_indicators = False
+        flow_indicators = False
+        line_breaks = False
+        special_characters = False
+
+        # Important whitespace combinations.
+        leading_space = False
+        leading_break = False
+        trailing_space = False
+        trailing_break = False
+        break_space = False
+        space_break = False
+
+        # Check document indicators.
+        if scalar.startswith(u'---') or scalar.startswith(u'...'):
+            block_indicators = True
+            flow_indicators = True
+
+        # First character or preceded by a whitespace.
+        preceeded_by_whitespace = True
+
+        # Last character or followed by a whitespace.
+        followed_by_whitespace = (len(scalar) == 1 or
+                scalar[1] in u'\0 \t\r\n\x85\u2028\u2029')
+
+        # The previous character is a space.
+        previous_space = False
+
+        # The previous character is a break.
+        previous_break = False
+
+        index = 0
+        while index < len(scalar):
+            ch = scalar[index]
+
+            # Check for indicators.
+            if index == 0:
+                # Leading indicators are special characters.
+                if ch in u'#,[]{}&*!|>\'\"%@`': 
+                    flow_indicators = True
+                    block_indicators = True
+                if ch in u'?:':
+                    flow_indicators = True
+                    if followed_by_whitespace:
+                        block_indicators = True
+                if ch == u'-' and followed_by_whitespace:
+                    flow_indicators = True
+                    block_indicators = True
+            else:
+                # Some indicators cannot appear within a scalar as well.
+                if ch in u',?[]{}':
+                    flow_indicators = True
+                if ch == u':':
+                    flow_indicators = True
+                    if followed_by_whitespace:
+                        block_indicators = True
+                if ch == u'#' and preceeded_by_whitespace:
+                    flow_indicators = True
+                    block_indicators = True
+
+            # Check for line breaks, special, and unicode characters.
+            if ch in u'\n\x85\u2028\u2029':
+                line_breaks = True
+            if not (ch == u'\n' or u'\x20' <= ch <= u'\x7E'):
+                if (ch == u'\x85' or u'\xA0' <= ch <= u'\uD7FF'
+                        or u'\uE000' <= ch <= u'\uFFFD') and ch != u'\uFEFF':
+                    unicode_characters = True
+                    if not self.allow_unicode:
+                        special_characters = True
+                else:
+                    special_characters = True
+
+            # Detect important whitespace combinations.
+            if ch == u' ':
+                if index == 0:
+                    leading_space = True
+                if index == len(scalar)-1:
+                    trailing_space = True
+                if previous_break:
+                    break_space = True
+                previous_space = True
+                previous_break = False
+            elif ch in u'\n\x85\u2028\u2029':
+                if index == 0:
+                    leading_break = True
+                if index == len(scalar)-1:
+                    trailing_break = True
+                if previous_space:
+                    space_break = True
+                previous_space = False
+                previous_break = True
+            else:
+                previous_space = False
+                previous_break = False
+
+            # Prepare for the next character.
+            index += 1
+            preceeded_by_whitespace = (ch in u'\0 \t\r\n\x85\u2028\u2029')
+            followed_by_whitespace = (index+1 >= len(scalar) or
+                    scalar[index+1] in u'\0 \t\r\n\x85\u2028\u2029')
+
+        # Let's decide what styles are allowed.
+        allow_flow_plain = True
+        allow_block_plain = True
+        allow_single_quoted = True
+        allow_double_quoted = True
+        allow_block = True
+
+        # Leading and trailing whitespaces are bad for plain scalars.
+        if (leading_space or leading_break
+                or trailing_space or trailing_break):
+            allow_flow_plain = allow_block_plain = False
+
+        # We do not permit trailing spaces for block scalars.
+        if trailing_space:
+            allow_block = False
+
+        # Spaces at the beginning of a new line are only acceptable for block
+        # scalars.
+        if break_space:
+            allow_flow_plain = allow_block_plain = allow_single_quoted = False
+
+        # Spaces followed by breaks, as well as special character are only
+        # allowed for double quoted scalars.
+        if space_break or special_characters:
+            allow_flow_plain = allow_block_plain =  \
+            allow_single_quoted = allow_block = False
+
+        # Although the plain scalar writer supports breaks, we never emit
+        # multiline plain scalars.
+        if line_breaks:
+            allow_flow_plain = allow_block_plain = False
+
+        # Flow indicators are forbidden for flow plain scalars.
+        if flow_indicators:
+            allow_flow_plain = False
+
+        # Block indicators are forbidden for block plain scalars.
+        if block_indicators:
+            allow_block_plain = False
+
+        return ScalarAnalysis(scalar=scalar,
+                empty=False, multiline=line_breaks,
+                allow_flow_plain=allow_flow_plain,
+                allow_block_plain=allow_block_plain,
+                allow_single_quoted=allow_single_quoted,
+                allow_double_quoted=allow_double_quoted,
+                allow_block=allow_block)
+
+    # Writers.
+
+    def flush_stream(self):
+        if hasattr(self.stream, 'flush'):
+            self.stream.flush()
+
+    def write_stream_start(self):
+        # Write BOM if needed.
+        if self.encoding and self.encoding.startswith('utf-16'):
+            self.stream.write(u'\uFEFF'.encode(self.encoding))
+
+    def write_stream_end(self):
+        self.flush_stream()
+
+    def write_indicator(self, indicator, need_whitespace,
+            whitespace=False, indention=False):
+        if self.whitespace or not need_whitespace:
+            data = indicator
+        else:
+            data = u' '+indicator
+        self.whitespace = whitespace
+        self.indention = self.indention and indention
+        self.column += len(data)
+        self.open_ended = False
+        if self.encoding:
+            data = data.encode(self.encoding)
+        self.stream.write(data)
+
+    def write_indent(self):
+        indent = self.indent or 0
+        if not self.indention or self.column > indent   \
+                or (self.column == indent and not self.whitespace):
+            self.write_line_break()
+        if self.column < indent:
+            self.whitespace = True
+            data = u' '*(indent-self.column)
+            self.column = indent
+            if self.encoding:
+                data = data.encode(self.encoding)
+            self.stream.write(data)
+
+    def write_line_break(self, data=None):
+        if data is None:
+            data = self.best_line_break
+        self.whitespace = True
+        self.indention = True
+        self.line += 1
+        self.column = 0
+        if self.encoding:
+            data = data.encode(self.encoding)
+        self.stream.write(data)
+
+    def write_version_directive(self, version_text):
+        data = u'%%YAML %s' % version_text
+        if self.encoding:
+            data = data.encode(self.encoding)
+        self.stream.write(data)
+        self.write_line_break()
+
+    def write_tag_directive(self, handle_text, prefix_text):
+        data = u'%%TAG %s %s' % (handle_text, prefix_text)
+        if self.encoding:
+            data = data.encode(self.encoding)
+        self.stream.write(data)
+        self.write_line_break()
+
+    # Scalar streams.
+
+    def write_single_quoted(self, text, split=True):
+        self.write_indicator(u'\'', True)
+        spaces = False
+        breaks = False
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if spaces:
+                if ch is None or ch != u' ':
+                    if start+1 == end and self.column > self.best_width and split   \
+                            and start != 0 and end != len(text):
+                        self.write_indent()
+                    else:
+                        data = text[start:end]
+                        self.column += len(data)
+                        if self.encoding:
+                            data = data.encode(self.encoding)
+                        self.stream.write(data)
+                    start = end
+            elif breaks:
+                if ch is None or ch not in u'\n\x85\u2028\u2029':
+                    if text[start] == u'\n':
+                        self.write_line_break()
+                    for br in text[start:end]:
+                        if br == u'\n':
+                            self.write_line_break()
+                        else:
+                            self.write_line_break(br)
+                    self.write_indent()
+                    start = end
+            else:
+                if ch is None or ch in u' \n\x85\u2028\u2029' or ch == u'\'':
+                    if start < end:
+                        data = text[start:end]
+                        self.column += len(data)
+                        if self.encoding:
+                            data = data.encode(self.encoding)
+                        self.stream.write(data)
+                        start = end
+            if ch == u'\'':
+                data = u'\'\''
+                self.column += 2
+                if self.encoding:
+                    data = data.encode(self.encoding)
+                self.stream.write(data)
+                start = end + 1
+            if ch is not None:
+                spaces = (ch == u' ')
+                breaks = (ch in u'\n\x85\u2028\u2029')
+            end += 1
+        self.write_indicator(u'\'', False)
+
+    ESCAPE_REPLACEMENTS = {
+        u'\0':      u'0',
+        u'\x07':    u'a',
+        u'\x08':    u'b',
+        u'\x09':    u't',
+        u'\x0A':    u'n',
+        u'\x0B':    u'v',
+        u'\x0C':    u'f',
+        u'\x0D':    u'r',
+        u'\x1B':    u'e',
+        u'\"':      u'\"',
+        u'\\':      u'\\',
+        u'\x85':    u'N',
+        u'\xA0':    u'_',
+        u'\u2028':  u'L',
+        u'\u2029':  u'P',
+    }
+
+    def write_double_quoted(self, text, split=True):
+        self.write_indicator(u'"', True)
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if ch is None or ch in u'"\\\x85\u2028\u2029\uFEFF' \
+                    or not (u'\x20' <= ch <= u'\x7E'
+                        or (self.allow_unicode
+                            and (u'\xA0' <= ch <= u'\uD7FF'
+                                or u'\uE000' <= ch <= u'\uFFFD'))):
+                if start < end:
+                    data = text[start:end]
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    start = end
+                if ch is not None:
+                    if ch in self.ESCAPE_REPLACEMENTS:
+                        data = u'\\'+self.ESCAPE_REPLACEMENTS[ch]
+                    elif ch <= u'\xFF':
+                        data = u'\\x%02X' % ord(ch)
+                    elif ch <= u'\uFFFF':
+                        data = u'\\u%04X' % ord(ch)
+                    else:
+                        data = u'\\U%08X' % ord(ch)
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    start = end+1
+            if 0 < end < len(text)-1 and (ch == u' ' or start >= end)   \
+                    and self.column+(end-start) > self.best_width and split:
+                data = text[start:end]+u'\\'
+                if start < end:
+                    start = end
+                self.column += len(data)
+                if self.encoding:
+                    data = data.encode(self.encoding)
+                self.stream.write(data)
+                self.write_indent()
+                self.whitespace = False
+                self.indention = False
+                if text[start] == u' ':
+                    data = u'\\'
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+            end += 1
+        self.write_indicator(u'"', False)
+
+    def determine_block_hints(self, text):
+        hints = u''
+        if text:
+            if text[0] in u' \n\x85\u2028\u2029':
+                hints += unicode(self.best_indent)
+            if text[-1] not in u'\n\x85\u2028\u2029':
+                hints += u'-'
+            elif len(text) == 1 or text[-2] in u'\n\x85\u2028\u2029':
+                hints += u'+'
+        return hints
+
+    def write_folded(self, text):
+        hints = self.determine_block_hints(text)
+        self.write_indicator(u'>'+hints, True)
+        if hints[-1:] == u'+':
+            self.open_ended = True
+        self.write_line_break()
+        leading_space = True
+        spaces = False
+        breaks = True
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if breaks:
+                if ch is None or ch not in u'\n\x85\u2028\u2029':
+                    if not leading_space and ch is not None and ch != u' '  \
+                            and text[start] == u'\n':
+                        self.write_line_break()
+                    leading_space = (ch == u' ')
+                    for br in text[start:end]:
+                        if br == u'\n':
+                            self.write_line_break()
+                        else:
+                            self.write_line_break(br)
+                    if ch is not None:
+                        self.write_indent()
+                    start = end
+            elif spaces:
+                if ch != u' ':
+                    if start+1 == end and self.column > self.best_width:
+                        self.write_indent()
+                    else:
+                        data = text[start:end]
+                        self.column += len(data)
+                        if self.encoding:
+                            data = data.encode(self.encoding)
+                        self.stream.write(data)
+                    start = end
+            else:
+                if ch is None or ch in u' \n\x85\u2028\u2029':
+                    data = text[start:end]
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    if ch is None:
+                        self.write_line_break()
+                    start = end
+            if ch is not None:
+                breaks = (ch in u'\n\x85\u2028\u2029')
+                spaces = (ch == u' ')
+            end += 1
+
+    def write_literal(self, text):
+        hints = self.determine_block_hints(text)
+        self.write_indicator(u'|'+hints, True)
+        if hints[-1:] == u'+':
+            self.open_ended = True
+        self.write_line_break()
+        breaks = True
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if breaks:
+                if ch is None or ch not in u'\n\x85\u2028\u2029':
+                    for br in text[start:end]:
+                        if br == u'\n':
+                            self.write_line_break()
+                        else:
+                            self.write_line_break(br)
+                    if ch is not None:
+                        self.write_indent()
+                    start = end
+            else:
+                if ch is None or ch in u'\n\x85\u2028\u2029':
+                    data = text[start:end]
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    if ch is None:
+                        self.write_line_break()
+                    start = end
+            if ch is not None:
+                breaks = (ch in u'\n\x85\u2028\u2029')
+            end += 1
+
+    def write_plain(self, text, split=True):
+        if self.root_context:
+            self.open_ended = True
+        if not text:
+            return
+        if not self.whitespace:
+            data = u' '
+            self.column += len(data)
+            if self.encoding:
+                data = data.encode(self.encoding)
+            self.stream.write(data)
+        self.whitespace = False
+        self.indention = False
+        spaces = False
+        breaks = False
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if spaces:
+                if ch != u' ':
+                    if start+1 == end and self.column > self.best_width and split:
+                        self.write_indent()
+                        self.whitespace = False
+                        self.indention = False
+                    else:
+                        data = text[start:end]
+                        self.column += len(data)
+                        if self.encoding:
+                            data = data.encode(self.encoding)
+                        self.stream.write(data)
+                    start = end
+            elif breaks:
+                if ch not in u'\n\x85\u2028\u2029':
+                    if text[start] == u'\n':
+                        self.write_line_break()
+                    for br in text[start:end]:
+                        if br == u'\n':
+                            self.write_line_break()
+                        else:
+                            self.write_line_break(br)
+                    self.write_indent()
+                    self.whitespace = False
+                    self.indention = False
+                    start = end
+            else:
+                if ch is None or ch in u' \n\x85\u2028\u2029':
+                    data = text[start:end]
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    start = end
+            if ch is not None:
+                spaces = (ch == u' ')
+                breaks = (ch in u'\n\x85\u2028\u2029')
+            end += 1
+
diff --git a/pynxc/yaml/error.py b/pynxc/yaml/error.py
new file mode 100644
index 0000000..577686d
--- /dev/null
+++ b/pynxc/yaml/error.py
@@ -0,0 +1,75 @@
+
+__all__ = ['Mark', 'YAMLError', 'MarkedYAMLError']
+
+class Mark(object):
+
+    def __init__(self, name, index, line, column, buffer, pointer):
+        self.name = name
+        self.index = index
+        self.line = line
+        self.column = column
+        self.buffer = buffer
+        self.pointer = pointer
+
+    def get_snippet(self, indent=4, max_length=75):
+        if self.buffer is None:
+            return None
+        head = ''
+        start = self.pointer
+        while start > 0 and self.buffer[start-1] not in u'\0\r\n\x85\u2028\u2029':
+            start -= 1
+            if self.pointer-start > max_length/2-1:
+                head = ' ... '
+                start += 5
+                break
+        tail = ''
+        end = self.pointer
+        while end < len(self.buffer) and self.buffer[end] not in u'\0\r\n\x85\u2028\u2029':
+            end += 1
+            if end-self.pointer > max_length/2-1:
+                tail = ' ... '
+                end -= 5
+                break
+        snippet = self.buffer[start:end].encode('utf-8')
+        return ' '*indent + head + snippet + tail + '\n'  \
+                + ' '*(indent+self.pointer-start+len(head)) + '^'
+
+    def __str__(self):
+        snippet = self.get_snippet()
+        where = "  in \"%s\", line %d, column %d"   \
+                % (self.name, self.line+1, self.column+1)
+        if snippet is not None:
+            where += ":\n"+snippet
+        return where
+
+class YAMLError(Exception):
+    pass
+
+class MarkedYAMLError(YAMLError):
+
+    def __init__(self, context=None, context_mark=None,
+            problem=None, problem_mark=None, note=None):
+        self.context = context
+        self.context_mark = context_mark
+        self.problem = problem
+        self.problem_mark = problem_mark
+        self.note = note
+
+    def __str__(self):
+        lines = []
+        if self.context is not None:
+            lines.append(self.context)
+        if self.context_mark is not None  \
+            and (self.problem is None or self.problem_mark is None
+                    or self.context_mark.name != self.problem_mark.name
+                    or self.context_mark.line != self.problem_mark.line
+                    or self.context_mark.column != self.problem_mark.column):
+            lines.append(str(self.context_mark))
+        if self.problem is not None:
+            lines.append(self.problem)
+        if self.problem_mark is not None:
+            lines.append(str(self.problem_mark))
+        if self.note is not None:
+            lines.append(self.note)
+        return '\n'.join(lines)
+
diff --git a/pynxc/yaml/events.py b/pynxc/yaml/events.py
new file mode 100644
index 0000000..f79ad38
--- /dev/null
+++ b/pynxc/yaml/events.py
@@ -0,0 +1,86 @@
+
+# Abstract classes.
+
+class Event(object):
+    def __init__(self, start_mark=None, end_mark=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+    def __repr__(self):
+        attributes = [key for key in ['anchor', 'tag', 'implicit', 'value']
+                if hasattr(self, key)]
+        arguments = ', '.join(['%s=%r' % (key, getattr(self, key))
+                for key in attributes])
+        return '%s(%s)' % (self.__class__.__name__, arguments)
+
+class NodeEvent(Event):
+    def __init__(self, anchor, start_mark=None, end_mark=None):
+        self.anchor = anchor
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class CollectionStartEvent(NodeEvent):
+    def __init__(self, anchor, tag, implicit, start_mark=None, end_mark=None,
+            flow_style=None):
+        self.anchor = anchor
+        self.tag = tag
+        self.implicit = implicit
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.flow_style = flow_style
+
+class CollectionEndEvent(Event):
+    pass
+
+# Implementations.
+
+class StreamStartEvent(Event):
+    def __init__(self, start_mark=None, end_mark=None, encoding=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.encoding = encoding
+
+class StreamEndEvent(Event):
+    pass
+
+class DocumentStartEvent(Event):
+    def __init__(self, start_mark=None, end_mark=None,
+            explicit=None, version=None, tags=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.explicit = explicit
+        self.version = version
+        self.tags = tags
+
+class DocumentEndEvent(Event):
+    def __init__(self, start_mark=None, end_mark=None,
+            explicit=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.explicit = explicit
+
+class AliasEvent(NodeEvent):
+    pass
+
+class ScalarEvent(NodeEvent):
+    def __init__(self, anchor, tag, implicit, value,
+            start_mark=None, end_mark=None, style=None):
+        self.anchor = anchor
+        self.tag = tag
+        self.implicit = implicit
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.style = style
+
+class SequenceStartEvent(CollectionStartEvent):
+    pass
+
+class SequenceEndEvent(CollectionEndEvent):
+    pass
+
+class MappingStartEvent(CollectionStartEvent):
+    pass
+
+class MappingEndEvent(CollectionEndEvent):
+    pass
+
diff --git a/pynxc/yaml/loader.py b/pynxc/yaml/loader.py
new file mode 100644
index 0000000..293ff46
--- /dev/null
+++ b/pynxc/yaml/loader.py
@@ -0,0 +1,40 @@
+
+__all__ = ['BaseLoader', 'SafeLoader', 'Loader']
+
+from reader import *
+from scanner import *
+from parser import *
+from composer import *
+from constructor import *
+from resolver import *
+
+class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver):
+
+    def __init__(self, stream):
+        Reader.__init__(self, stream)
+        Scanner.__init__(self)
+        Parser.__init__(self)
+        Composer.__init__(self)
+        BaseConstructor.__init__(self)
+        BaseResolver.__init__(self)
+
+class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver):
+
+    def __init__(self, stream):
+        Reader.__init__(self, stream)
+        Scanner.__init__(self)
+        Parser.__init__(self)
+        Composer.__init__(self)
+        SafeConstructor.__init__(self)
+        Resolver.__init__(self)
+
+class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver):
+
+    def __init__(self, stream):
+        Reader.__init__(self, stream)
+        Scanner.__init__(self)
+        Parser.__init__(self)
+        Composer.__init__(self)
+        Constructor.__init__(self)
+        Resolver.__init__(self)
+
diff --git a/pynxc/yaml/nodes.py b/pynxc/yaml/nodes.py
new file mode 100644
index 0000000..c4f070c
--- /dev/null
+++ b/pynxc/yaml/nodes.py
@@ -0,0 +1,49 @@
+
+class Node(object):
+    def __init__(self, tag, value, start_mark, end_mark):
+        self.tag = tag
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+    def __repr__(self):
+        value = self.value
+        #if isinstance(value, list):
+        #    if len(value) == 0:
+        #        value = '<empty>'
+        #    elif len(value) == 1:
+        #        value = '<1 item>'
+        #    else:
+        #        value = '<%d items>' % len(value)
+        #else:
+        #    if len(value) > 75:
+        #        value = repr(value[:70]+u' ... ')
+        #    else:
+        #        value = repr(value)
+        value = repr(value)
+        return '%s(tag=%r, value=%s)' % (self.__class__.__name__, self.tag, value)
+
+class ScalarNode(Node):
+    id = 'scalar'
+    def __init__(self, tag, value,
+            start_mark=None, end_mark=None, style=None):
+        self.tag = tag
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.style = style
+
+class CollectionNode(Node):
+    def __init__(self, tag, value,
+            start_mark=None, end_mark=None, flow_style=None):
+        self.tag = tag
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.flow_style = flow_style
+
+class SequenceNode(CollectionNode):
+    id = 'sequence'
+
+class MappingNode(CollectionNode):
+    id = 'mapping'
+
diff --git a/pynxc/yaml/parser.py b/pynxc/yaml/parser.py
new file mode 100644
index 0000000..b6a7416
--- /dev/null
+++ b/pynxc/yaml/parser.py
@@ -0,0 +1,584 @@
+
+# The following YAML grammar is LL(1) and is parsed by a recursive descent
+# parser.
+#
+# stream            ::= STREAM-START implicit_document? explicit_document* STREAM-END
+# implicit_document ::= block_node DOCUMENT-END*
+# explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+# block_node_or_indentless_sequence ::=
+#                       ALIAS
+#                       | properties (block_content | indentless_block_sequence)?
+#                       | block_content
+#                       | indentless_block_sequence
+# block_node        ::= ALIAS
+#                       | properties block_content?
+#                       | block_content
+# flow_node         ::= ALIAS
+#                       | properties flow_content?
+#                       | flow_content
+# properties        ::= TAG ANCHOR? | ANCHOR TAG?
+# block_content     ::= block_collection | flow_collection | SCALAR
+# flow_content      ::= flow_collection | SCALAR
+# block_collection  ::= block_sequence | block_mapping
+# flow_collection   ::= flow_sequence | flow_mapping
+# block_sequence    ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+# indentless_sequence   ::= (BLOCK-ENTRY block_node?)+
+# block_mapping     ::= BLOCK-MAPPING_START
+#                       ((KEY block_node_or_indentless_sequence?)?
+#                       (VALUE block_node_or_indentless_sequence?)?)*
+#                       BLOCK-END
+# flow_sequence     ::= FLOW-SEQUENCE-START
+#                       (flow_sequence_entry FLOW-ENTRY)*
+#                       flow_sequence_entry?
+#                       FLOW-SEQUENCE-END
+# flow_sequence_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+# flow_mapping      ::= FLOW-MAPPING-START
+#                       (flow_mapping_entry FLOW-ENTRY)*
+#                       flow_mapping_entry?
+#                       FLOW-MAPPING-END
+# flow_mapping_entry    ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+#
+# FIRST sets:
+#
+# stream: { STREAM-START }
+# explicit_document: { DIRECTIVE DOCUMENT-START }
+# implicit_document: FIRST(block_node)
+# block_node: { ALIAS TAG ANCHOR SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# flow_node: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# block_content: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR }
+# flow_content: { FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR }
+# block_collection: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START }
+# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# block_sequence: { BLOCK-SEQUENCE-START }
+# block_mapping: { BLOCK-MAPPING-START }
+# block_node_or_indentless_sequence: { ALIAS ANCHOR TAG SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START BLOCK-ENTRY }
+# indentless_sequence: { ENTRY }
+# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# flow_sequence: { FLOW-SEQUENCE-START }
+# flow_mapping: { FLOW-MAPPING-START }
+# flow_sequence_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY }
+# flow_mapping_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY }
+
+__all__ = ['Parser', 'ParserError']
+
+from error import MarkedYAMLError
+from tokens import *
+from events import *
+from scanner import *
+
+class ParserError(MarkedYAMLError):
+    pass
+
+class Parser(object):
+    # Since writing a recursive-descendant parser is a straightforward task, we
+    # do not give many comments here.
+
+    DEFAULT_TAGS = {
+        u'!':   u'!',
+        u'!!':  u'tag:yaml.org,2002:',
+    }
+
+    def __init__(self):
+        self.current_event = None
+        self.yaml_version = None
+        self.tag_handles = {}
+        self.states = []
+        self.marks = []
+        self.state = self.parse_stream_start
+
+    def check_event(self, *choices):
+        # Check the type of the next event.
+        if self.current_event is None:
+            if self.state:
+                self.current_event = self.state()
+        if self.current_event is not None:
+            if not choices:
+                return True
+            for choice in choices:
+                if isinstance(self.current_event, choice):
+                    return True
+        return False
+
+    def peek_event(self):
+        # Get the next event.
+        if self.current_event is None:
+            if self.state:
+                self.current_event = self.state()
+        return self.current_event
+
+    def get_event(self):
+        # Get the next event and proceed further.
+        if self.current_event is None:
+            if self.state:
+                self.current_event = self.state()
+        value = self.current_event
+        self.current_event = None
+        return value
+
+    # stream    ::= STREAM-START implicit_document? explicit_document* STREAM-END
+    # implicit_document ::= block_node DOCUMENT-END*
+    # explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+
+    def parse_stream_start(self):
+
+        # Parse the stream start.
+        token = self.get_token()
+        event = StreamStartEvent(token.start_mark, token.end_mark,
+                encoding=token.encoding)
+
+        # Prepare the next state.
+        self.state = self.parse_implicit_document_start
+
+        return event
+
+    def parse_implicit_document_start(self):
+
+        # Parse an implicit document.
+        if not self.check_token(DirectiveToken, DocumentStartToken,
+                StreamEndToken):
+            self.tag_handles = self.DEFAULT_TAGS
+            token = self.peek_token()
+            start_mark = end_mark = token.start_mark
+            event = DocumentStartEvent(start_mark, end_mark,
+                    explicit=False)
+
+            # Prepare the next state.
+            self.states.append(self.parse_document_end)
+            self.state = self.parse_block_node
+
+            return event
+
+        else:
+            return self.parse_document_start()
+
+    def parse_document_start(self):
+
+        # Parse any extra document end indicators.
+        while self.check_token(DocumentEndToken):
+            self.get_token()
+
+        # Parse an explicit document.
+        if not self.check_token(StreamEndToken):
+            token = self.peek_token()
+            start_mark = token.start_mark
+            version, tags = self.process_directives()
+            if not self.check_token(DocumentStartToken):
+                raise ParserError(None, None,
+                        "expected '<document start>', but found %r"
+                        % self.peek_token().id,
+                        self.peek_token().start_mark)
+            token = self.get_token()
+            end_mark = token.end_mark
+            event = DocumentStartEvent(start_mark, end_mark,
+                    explicit=True, version=version, tags=tags)
+            self.states.append(self.parse_document_end)
+            self.state = self.parse_document_content
+        else:
+            # Parse the end of the stream.
+            token = self.get_token()
+            event = StreamEndEvent(token.start_mark, token.end_mark)
+            assert not self.states
+            assert not self.marks
+            self.state = None
+        return event
+
+    def parse_document_end(self):
+
+        # Parse the document end.
+        token = self.peek_token()
+        start_mark = end_mark = token.start_mark
+        explicit = False
+        if self.check_token(DocumentEndToken):
+            token = self.get_token()
+            end_mark = token.end_mark
+            explicit = True
+        event = DocumentEndEvent(start_mark, end_mark,
+                explicit=explicit)
+
+        # Prepare the next state.
+        self.state = self.parse_document_start
+
+        return event
+
+    def parse_document_content(self):
+        if self.check_token(DirectiveToken,
+                DocumentStartToken, DocumentEndToken, StreamEndToken):
+            event = self.process_empty_scalar(self.peek_token().start_mark)
+            self.state = self.states.pop()
+            return event
+        else:
+            return self.parse_block_node()
+
+    def process_directives(self):
+        self.yaml_version = None
+        self.tag_handles = {}
+        while self.check_token(DirectiveToken):
+            token = self.get_token()
+            if token.name == u'YAML':
+                if self.yaml_version is not None:
+                    raise ParserError(None, None,
+                            "found duplicate YAML directive", token.start_mark)
+                major, minor = token.value
+                if major != 1:
+                    raise ParserError(None, None,
+                            "found incompatible YAML document (version 1.* is required)",
+                            token.start_mark)
+                self.yaml_version = token.value
+            elif token.name == u'TAG':
+                handle, prefix = token.value
+                if handle in self.tag_handles:
+                    raise ParserError(None, None,
+                            "duplicate tag handle %r" % handle.encode('utf-8'),
+                            token.start_mark)
+                self.tag_handles[handle] = prefix
+        if self.tag_handles:
+            value = self.yaml_version, self.tag_handles.copy()
+        else:
+            value = self.yaml_version, None
+        for key in self.DEFAULT_TAGS:
+            if key not in self.tag_handles:
+                self.tag_handles[key] = self.DEFAULT_TAGS[key]
+        return value
+
+    # block_node_or_indentless_sequence ::= ALIAS
+    #               | properties (block_content | indentless_block_sequence)?
+    #               | block_content
+    #               | indentless_block_sequence
+    # block_node    ::= ALIAS
+    #                   | properties block_content?
+    #                   | block_content
+    # flow_node     ::= ALIAS
+    #                   | properties flow_content?
+    #                   | flow_content
+    # properties    ::= TAG ANCHOR? | ANCHOR TAG?
+    # block_content     ::= block_collection | flow_collection | SCALAR
+    # flow_content      ::= flow_collection | SCALAR
+    # block_collection  ::= block_sequence | block_mapping
+    # flow_collection   ::= flow_sequence | flow_mapping
+
+    def parse_block_node(self):
+        return self.parse_node(block=True)
+
+    def parse_flow_node(self):
+        return self.parse_node()
+
+    def parse_block_node_or_indentless_sequence(self):
+        return self.parse_node(block=True, indentless_sequence=True)
+
+    def parse_node(self, block=False, indentless_sequence=False):
+        if self.check_token(AliasToken):
+            token = self.get_token()
+            event = AliasEvent(token.value, token.start_mark, token.end_mark)
+            self.state = self.states.pop()
+        else:
+            anchor = None
+            tag = None
+            start_mark = end_mark = tag_mark = None
+            if self.check_token(AnchorToken):
+                token = self.get_token()
+                start_mark = token.start_mark
+                end_mark = token.end_mark
+                anchor = token.value
+                if self.check_token(TagToken):
+                    token = self.get_token()
+                    tag_mark = token.start_mark
+                    end_mark = token.end_mark
+                    tag = token.value
+            elif self.check_token(TagToken):
+                token = self.get_token()
+                start_mark = tag_mark = token.start_mark
+                end_mark = token.end_mark
+                tag = token.value
+                if self.check_token(AnchorToken):
+                    token = self.get_token()
+                    end_mark = token.end_mark
+                    anchor = token.value
+            if tag is not None:
+                handle, suffix = tag
+                if handle is not None:
+                    if handle not in self.tag_handles:
+                        raise ParserError("while parsing a node", start_mark,
+                                "found undefined tag handle %r" % handle.encode('utf-8'),
+                                tag_mark)
+                    tag = self.tag_handles[handle]+suffix
+                else:
+                    tag = suffix
+            #if tag == u'!':
+            #    raise ParserError("while parsing a node", start_mark,
+            #            "found non-specific tag '!'", tag_mark,
+            #            "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' and share your opinion.")
+            if start_mark is None:
+                start_mark = end_mark = self.peek_token().start_mark
+            event = None
+            implicit = (tag is None or tag == u'!')
+            if indentless_sequence and self.check_token(BlockEntryToken):
+                end_mark = self.peek_token().end_mark
+                event = SequenceStartEvent(anchor, tag, implicit,
+                        start_mark, end_mark)
+                self.state = self.parse_indentless_sequence_entry
+            else:
+                if self.check_token(ScalarToken):
+                    token = self.get_token()
+                    end_mark = token.end_mark
+                    if (token.plain and tag is None) or tag == u'!':
+                        implicit = (True, False)
+                    elif tag is None:
+                        implicit = (False, True)
+                    else:
+                        implicit = (False, False)
+                    event = ScalarEvent(anchor, tag, implicit, token.value,
+                            start_mark, end_mark, style=token.style)
+                    self.state = self.states.pop()
+                elif self.check_token(FlowSequenceStartToken):
+                    end_mark = self.peek_token().end_mark
+                    event = SequenceStartEvent(anchor, tag, implicit,
+                            start_mark, end_mark, flow_style=True)
+                    self.state = self.parse_flow_sequence_first_entry
+                elif self.check_token(FlowMappingStartToken):
+                    end_mark = self.peek_token().end_mark
+                    event = MappingStartEvent(anchor, tag, implicit,
+                            start_mark, end_mark, flow_style=True)
+                    self.state = self.parse_flow_mapping_first_key
+                elif block and self.check_token(BlockSequenceStartToken):
+                    end_mark = self.peek_token().start_mark
+                    event = SequenceStartEvent(anchor, tag, implicit,
+                            start_mark, end_mark, flow_style=False)
+                    self.state = self.parse_block_sequence_first_entry
+                elif block and self.check_token(BlockMappingStartToken):
+                    end_mark = self.peek_token().start_mark
+                    event = MappingStartEvent(anchor, tag, implicit,
+                            start_mark, end_mark, flow_style=False)
+                    self.state = self.parse_block_mapping_first_key
+                elif anchor is not None or tag is not None:
+                    # Empty scalars are allowed even if a tag or an anchor is
+                    # specified.
+                    event = ScalarEvent(anchor, tag, (implicit, False), u'',
+                            start_mark, end_mark)
+                    self.state = self.states.pop()
+                else:
+                    if block:
+                        node = 'block'
+                    else:
+                        node = 'flow'
+                    token = self.peek_token()
+                    raise ParserError("while parsing a %s node" % node, start_mark,
+                            "expected the node content, but found %r" % token.id,
+                            token.start_mark)
+        return event
+
+    # block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+
+    def parse_block_sequence_first_entry(self):
+        token = self.get_token()
+        self.marks.append(token.start_mark)
+        return self.parse_block_sequence_entry()
+
+    def parse_block_sequence_entry(self):
+        if self.check_token(BlockEntryToken):
+            token = self.get_token()
+            if not self.check_token(BlockEntryToken, BlockEndToken):
+                self.states.append(self.parse_block_sequence_entry)
+                return self.parse_block_node()
+            else:
+                self.state = self.parse_block_sequence_entry
+                return self.process_empty_scalar(token.end_mark)
+        if not self.check_token(BlockEndToken):
+            token = self.peek_token()
+            raise ParserError("while parsing a block collection", self.marks[-1],
+                    "expected <block end>, but found %r" % token.id, token.start_mark)
+        token = self.get_token()
+        event = SequenceEndEvent(token.start_mark, token.end_mark)
+        self.state = self.states.pop()
+        self.marks.pop()
+        return event
+
+    # indentless_sequence ::= (BLOCK-ENTRY block_node?)+
+
+    def parse_indentless_sequence_entry(self):
+        if self.check_token(BlockEntryToken):
+            token = self.get_token()
+            if not self.check_token(BlockEntryToken,
+                    KeyToken, ValueToken, BlockEndToken):
+                self.states.append(self.parse_indentless_sequence_entry)
+                return self.parse_block_node()
+            else:
+                self.state = self.parse_indentless_sequence_entry
+                return self.process_empty_scalar(token.end_mark)
+        token = self.peek_token()
+        event = SequenceEndEvent(token.start_mark, token.start_mark)
+        self.state = self.states.pop()
+        return event
+
+    # block_mapping     ::= BLOCK-MAPPING_START
+    #                       ((KEY block_node_or_indentless_sequence?)?
+    #                       (VALUE block_node_or_indentless_sequence?)?)*
+    #                       BLOCK-END
+
+    def parse_block_mapping_first_key(self):
+        token = self.get_token()
+        self.marks.append(token.start_mark)
+        return self.parse_block_mapping_key()
+
+    def parse_block_mapping_key(self):
+        if self.check_token(KeyToken):
+            token = self.get_token()
+            if not self.check_token(KeyToken, ValueToken, BlockEndToken):
+                self.states.append(self.parse_block_mapping_value)
+                return self.parse_block_node_or_indentless_sequence()
+            else:
+                self.state = self.parse_block_mapping_value
+                return self.process_empty_scalar(token.end_mark)
+        if not self.check_token(BlockEndToken):
+            token = self.peek_token()
+            raise ParserError("while parsing a block mapping", self.marks[-1],
+                    "expected <block end>, but found %r" % token.id, token.start_mark)
+        token = self.get_token()
+        event = MappingEndEvent(token.start_mark, token.end_mark)
+        self.state = self.states.pop()
+        self.marks.pop()
+        return event
+
+    def parse_block_mapping_value(self):
+        if self.check_token(ValueToken):
+            token = self.get_token()
+            if not self.check_token(KeyToken, ValueToken, BlockEndToken):
+                self.states.append(self.parse_block_mapping_key)
+                return self.parse_block_node_or_indentless_sequence()
+            else:
+                self.state = self.parse_block_mapping_key
+                return self.process_empty_scalar(token.end_mark)
+        else:
+            self.state = self.parse_block_mapping_key
+            token = self.peek_token()
+            return self.process_empty_scalar(token.start_mark)
+
+    # flow_sequence     ::= FLOW-SEQUENCE-START
+    #                       (flow_sequence_entry FLOW-ENTRY)*
+    #                       flow_sequence_entry?
+    #                       FLOW-SEQUENCE-END
+    # flow_sequence_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+    #
+    # Note that while production rules for both flow_sequence_entry and
+    # flow_mapping_entry are equal, their interpretations are different.
+    # For `flow_sequence_entry`, the part `KEY flow_node? (VALUE flow_node?)?`
+    # generate an inline mapping (set syntax).
+
+    def parse_flow_sequence_first_entry(self):
+        token = self.get_token()
+        self.marks.append(token.start_mark)
+        return self.parse_flow_sequence_entry(first=True)
+
+    def parse_flow_sequence_entry(self, first=False):
+        if not self.check_token(FlowSequenceEndToken):
+            if not first:
+                if self.check_token(FlowEntryToken):
+                    self.get_token()
+                else:
+                    token = self.peek_token()
+                    raise ParserError("while parsing a flow sequence", self.marks[-1],
+                            "expected ',' or ']', but got %r" % token.id, token.start_mark)
+            
+            if self.check_token(KeyToken):
+                token = self.peek_token()
+                event = MappingStartEvent(None, None, True,
+                        token.start_mark, token.end_mark,
+                        flow_style=True)
+                self.state = self.parse_flow_sequence_entry_mapping_key
+                return event
+            elif not self.check_token(FlowSequenceEndToken):
+                self.states.append(self.parse_flow_sequence_entry)
+                return self.parse_flow_node()
+        token = self.get_token()
+        event = SequenceEndEvent(token.start_mark, token.end_mark)
+        self.state = self.states.pop()
+        self.marks.pop()
+        return event
+
+    def parse_flow_sequence_entry_mapping_key(self):
+        token = self.get_token()
+        if not self.check_token(ValueToken,
+                FlowEntryToken, FlowSequenceEndToken):
+            self.states.append(self.parse_flow_sequence_entry_mapping_value)
+            return self.parse_flow_node()
+        else:
+            self.state = self.parse_flow_sequence_entry_mapping_value
+            return self.process_empty_scalar(token.end_mark)
+
+    def parse_flow_sequence_entry_mapping_value(self):
+        if self.check_token(ValueToken):
+            token = self.get_token()
+            if not self.check_token(FlowEntryToken, FlowSequenceEndToken):
+                self.states.append(self.parse_flow_sequence_entry_mapping_end)
+                return self.parse_flow_node()
+            else:
+                self.state = self.parse_flow_sequence_entry_mapping_end
+                return self.process_empty_scalar(token.end_mark)
+        else:
+            self.state = self.parse_flow_sequence_entry_mapping_end
+            token = self.peek_token()
+            return self.process_empty_scalar(token.start_mark)
+
+    def parse_flow_sequence_entry_mapping_end(self):
+        self.state = self.parse_flow_sequence_entry
+        token = self.peek_token()
+        return MappingEndEvent(token.start_mark, token.start_mark)
+
+    # flow_mapping  ::= FLOW-MAPPING-START
+    #                   (flow_mapping_entry FLOW-ENTRY)*
+    #                   flow_mapping_entry?
+    #                   FLOW-MAPPING-END
+    # flow_mapping_entry    ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+
+    def parse_flow_mapping_first_key(self):
+        token = self.get_token()
+        self.marks.append(token.start_mark)
+        return self.parse_flow_mapping_key(first=True)
+
+    def parse_flow_mapping_key(self, first=False):
+        if not self.check_token(FlowMappingEndToken):
+            if not first:
+                if self.check_token(FlowEntryToken):
+                    self.get_token()
+                else:
+                    token = self.peek_token()
+                    raise ParserError("while parsing a flow mapping", self.marks[-1],
+                            "expected ',' or '}', but got %r" % token.id, token.start_mark)
+            if self.check_token(KeyToken):
+                token = self.get_token()
+                if not self.check_token(ValueToken,
+                        FlowEntryToken, FlowMappingEndToken):
+                    self.states.append(self.parse_flow_mapping_value)
+                    return self.parse_flow_node()
+                else:
+                    self.state = self.parse_flow_mapping_value
+                    return self.process_empty_scalar(token.end_mark)
+            elif not self.check_token(FlowMappingEndToken):
+                self.states.append(self.parse_flow_mapping_empty_value)
+                return self.parse_flow_node()
+        token = self.get_token()
+        event = MappingEndEvent(token.start_mark, token.end_mark)
+        self.state = self.states.pop()
+        self.marks.pop()
+        return event
+
+    def parse_flow_mapping_value(self):
+        if self.check_token(ValueToken):
+            token = self.get_token()
+            if not self.check_token(FlowEntryToken, FlowMappingEndToken):
+                self.states.append(self.parse_flow_mapping_key)
+                return self.parse_flow_node()
+            else:
+                self.state = self.parse_flow_mapping_key
+                return self.process_empty_scalar(token.end_mark)
+        else:
+            self.state = self.parse_flow_mapping_key
+            token = self.peek_token()
+            return self.process_empty_scalar(token.start_mark)
+
+    def parse_flow_mapping_empty_value(self):
+        self.state = self.parse_flow_mapping_key
+        return self.process_empty_scalar(self.peek_token().start_mark)
+
+    def process_empty_scalar(self, mark):
+        return ScalarEvent(None, None, (True, False), u'', mark, mark)
+
diff --git a/pynxc/yaml/reader.py b/pynxc/yaml/reader.py
new file mode 100644
index 0000000..1e7a4db
--- /dev/null
+++ b/pynxc/yaml/reader.py
@@ -0,0 +1,225 @@
+# This module contains abstractions for the input stream. You don't have to
+# looks further, there are no pretty code.
+#
+# We define two classes here.
+#
+#   Mark(source, line, column)
+# It's just a record and its only use is producing nice error messages.
+# Parser does not use it for any other purposes.
+#
+#   Reader(source, data)
+# Reader determines the encoding of `data` and converts it to unicode.
+# Reader provides the following methods and attributes:
+#   reader.peek(length=1) - return the next `length` characters
+#   reader.forward(length=1) - move the current position to `length` characters.
+#   reader.index - the number of the current character.
+#   reader.line, stream.column - the line and the column of the current character.
+
+__all__ = ['Reader', 'ReaderError']
+
+from error import YAMLError, Mark
+
+import codecs, re
+
+# Unfortunately, codec functions in Python 2.3 does not support the `finish`
+# arguments, so we have to write our own wrappers.
+
+try:
+    codecs.utf_8_decode('', 'strict', False)
+    from codecs import utf_8_decode, utf_16_le_decode, utf_16_be_decode
+
+except TypeError:
+
+    def utf_16_le_decode(data, errors, finish=False):
+        if not finish and len(data) % 2 == 1:
+            data = data[:-1]
+        return codecs.utf_16_le_decode(data, errors)
+
+    def utf_16_be_decode(data, errors, finish=False):
+        if not finish and len(data) % 2 == 1:
+            data = data[:-1]
+        return codecs.utf_16_be_decode(data, errors)
+
+    def utf_8_decode(data, errors, finish=False):
+        if not finish:
+            # We are trying to remove a possible incomplete multibyte character
+            # from the suffix of the data.
+            # The first byte of a multi-byte sequence is in the range 0xc0 to 0xfd.
+            # All further bytes are in the range 0x80 to 0xbf.
+            # UTF-8 encoded UCS characters may be up to six bytes long.
+            count = 0
+            while count < 5 and count < len(data)   \
+                    and '\x80' <= data[-count-1] <= '\xBF':
+                count -= 1
+            if count < 5 and count < len(data)  \
+                    and '\xC0' <= data[-count-1] <= '\xFD':
+                data = data[:-count-1]
+        return codecs.utf_8_decode(data, errors)
+
+class ReaderError(YAMLError):
+
+    def __init__(self, name, position, character, encoding, reason):
+        self.name = name
+        self.character = character
+        self.position = position
+        self.encoding = encoding
+        self.reason = reason
+
+    def __str__(self):
+        if isinstance(self.character, str):
+            return "'%s' codec can't decode byte #x%02x: %s\n"  \
+                    "  in \"%s\", position %d"    \
+                    % (self.encoding, ord(self.character), self.reason,
+                            self.name, self.position)
+        else:
+            return "unacceptable character #x%04x: %s\n"    \
+                    "  in \"%s\", position %d"    \
+                    % (self.character, self.reason,
+                            self.name, self.position)
+
+class Reader(object):
+    # Reader:
+    # - determines the data encoding and converts it to unicode,
+    # - checks if characters are in allowed range,
+    # - adds '\0' to the end.
+
+    # Reader accepts
+    #  - a `str` object,
+    #  - a `unicode` object,
+    #  - a file-like object with its `read` method returning `str`,
+    #  - a file-like object with its `read` method returning `unicode`.
+
+    # Yeah, it's ugly and slow.
+
+    def __init__(self, stream):
+        self.name = None
+        self.stream = None
+        self.stream_pointer = 0
+        self.eof = True
+        self.buffer = u''
+        self.pointer = 0
+        self.raw_buffer = None
+        self.raw_decode = None
+        self.encoding = None
+        self.index = 0
+        self.line = 0
+        self.column = 0
+        if isinstance(stream, unicode):
+            self.name = "<unicode string>"
+            self.check_printable(stream)
+            self.buffer = stream+u'\0'
+        elif isinstance(stream, str):
+            self.name = "<string>"
+            self.raw_buffer = stream
+            self.determine_encoding()
+        else:
+            self.stream = stream
+            self.name = getattr(stream, 'name', "<file>")
+            self.eof = False
+            self.raw_buffer = ''
+            self.determine_encoding()
+
+    def peek(self, index=0):
+        try:
+            return self.buffer[self.pointer+index]
+        except IndexError:
+            self.update(index+1)
+            return self.buffer[self.pointer+index]
+
+    def prefix(self, length=1):
+        if self.pointer+length >= len(self.buffer):
+            self.update(length)
+        return self.buffer[self.pointer:self.pointer+length]
+
+    def forward(self, length=1):
+        if self.pointer+length+1 >= len(self.buffer):
+            self.update(length+1)
+        while length:
+            ch = self.buffer[self.pointer]
+            self.pointer += 1
+            self.index += 1
+            if ch in u'\n\x85\u2028\u2029'  \
+                    or (ch == u'\r' and self.buffer[self.pointer] != u'\n'):
+                self.line += 1
+                self.column = 0
+            elif ch != u'\uFEFF':
+                self.column += 1
+            length -= 1
+
+    def get_mark(self):
+        if self.stream is None:
+            return Mark(self.name, self.index, self.line, self.column,
+                    self.buffer, self.pointer)
+        else:
+            return Mark(self.name, self.index, self.line, self.column,
+                    None, None)
+
+    def determine_encoding(self):
+        while not self.eof and len(self.raw_buffer) < 2:
+            self.update_raw()
+        if not isinstance(self.raw_buffer, unicode):
+            if self.raw_buffer.startswith(codecs.BOM_UTF16_LE):
+                self.raw_decode = utf_16_le_decode
+                self.encoding = 'utf-16-le'
+            elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE):
+                self.raw_decode = utf_16_be_decode
+                self.encoding = 'utf-16-be'
+            else:
+                self.raw_decode = utf_8_decode
+                self.encoding = 'utf-8'
+        self.update(1)
+
+    NON_PRINTABLE = re.compile(u'[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD]')
+    def check_printable(self, data):
+        match = self.NON_PRINTABLE.search(data)
+        if match:
+            character = match.group()
+            position = self.index+(len(self.buffer)-self.pointer)+match.start()
+            raise ReaderError(self.name, position, ord(character),
+                    'unicode', "special characters are not allowed")
+
+    def update(self, length):
+        if self.raw_buffer is None:
+            return
+        self.buffer = self.buffer[self.pointer:]
+        self.pointer = 0
+        while len(self.buffer) < length:
+            if not self.eof:
+                self.update_raw()
+            if self.raw_decode is not None:
+                try:
+                    data, converted = self.raw_decode(self.raw_buffer,
+                            'strict', self.eof)
+                except UnicodeDecodeError, exc:
+                    character = exc.object[exc.start]
+                    if self.stream is not None:
+                        position = self.stream_pointer-len(self.raw_buffer)+exc.start
+                    else:
+                        position = exc.start
+                    raise ReaderError(self.name, position, character,
+                            exc.encoding, exc.reason)
+            else:
+                data = self.raw_buffer
+                converted = len(data)
+            self.check_printable(data)
+            self.buffer += data
+            self.raw_buffer = self.raw_buffer[converted:]
+            if self.eof:
+                self.buffer += u'\0'
+                self.raw_buffer = None
+                break
+
+    def update_raw(self, size=1024):
+        data = self.stream.read(size)
+        if data:
+            self.raw_buffer += data
+            self.stream_pointer += len(data)
+        else:
+            self.eof = True
+
+#try:
+#    import psyco
+#    psyco.bind(Reader)
+#except ImportError:
+#    pass
+
diff --git a/pynxc/yaml/representer.py b/pynxc/yaml/representer.py
new file mode 100644
index 0000000..f5606ec
--- /dev/null
+++ b/pynxc/yaml/representer.py
@@ -0,0 +1,489 @@
+
+__all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer',
+    'RepresenterError']
+
+from error import *
+from nodes import *
+
+import datetime
+
+try:
+    set
+except NameError:
+    from sets import Set as set
+
+import sys, copy_reg, types
+
+class RepresenterError(YAMLError):
+    pass
+
+class BaseRepresenter(object):
+
+    yaml_representers = {}
+    yaml_multi_representers = {}
+
+    def __init__(self, default_style=None, default_flow_style=None):
+        self.default_style = default_style
+        self.default_flow_style = default_flow_style
+        self.represented_objects = {}
+        self.object_keeper = []
+        self.alias_key = None
+
+    def represent(self, data):
+        node = self.represent_data(data)
+        self.serialize(node)
+        self.represented_objects = {}
+        self.object_keeper = []
+        self.alias_key = None
+
+    def get_classobj_bases(self, cls):
+        bases = [cls]
+        for base in cls.__bases__:
+            bases.extend(self.get_classobj_bases(base))
+        return bases
+
+    def represent_data(self, data):
+        if self.ignore_aliases(data):
+            self.alias_key = None
+        else:
+            self.alias_key = id(data)
+        if self.alias_key is not None:
+            if self.alias_key in self.represented_objects:
+                node = self.represented_objects[self.alias_key]
+                #if node is None:
+                #    raise RepresenterError("recursive objects are not allowed: %r" % data)
+                return node
+            #self.represented_objects[alias_key] = None
+            self.object_keeper.append(data)
+        data_types = type(data).__mro__
+        if type(data) is types.InstanceType:
+            data_types = self.get_classobj_bases(data.__class__)+list(data_types)
+        if data_types[0] in self.yaml_representers:
+            node = self.yaml_representers[data_types[0]](self, data)
+        else:
+            for data_type in data_types:
+                if data_type in self.yaml_multi_representers:
+                    node = self.yaml_multi_representers[data_type](self, data)
+                    break
+            else:
+                if None in self.yaml_multi_representers:
+                    node = self.yaml_multi_representers[None](self, data)
+                elif None in self.yaml_representers:
+                    node = self.yaml_representers[None](self, data)
+                else:
+                    node = ScalarNode(None, unicode(data))
+        #if alias_key is not None:
+        #    self.represented_objects[alias_key] = node
+        return node
+
+    def add_representer(cls, data_type, representer):
+        if not 'yaml_representers' in cls.__dict__:
+            cls.yaml_representers = cls.yaml_representers.copy()
+        cls.yaml_representers[data_type] = representer
+    add_representer = classmethod(add_representer)
+
+    def add_multi_representer(cls, data_type, representer):
+        if not 'yaml_multi_representers' in cls.__dict__:
+            cls.yaml_multi_representers = cls.yaml_multi_representers.copy()
+        cls.yaml_multi_representers[data_type] = representer
+    add_multi_representer = classmethod(add_multi_representer)
+
+    def represent_scalar(self, tag, value, style=None):
+        if style is None:
+            style = self.default_style
+        node = ScalarNode(tag, value, style=style)
+        if self.alias_key is not None:
+            self.represented_objects[self.alias_key] = node
+        return node
+
+    def represent_sequence(self, tag, sequence, flow_style=None):
+        value = []
+        node = SequenceNode(tag, value, flow_style=flow_style)
+        if self.alias_key is not None:
+            self.represented_objects[self.alias_key] = node
+        best_style = True
+        for item in sequence:
+            node_item = self.represent_data(item)
+            if not (isinstance(node_item, ScalarNode) and not node_item.style):
+                best_style = False
+            value.append(node_item)
+        if flow_style is None:
+            if self.default_flow_style is not None:
+                node.flow_style = self.default_flow_style
+            else:
+                node.flow_style = best_style
+        return node
+
+    def represent_mapping(self, tag, mapping, flow_style=None):
+        value = []
+        node = MappingNode(tag, value, flow_style=flow_style)
+        if self.alias_key is not None:
+            self.represented_objects[self.alias_key] = node
+        best_style = True
+        if hasattr(mapping, 'items'):
+            mapping = mapping.items()
+            mapping.sort()
+        for item_key, item_value in mapping:
+            node_key = self.represent_data(item_key)
+            node_value = self.represent_data(item_value)
+            if not (isinstance(node_key, ScalarNode) and not node_key.style):
+                best_style = False
+            if not (isinstance(node_value, ScalarNode) and not node_value.style):
+                best_style = False
+            value.append((node_key, node_value))
+        if flow_style is None:
+            if self.default_flow_style is not None:
+                node.flow_style = self.default_flow_style
+            else:
+                node.flow_style = best_style
+        return node
+
+    def ignore_aliases(self, data):
+        return False
+
+class SafeRepresenter(BaseRepresenter):
+
+    def ignore_aliases(self, data):
+        if data in [None, ()]:
+            return True
+        if isinstance(data, (str, unicode, bool, int, float)):
+            return True
+
+    def represent_none(self, data):
+        return self.represent_scalar(u'tag:yaml.org,2002:null',
+                u'null')
+
+    def represent_str(self, data):
+        tag = None
+        style = None
+        try:
+            data = unicode(data, 'ascii')
+            tag = u'tag:yaml.org,2002:str'
+        except UnicodeDecodeError:
+            try:
+                data = unicode(data, 'utf-8')
+                tag = u'tag:yaml.org,2002:str'
+            except UnicodeDecodeError:
+                data = data.encode('base64')
+                tag = u'tag:yaml.org,2002:binary'
+                style = '|'
+        return self.represent_scalar(tag, data, style=style)
+
+    def represent_unicode(self, data):
+        return self.represent_scalar(u'tag:yaml.org,2002:str', data)
+
+    def represent_bool(self, data):
+        if data:
+            value = u'true'
+        else:
+            value = u'false'
+        return self.represent_scalar(u'tag:yaml.org,2002:bool', value)
+
+    def represent_int(self, data):
+        return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data))
+
+    def represent_long(self, data):
+        return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data))
+
+    inf_value = 1e300
+    while repr(inf_value) != repr(inf_value*inf_value):
+        inf_value *= inf_value
+
+    def represent_float(self, data):
+        if data != data or (data == 0.0 and data == 1.0):
+            value = u'.nan'
+        elif data == self.inf_value:
+            value = u'.inf'
+        elif data == -self.inf_value:
+            value = u'-.inf'
+        else:
+            value = unicode(repr(data)).lower()
+            # Note that in some cases `repr(data)` represents a float number
+            # without the decimal parts.  For instance:
+            #   >>> repr(1e17)
+            #   '1e17'
+            # Unfortunately, this is not a valid float representation according
+            # to the definition of the `!!float` tag.  We fix this by adding
+            # '.0' before the 'e' symbol.
+            if u'.' not in value and u'e' in value:
+                value = value.replace(u'e', u'.0e', 1)
+        return self.represent_scalar(u'tag:yaml.org,2002:float', value)
+
+    def represent_list(self, data):
+        #pairs = (len(data) > 0 and isinstance(data, list))
+        #if pairs:
+        #    for item in data:
+        #        if not isinstance(item, tuple) or len(item) != 2:
+        #            pairs = False
+        #            break
+        #if not pairs:
+            return self.represent_sequence(u'tag:yaml.org,2002:seq', data)
+        #value = []
+        #for item_key, item_value in data:
+        #    value.append(self.represent_mapping(u'tag:yaml.org,2002:map',
+        #        [(item_key, item_value)]))
+        #return SequenceNode(u'tag:yaml.org,2002:pairs', value)
+
+    def represent_dict(self, data):
+        return self.represent_mapping(u'tag:yaml.org,2002:map', data)
+
+    def represent_set(self, data):
+        value = {}
+        for key in data:
+            value[key] = None
+        return self.represent_mapping(u'tag:yaml.org,2002:set', value)
+
+    def represent_date(self, data):
+        value = unicode(data.isoformat())
+        return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value)
+
+    def represent_datetime(self, data):
+        value = unicode(data.isoformat(' '))
+        return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value)
+
+    def represent_yaml_object(self, tag, data, cls, flow_style=None):
+        if hasattr(data, '__getstate__'):
+            state = data.__getstate__()
+        else:
+            state = data.__dict__.copy()
+        return self.represent_mapping(tag, state, flow_style=flow_style)
+
+    def represent_undefined(self, data):
+        raise RepresenterError("cannot represent an object: %s" % data)
+
+SafeRepresenter.add_representer(type(None),
+        SafeRepresenter.represent_none)
+
+SafeRepresenter.add_representer(str,
+        SafeRepresenter.represent_str)
+
+SafeRepresenter.add_representer(unicode,
+        SafeRepresenter.represent_unicode)
+
+SafeRepresenter.add_representer(bool,
+        SafeRepresenter.represent_bool)
+
+SafeRepresenter.add_representer(int,
+        SafeRepresenter.represent_int)
+
+SafeRepresenter.add_representer(long,
+        SafeRepresenter.represent_long)
+
+SafeRepresenter.add_representer(float,
+        SafeRepresenter.represent_float)
+
+SafeRepresenter.add_representer(list,
+        SafeRepresenter.represent_list)
+
+SafeRepresenter.add_representer(tuple,
+        SafeRepresenter.represent_list)
+
+SafeRepresenter.add_representer(dict,
+        SafeRepresenter.represent_dict)
+
+SafeRepresenter.add_representer(set,
+        SafeRepresenter.represent_set)
+
+SafeRepresenter.add_representer(datetime.date,
+        SafeRepresenter.represent_date)
+
+SafeRepresenter.add_representer(datetime.datetime,
+        SafeRepresenter.represent_datetime)
+
+SafeRepresenter.add_representer(None,
+        SafeRepresenter.represent_undefined)
+
+class Representer(SafeRepresenter):
+
+    def represent_str(self, data):
+        tag = None
+        style = None
+        try:
+            data = unicode(data, 'ascii')
+            tag = u'tag:yaml.org,2002:str'
+        except UnicodeDecodeError:
+            try:
+                data = unicode(data, 'utf-8')
+                tag = u'tag:yaml.org,2002:python/str'
+            except UnicodeDecodeError:
+                data = data.encode('base64')
+                tag = u'tag:yaml.org,2002:binary'
+                style = '|'
+        return self.represent_scalar(tag, data, style=style)
+
+    def represent_unicode(self, data):
+        tag = None
+        try:
+            data.encode('ascii')
+            tag = u'tag:yaml.org,2002:python/unicode'
+        except UnicodeEncodeError:
+            tag = u'tag:yaml.org,2002:str'
+        return self.represent_scalar(tag, data)
+
+    def represent_long(self, data):
+        tag = u'tag:yaml.org,2002:int'
+        if int(data) is not data:
+            tag = u'tag:yaml.org,2002:python/long'
+        return self.represent_scalar(tag, unicode(data))
+
+    def represent_complex(self, data):
+        if data.imag == 0.0:
+            data = u'%r' % data.real
+        elif data.real == 0.0:
+            data = u'%rj' % data.imag
+        elif data.imag > 0:
+            data = u'%r+%rj' % (data.real, data.imag)
+        else:
+            data = u'%r%rj' % (data.real, data.imag)
+        return self.represent_scalar(u'tag:yaml.org,2002:python/complex', data)
+
+    def represent_tuple(self, data):
+        return self.represent_sequence(u'tag:yaml.org,2002:python/tuple', data)
+
+    def represent_name(self, data):
+        name = u'%s.%s' % (data.__module__, data.__name__)
+        return self.represent_scalar(u'tag:yaml.org,2002:python/name:'+name, u'')
+
+    def represent_module(self, data):
+        return self.represent_scalar(
+                u'tag:yaml.org,2002:python/module:'+data.__name__, u'')
+
+    def represent_instance(self, data):
+        # For instances of classic classes, we use __getinitargs__ and
+        # __getstate__ to serialize the data.
+
+        # If data.__getinitargs__ exists, the object must be reconstructed by
+        # calling cls(**args), where args is a tuple returned by
+        # __getinitargs__. Otherwise, the cls.__init__ method should never be
+        # called and the class instance is created by instantiating a trivial
+        # class and assigning to the instance's __class__ variable.
+
+        # If data.__getstate__ exists, it returns the state of the object.
+        # Otherwise, the state of the object is data.__dict__.
+
+        # We produce either a !!python/object or !!python/object/new node.
+        # If data.__getinitargs__ does not exist and state is a dictionary, we
+        # produce a !!python/object node . Otherwise we produce a
+        # !!python/object/new node.
+
+        cls = data.__class__
+        class_name = u'%s.%s' % (cls.__module__, cls.__name__)
+        args = None
+        state = None
+        if hasattr(data, '__getinitargs__'):
+            args = list(data.__getinitargs__())
+        if hasattr(data, '__getstate__'):
+            state = data.__getstate__()
+        else:
+            state = data.__dict__
+        if args is None and isinstance(state, dict):
+            return self.represent_mapping(
+                    u'tag:yaml.org,2002:python/object:'+class_name, state)
+        if isinstance(state, dict) and not state:
+            return self.represent_sequence(
+                    u'tag:yaml.org,2002:python/object/new:'+class_name, args)
+        value = {}
+        if args:
+            value['args'] = args
+        value['state'] = state
+        return self.represent_mapping(
+                u'tag:yaml.org,2002:python/object/new:'+class_name, value)
+
+    def represent_object(self, data):
+        # We use __reduce__ API to save the data. data.__reduce__ returns
+        # a tuple of length 2-5:
+        #   (function, args, state, listitems, dictitems)
+
+        # For reconstructing, we calls function(*args), then set its state,
+        # listitems, and dictitems if they are not None.
+
+        # A special case is when function.__name__ == '__newobj__'. In this
+        # case we create the object with args[0].__new__(*args).
+
+        # Another special case is when __reduce__ returns a string - we don't
+        # support it.
+
+        # We produce a !!python/object, !!python/object/new or
+        # !!python/object/apply node.
+
+        cls = type(data)
+        if cls in copy_reg.dispatch_table:
+            reduce = copy_reg.dispatch_table[cls](data)
+        elif hasattr(data, '__reduce_ex__'):
+            reduce = data.__reduce_ex__(2)
+        elif hasattr(data, '__reduce__'):
+            reduce = data.__reduce__()
+        else:
+            raise RepresenterError("cannot represent object: %r" % data)
+        reduce = (list(reduce)+[None]*5)[:5]
+        function, args, state, listitems, dictitems = reduce
+        args = list(args)
+        if state is None:
+            state = {}
+        if listitems is not None:
+            listitems = list(listitems)
+        if dictitems is not None:
+            dictitems = dict(dictitems)
+        if function.__name__ == '__newobj__':
+            function = args[0]
+            args = args[1:]
+            tag = u'tag:yaml.org,2002:python/object/new:'
+            newobj = True
+        else:
+            tag = u'tag:yaml.org,2002:python/object/apply:'
+            newobj = False
+        function_name = u'%s.%s' % (function.__module__, function.__name__)
+        if not args and not listitems and not dictitems \
+                and isinstance(state, dict) and newobj:
+            return self.represent_mapping(
+                    u'tag:yaml.org,2002:python/object:'+function_name, state)
+        if not listitems and not dictitems  \
+                and isinstance(state, dict) and not state:
+            return self.represent_sequence(tag+function_name, args)
+        value = {}
+        if args:
+            value['args'] = args
+        if state or not isinstance(state, dict):
+            value['state'] = state
+        if listitems:
+            value['listitems'] = listitems
+        if dictitems:
+            value['dictitems'] = dictitems
+        return self.represent_mapping(tag+function_name, value)
+
+Representer.add_representer(str,
+        Representer.represent_str)
+
+Representer.add_representer(unicode,
+        Representer.represent_unicode)
+
+Representer.add_representer(long,
+        Representer.represent_long)
+
+Representer.add_representer(complex,
+        Representer.represent_complex)
+
+Representer.add_representer(tuple,
+        Representer.represent_tuple)
+
+Representer.add_representer(type,
+        Representer.represent_name)
+
+Representer.add_representer(types.ClassType,
+        Representer.represent_name)
+
+Representer.add_representer(types.FunctionType,
+        Representer.represent_name)
+
+Representer.add_representer(types.BuiltinFunctionType,
+        Representer.represent_name)
+
+Representer.add_representer(types.ModuleType,
+        Representer.represent_module)
+
+Representer.add_multi_representer(types.InstanceType,
+        Representer.represent_instance)
+
+Representer.add_multi_representer(object,
+        Representer.represent_object)
+
diff --git a/pynxc/yaml/resolver.py b/pynxc/yaml/resolver.py
new file mode 100644
index 0000000..6b5ab87
--- /dev/null
+++ b/pynxc/yaml/resolver.py
@@ -0,0 +1,224 @@
+
+__all__ = ['BaseResolver', 'Resolver']
+
+from error import *
+from nodes import *
+
+import re
+
+class ResolverError(YAMLError):
+    pass
+
+class BaseResolver(object):
+
+    DEFAULT_SCALAR_TAG = u'tag:yaml.org,2002:str'
+    DEFAULT_SEQUENCE_TAG = u'tag:yaml.org,2002:seq'
+    DEFAULT_MAPPING_TAG = u'tag:yaml.org,2002:map'
+
+    yaml_implicit_resolvers = {}
+    yaml_path_resolvers = {}
+
+    def __init__(self):
+        self.resolver_exact_paths = []
+        self.resolver_prefix_paths = []
+
+    def add_implicit_resolver(cls, tag, regexp, first):
+        if not 'yaml_implicit_resolvers' in cls.__dict__:
+            cls.yaml_implicit_resolvers = cls.yaml_implicit_resolvers.copy()
+        if first is None:
+            first = [None]
+        for ch in first:
+            cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp))
+    add_implicit_resolver = classmethod(add_implicit_resolver)
+
+    def add_path_resolver(cls, tag, path, kind=None):
+        # Note: `add_path_resolver` is experimental.  The API could be changed.
+        # `new_path` is a pattern that is matched against the path from the
+        # root to the node that is being considered.  `node_path` elements are
+        # tuples `(node_check, index_check)`.  `node_check` is a node class:
+        # `ScalarNode`, `SequenceNode`, `MappingNode` or `None`.  `None`
+        # matches any kind of a node.  `index_check` could be `None`, a boolean
+        # value, a string value, or a number.  `None` and `False` match against
+        # any _value_ of sequence and mapping nodes.  `True` matches against
+        # any _key_ of a mapping node.  A string `index_check` matches against
+        # a mapping value that corresponds to a scalar key which content is
+        # equal to the `index_check` value.  An integer `index_check` matches
+        # against a sequence value with the index equal to `index_check`.
+        if not 'yaml_path_resolvers' in cls.__dict__:
+            cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy()
+        new_path = []
+        for element in path:
+            if isinstance(element, (list, tuple)):
+                if len(element) == 2:
+                    node_check, index_check = element
+                elif len(element) == 1:
+                    node_check = element[0]
+                    index_check = True
+                else:
+                    raise ResolverError("Invalid path element: %s" % element)
+            else:
+                node_check = None
+                index_check = element
+            if node_check is str:
+                node_check = ScalarNode
+            elif node_check is list:
+                node_check = SequenceNode
+            elif node_check is dict:
+                node_check = MappingNode
+            elif node_check not in [ScalarNode, SequenceNode, MappingNode]  \
+                    and not isinstance(node_check, basestring)  \
+                    and node_check is not None:
+                raise ResolverError("Invalid node checker: %s" % node_check)
+            if not isinstance(index_check, (basestring, int))   \
+                    and index_check is not None:
+                raise ResolverError("Invalid index checker: %s" % index_check)
+            new_path.append((node_check, index_check))
+        if kind is str:
+            kind = ScalarNode
+        elif kind is list:
+            kind = SequenceNode
+        elif kind is dict:
+            kind = MappingNode
+        elif kind not in [ScalarNode, SequenceNode, MappingNode]    \
+                and kind is not None:
+            raise ResolverError("Invalid node kind: %s" % kind)
+        cls.yaml_path_resolvers[tuple(new_path), kind] = tag
+    add_path_resolver = classmethod(add_path_resolver)
+
+    def descend_resolver(self, current_node, current_index):
+        if not self.yaml_path_resolvers:
+            return
+        exact_paths = {}
+        prefix_paths = []
+        if current_node:
+            depth = len(self.resolver_prefix_paths)
+            for path, kind in self.resolver_prefix_paths[-1]:
+                if self.check_resolver_prefix(depth, path, kind,
+                        current_node, current_index):
+                    if len(path) > depth:
+                        prefix_paths.append((path, kind))
+                    else:
+                        exact_paths[kind] = self.yaml_path_resolvers[path, kind]
+        else:
+            for path, kind in self.yaml_path_resolvers:
+                if not path:
+                    exact_paths[kind] = self.yaml_path_resolvers[path, kind]
+                else:
+                    prefix_paths.append((path, kind))
+        self.resolver_exact_paths.append(exact_paths)
+        self.resolver_prefix_paths.append(prefix_paths)
+
+    def ascend_resolver(self):
+        if not self.yaml_path_resolvers:
+            return
+        self.resolver_exact_paths.pop()
+        self.resolver_prefix_paths.pop()
+
+    def check_resolver_prefix(self, depth, path, kind,
+            current_node, current_index):
+        node_check, index_check = path[depth-1]
+        if isinstance(node_check, basestring):
+            if current_node.tag != node_check:
+                return
+        elif node_check is not None:
+            if not isinstance(current_node, node_check):
+                return
+        if index_check is True and current_index is not None:
+            return
+        if (index_check is False or index_check is None)    \
+                and current_index is None:
+            return
+        if isinstance(index_check, basestring):
+            if not (isinstance(current_index, ScalarNode)
+                    and index_check == current_index.value):
+                return
+        elif isinstance(index_check, int) and not isinstance(index_check, bool):
+            if index_check != current_index:
+                return
+        return True
+
+    def resolve(self, kind, value, implicit):
+        if kind is ScalarNode and implicit[0]:
+            if value == u'':
+                resolvers = self.yaml_implicit_resolvers.get(u'', [])
+            else:
+                resolvers = self.yaml_implicit_resolvers.get(value[0], [])
+            resolvers += self.yaml_implicit_resolvers.get(None, [])
+            for tag, regexp in resolvers:
+                if regexp.match(value):
+                    return tag
+            implicit = implicit[1]
+        if self.yaml_path_resolvers:
+            exact_paths = self.resolver_exact_paths[-1]
+            if kind in exact_paths:
+                return exact_paths[kind]
+            if None in exact_paths:
+                return exact_paths[None]
+        if kind is ScalarNode:
+            return self.DEFAULT_SCALAR_TAG
+        elif kind is SequenceNode:
+            return self.DEFAULT_SEQUENCE_TAG
+        elif kind is MappingNode:
+            return self.DEFAULT_MAPPING_TAG
+
+class Resolver(BaseResolver):
+    pass
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:bool',
+        re.compile(ur'''^(?:yes|Yes|YES|no|No|NO
+                    |true|True|TRUE|false|False|FALSE
+                    |on|On|ON|off|Off|OFF)$''', re.X),
+        list(u'yYnNtTfFoO'))
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:float',
+        re.compile(ur'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?
+                    |\.[0-9_]+(?:[eE][-+][0-9]+)?
+                    |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
+                    |[-+]?\.(?:inf|Inf|INF)
+                    |\.(?:nan|NaN|NAN))$''', re.X),
+        list(u'-+0123456789.'))
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:int',
+        re.compile(ur'''^(?:[-+]?0b[0-1_]+
+                    |[-+]?0[0-7_]+
+                    |[-+]?(?:0|[1-9][0-9_]*)
+                    |[-+]?0x[0-9a-fA-F_]+
+                    |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X),
+        list(u'-+0123456789'))
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:merge',
+        re.compile(ur'^(?:<<)$'),
+        [u'<'])
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:null',
+        re.compile(ur'''^(?: ~
+                    |null|Null|NULL
+                    | )$''', re.X),
+        [u'~', u'n', u'N', u''])
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:timestamp',
+        re.compile(ur'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]
+                    |[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]?
+                     (?:[Tt]|[ \t]+)[0-9][0-9]?
+                     :[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)?
+                     (?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X),
+        list(u'0123456789'))
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:value',
+        re.compile(ur'^(?:=)$'),
+        [u'='])
+
+# The following resolver is only for documentation purposes. It cannot work
+# because plain scalars cannot start with '!', '&', or '*'.
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:yaml',
+        re.compile(ur'^(?:!|&|\*)$'),
+        list(u'!&*'))
+
diff --git a/pynxc/yaml/scanner.py b/pynxc/yaml/scanner.py
new file mode 100644
index 0000000..5228fad
--- /dev/null
+++ b/pynxc/yaml/scanner.py
@@ -0,0 +1,1457 @@
+
+# Scanner produces tokens of the following types:
+# STREAM-START
+# STREAM-END
+# DIRECTIVE(name, value)
+# DOCUMENT-START
+# DOCUMENT-END
+# BLOCK-SEQUENCE-START
+# BLOCK-MAPPING-START
+# BLOCK-END
+# FLOW-SEQUENCE-START
+# FLOW-MAPPING-START
+# FLOW-SEQUENCE-END
+# FLOW-MAPPING-END
+# BLOCK-ENTRY
+# FLOW-ENTRY
+# KEY
+# VALUE
+# ALIAS(value)
+# ANCHOR(value)
+# TAG(value)
+# SCALAR(value, plain, style)
+#
+# Read comments in the Scanner code for more details.
+#
+
+__all__ = ['Scanner', 'ScannerError']
+
+from error import MarkedYAMLError
+from tokens import *
+
+class ScannerError(MarkedYAMLError):
+    pass
+
+class SimpleKey(object):
+    # See below simple keys treatment.
+
+    def __init__(self, token_number, required, index, line, column, mark):
+        self.token_number = token_number
+        self.required = required
+        self.index = index
+        self.line = line
+        self.column = column
+        self.mark = mark
+
+class Scanner(object):
+
+    def __init__(self):
+        """Initialize the scanner."""
+        # It is assumed that Scanner and Reader will have a common descendant.
+        # Reader do the dirty work of checking for BOM and converting the
+        # input data to Unicode. It also adds NUL to the end.
+        #
+        # Reader supports the following methods
+        #   self.peek(i=0)       # peek the next i-th character
+        #   self.prefix(l=1)     # peek the next l characters
+        #   self.forward(l=1)    # read the next l characters and move the pointer.
+
+        # Had we reached the end of the stream?
+        self.done = False
+
+        # The number of unclosed '{' and '['. `flow_level == 0` means block
+        # context.
+        self.flow_level = 0
+
+        # List of processed tokens that are not yet emitted.
+        self.tokens = []
+
+        # Add the STREAM-START token.
+        self.fetch_stream_start()
+
+        # Number of tokens that were emitted through the `get_token` method.
+        self.tokens_taken = 0
+
+        # The current indentation level.
+        self.indent = -1
+
+        # Past indentation levels.
+        self.indents = []
+
+        # Variables related to simple keys treatment.
+
+        # A simple key is a key that is not denoted by the '?' indicator.
+        # Example of simple keys:
+        #   ---
+        #   block simple key: value
+        #   ? not a simple key:
+        #   : { flow simple key: value }
+        # We emit the KEY token before all keys, so when we find a potential
+        # simple key, we try to locate the corresponding ':' indicator.
+        # Simple keys should be limited to a single line and 1024 characters.
+
+        # Can a simple key start at the current position? A simple key may
+        # start:
+        # - at the beginning of the line, not counting indentation spaces
+        #       (in block context),
+        # - after '{', '[', ',' (in the flow context),
+        # - after '?', ':', '-' (in the block context).
+        # In the block context, this flag also signifies if a block collection
+        # may start at the current position.
+        self.allow_simple_key = True
+
+        # Keep track of possible simple keys. This is a dictionary. The key
+        # is `flow_level`; there can be no more that one possible simple key
+        # for each level. The value is a SimpleKey record:
+        #   (token_number, required, index, line, column, mark)
+        # A simple key may start with ALIAS, ANCHOR, TAG, SCALAR(flow),
+        # '[', or '{' tokens.
+        self.possible_simple_keys = {}
+
+    # Public methods.
+
+    def check_token(self, *choices):
+        # Check if the next token is one of the given types.
+        while self.need_more_tokens():
+            self.fetch_more_tokens()
+        if self.tokens:
+            if not choices:
+                return True
+            for choice in choices:
+                if isinstance(self.tokens[0], choice):
+                    return True
+        return False
+
+    def peek_token(self):
+        # Return the next token, but do not delete if from the queue.
+        while self.need_more_tokens():
+            self.fetch_more_tokens()
+        if self.tokens:
+            return self.tokens[0]
+
+    def get_token(self):
+        # Return the next token.
+        while self.need_more_tokens():
+            self.fetch_more_tokens()
+        if self.tokens:
+            self.tokens_taken += 1
+            return self.tokens.pop(0)
+
+    # Private methods.
+
+    def need_more_tokens(self):
+        if self.done:
+            return False
+        if not self.tokens:
+            return True
+        # The current token may be a potential simple key, so we
+        # need to look further.
+        self.stale_possible_simple_keys()
+        if self.next_possible_simple_key() == self.tokens_taken:
+            return True
+
+    def fetch_more_tokens(self):
+
+        # Eat whitespaces and comments until we reach the next token.
+        self.scan_to_next_token()
+
+        # Remove obsolete possible simple keys.
+        self.stale_possible_simple_keys()
+
+        # Compare the current indentation and column. It may add some tokens
+        # and decrease the current indentation level.
+        self.unwind_indent(self.column)
+
+        # Peek the next character.
+        ch = self.peek()
+
+        # Is it the end of stream?
+        if ch == u'\0':
+            return self.fetch_stream_end()
+
+        # Is it a directive?
+        if ch == u'%' and self.check_directive():
+            return self.fetch_directive()
+
+        # Is it the document start?
+        if ch == u'-' and self.check_document_start():
+            return self.fetch_document_start()
+
+        # Is it the document end?
+        if ch == u'.' and self.check_document_end():
+            return self.fetch_document_end()
+
+        # TODO: support for BOM within a stream.
+        #if ch == u'\uFEFF':
+        #    return self.fetch_bom()    <-- issue BOMToken
+
+        # Note: the order of the following checks is NOT significant.
+
+        # Is it the flow sequence start indicator?
+        if ch == u'[':
+            return self.fetch_flow_sequence_start()
+
+        # Is it the flow mapping start indicator?
+        if ch == u'{':
+            return self.fetch_flow_mapping_start()
+
+        # Is it the flow sequence end indicator?
+        if ch == u']':
+            return self.fetch_flow_sequence_end()
+
+        # Is it the flow mapping end indicator?
+        if ch == u'}':
+            return self.fetch_flow_mapping_end()
+
+        # Is it the flow entry indicator?
+        if ch == u',':
+            return self.fetch_flow_entry()
+
+        # Is it the block entry indicator?
+        if ch == u'-' and self.check_block_entry():
+            return self.fetch_block_entry()
+
+        # Is it the key indicator?
+        if ch == u'?' and self.check_key():
+            return self.fetch_key()
+
+        # Is it the value indicator?
+        if ch == u':' and self.check_value():
+            return self.fetch_value()
+
+        # Is it an alias?
+        if ch == u'*':
+            return self.fetch_alias()
+
+        # Is it an anchor?
+        if ch == u'&':
+            return self.fetch_anchor()
+
+        # Is it a tag?
+        if ch == u'!':
+            return self.fetch_tag()
+
+        # Is it a literal scalar?
+        if ch == u'|' and not self.flow_level:
+            return self.fetch_literal()
+
+        # Is it a folded scalar?
+        if ch == u'>' and not self.flow_level:
+            return self.fetch_folded()
+
+        # Is it a single quoted scalar?
+        if ch == u'\'':
+            return self.fetch_single()
+
+        # Is it a double quoted scalar?
+        if ch == u'\"':
+            return self.fetch_double()
+
+        # It must be a plain scalar then.
+        if self.check_plain():
+            return self.fetch_plain()
+
+        # No? It's an error. Let's produce a nice error message.
+        raise ScannerError("while scanning for the next token", None,
+                "found character %r that cannot start any token"
+                % ch.encode('utf-8'), self.get_mark())
+
+    # Simple keys treatment.
+
+    def next_possible_simple_key(self):
+        # Return the number of the nearest possible simple key. Actually we
+        # don't need to loop through the whole dictionary. We may replace it
+        # with the following code:
+        #   if not self.possible_simple_keys:
+        #       return None
+        #   return self.possible_simple_keys[
+        #           min(self.possible_simple_keys.keys())].token_number
+        min_token_number = None
+        for level in self.possible_simple_keys:
+            key = self.possible_simple_keys[level]
+            if min_token_number is None or key.token_number < min_token_number:
+                min_token_number = key.token_number
+        return min_token_number
+
+    def stale_possible_simple_keys(self):
+        # Remove entries that are no longer possible simple keys. According to
+        # the YAML specification, simple keys
+        # - should be limited to a single line,
+        # - should be no longer than 1024 characters.
+        # Disabling this procedure will allow simple keys of any length and
+        # height (may cause problems if indentation is broken though).
+        for level in self.possible_simple_keys.keys():
+            key = self.possible_simple_keys[level]
+            if key.line != self.line  \
+                    or self.index-key.index > 1024:
+                if key.required:
+                    raise ScannerError("while scanning a simple key", key.mark,
+                            "could not found expected ':'", self.get_mark())
+                del self.possible_simple_keys[level]
+
+    def save_possible_simple_key(self):
+        # The next token may start a simple key. We check if it's possible
+        # and save its position. This function is called for
+        #   ALIAS, ANCHOR, TAG, SCALAR(flow), '[', and '{'.
+
+        # Check if a simple key is required at the current position.
+        required = not self.flow_level and self.indent == self.column
+
+        # A simple key is required only if it is the first token in the current
+        # line. Therefore it is always allowed.
+        assert self.allow_simple_key or not required
+
+        # The next token might be a simple key. Let's save it's number and
+        # position.
+        if self.allow_simple_key:
+            self.remove_possible_simple_key()
+            token_number = self.tokens_taken+len(self.tokens)
+            key = SimpleKey(token_number, required,
+                    self.index, self.line, self.column, self.get_mark())
+            self.possible_simple_keys[self.flow_level] = key
+
+    def remove_possible_simple_key(self):
+        # Remove the saved possible key position at the current flow level.
+        if self.flow_level in self.possible_simple_keys:
+            key = self.possible_simple_keys[self.flow_level]
+            
+            if key.required:
+                raise ScannerError("while scanning a simple key", key.mark,
+                        "could not found expected ':'", self.get_mark())
+
+            del self.possible_simple_keys[self.flow_level]
+
+    # Indentation functions.
+
+    def unwind_indent(self, column):
+
+        ## In flow context, tokens should respect indentation.
+        ## Actually the condition should be `self.indent >= column` according to
+        ## the spec. But this condition will prohibit intuitively correct
+        ## constructions such as
+        ## key : {
+        ## }
+        #if self.flow_level and self.indent > column:
+        #    raise ScannerError(None, None,
+        #            "invalid intendation or unclosed '[' or '{'",
+        #            self.get_mark())
+
+        # In the flow context, indentation is ignored. We make the scanner less
+        # restrictive then specification requires.
+        if self.flow_level:
+            return
+
+        # In block context, we may need to issue the BLOCK-END tokens.
+        while self.indent > column:
+            mark = self.get_mark()
+            self.indent = self.indents.pop()
+            self.tokens.append(BlockEndToken(mark, mark))
+
+    def add_indent(self, column):
+        # Check if we need to increase indentation.
+        if self.indent < column:
+            self.indents.append(self.indent)
+            self.indent = column
+            return True
+        return False
+
+    # Fetchers.
+
+    def fetch_stream_start(self):
+        # We always add STREAM-START as the first token and STREAM-END as the
+        # last token.
+
+        # Read the token.
+        mark = self.get_mark()
+        
+        # Add STREAM-START.
+        self.tokens.append(StreamStartToken(mark, mark,
+            encoding=self.encoding))
+        
+
+    def fetch_stream_end(self):
+
+        # Set the current intendation to -1.
+        self.unwind_indent(-1)
+
+        # Reset simple keys.
+        self.remove_possible_simple_key()
+        self.allow_simple_key = False
+        self.possible_simple_keys = {}
+
+        # Read the token.
+        mark = self.get_mark()
+        
+        # Add STREAM-END.
+        self.tokens.append(StreamEndToken(mark, mark))
+
+        # The steam is finished.
+        self.done = True
+
+    def fetch_directive(self):
+        
+        # Set the current intendation to -1.
+        self.unwind_indent(-1)
+
+        # Reset simple keys.
+        self.remove_possible_simple_key()
+        self.allow_simple_key = False
+
+        # Scan and add DIRECTIVE.
+        self.tokens.append(self.scan_directive())
+
+    def fetch_document_start(self):
+        self.fetch_document_indicator(DocumentStartToken)
+
+    def fetch_document_end(self):
+        self.fetch_document_indicator(DocumentEndToken)
+
+    def fetch_document_indicator(self, TokenClass):
+
+        # Set the current intendation to -1.
+        self.unwind_indent(-1)
+
+        # Reset simple keys. Note that there could not be a block collection
+        # after '---'.
+        self.remove_possible_simple_key()
+        self.allow_simple_key = False
+
+        # Add DOCUMENT-START or DOCUMENT-END.
+        start_mark = self.get_mark()
+        self.forward(3)
+        end_mark = self.get_mark()
+        self.tokens.append(TokenClass(start_mark, end_mark))
+
+    def fetch_flow_sequence_start(self):
+        self.fetch_flow_collection_start(FlowSequenceStartToken)
+
+    def fetch_flow_mapping_start(self):
+        self.fetch_flow_collection_start(FlowMappingStartToken)
+
+    def fetch_flow_collection_start(self, TokenClass):
+
+        # '[' and '{' may start a simple key.
+        self.save_possible_simple_key()
+
+        # Increase the flow level.
+        self.flow_level += 1
+
+        # Simple keys are allowed after '[' and '{'.
+        self.allow_simple_key = True
+
+        # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(TokenClass(start_mark, end_mark))
+
+    def fetch_flow_sequence_end(self):
+        self.fetch_flow_collection_end(FlowSequenceEndToken)
+
+    def fetch_flow_mapping_end(self):
+        self.fetch_flow_collection_end(FlowMappingEndToken)
+
+    def fetch_flow_collection_end(self, TokenClass):
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Decrease the flow level.
+        self.flow_level -= 1
+
+        # No simple keys after ']' or '}'.
+        self.allow_simple_key = False
+
+        # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(TokenClass(start_mark, end_mark))
+
+    def fetch_flow_entry(self):
+
+        # Simple keys are allowed after ','.
+        self.allow_simple_key = True
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Add FLOW-ENTRY.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(FlowEntryToken(start_mark, end_mark))
+
+    def fetch_block_entry(self):
+
+        # Block context needs additional checks.
+        if not self.flow_level:
+
+            # Are we allowed to start a new entry?
+            if not self.allow_simple_key:
+                raise ScannerError(None, None,
+                        "sequence entries are not allowed here",
+                        self.get_mark())
+
+            # We may need to add BLOCK-SEQUENCE-START.
+            if self.add_indent(self.column):
+                mark = self.get_mark()
+                self.tokens.append(BlockSequenceStartToken(mark, mark))
+
+        # It's an error for the block entry to occur in the flow context,
+        # but we let the parser detect this.
+        else:
+            pass
+
+        # Simple keys are allowed after '-'.
+        self.allow_simple_key = True
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Add BLOCK-ENTRY.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(BlockEntryToken(start_mark, end_mark))
+
+    def fetch_key(self):
+        
+        # Block context needs additional checks.
+        if not self.flow_level:
+
+            # Are we allowed to start a key (not nessesary a simple)?
+            if not self.allow_simple_key:
+                raise ScannerError(None, None,
+                        "mapping keys are not allowed here",
+                        self.get_mark())
+
+            # We may need to add BLOCK-MAPPING-START.
+            if self.add_indent(self.column):
+                mark = self.get_mark()
+                self.tokens.append(BlockMappingStartToken(mark, mark))
+
+        # Simple keys are allowed after '?' in the block context.
+        self.allow_simple_key = not self.flow_level
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Add KEY.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(KeyToken(start_mark, end_mark))
+
+    def fetch_value(self):
+
+        # Do we determine a simple key?
+        if self.flow_level in self.possible_simple_keys:
+
+            # Add KEY.
+            key = self.possible_simple_keys[self.flow_level]
+            del self.possible_simple_keys[self.flow_level]
+            self.tokens.insert(key.token_number-self.tokens_taken,
+                    KeyToken(key.mark, key.mark))
+
+            # If this key starts a new block mapping, we need to add
+            # BLOCK-MAPPING-START.
+            if not self.flow_level:
+                if self.add_indent(key.column):
+                    self.tokens.insert(key.token_number-self.tokens_taken,
+                            BlockMappingStartToken(key.mark, key.mark))
+
+            # There cannot be two simple keys one after another.
+            self.allow_simple_key = False
+
+        # It must be a part of a complex key.
+        else:
+            
+            # Block context needs additional checks.
+            # (Do we really need them? They will be catched by the parser
+            # anyway.)
+            if not self.flow_level:
+
+                # We are allowed to start a complex value if and only if
+                # we can start a simple key.
+                if not self.allow_simple_key:
+                    raise ScannerError(None, None,
+                            "mapping values are not allowed here",
+                            self.get_mark())
+
+            # If this value starts a new block mapping, we need to add
+            # BLOCK-MAPPING-START.  It will be detected as an error later by
+            # the parser.
+            if not self.flow_level:
+                if self.add_indent(self.column):
+                    mark = self.get_mark()
+                    self.tokens.append(BlockMappingStartToken(mark, mark))
+
+            # Simple keys are allowed after ':' in the block context.
+            self.allow_simple_key = not self.flow_level
+
+            # Reset possible simple key on the current level.
+            self.remove_possible_simple_key()
+
+        # Add VALUE.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(ValueToken(start_mark, end_mark))
+
+    def fetch_alias(self):
+
+        # ALIAS could be a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after ALIAS.
+        self.allow_simple_key = False
+
+        # Scan and add ALIAS.
+        self.tokens.append(self.scan_anchor(AliasToken))
+
+    def fetch_anchor(self):
+
+        # ANCHOR could start a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after ANCHOR.
+        self.allow_simple_key = False
+
+        # Scan and add ANCHOR.
+        self.tokens.append(self.scan_anchor(AnchorToken))
+
+    def fetch_tag(self):
+
+        # TAG could start a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after TAG.
+        self.allow_simple_key = False
+
+        # Scan and add TAG.
+        self.tokens.append(self.scan_tag())
+
+    def fetch_literal(self):
+        self.fetch_block_scalar(style='|')
+
+    def fetch_folded(self):
+        self.fetch_block_scalar(style='>')
+
+    def fetch_block_scalar(self, style):
+
+        # A simple key may follow a block scalar.
+        self.allow_simple_key = True
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Scan and add SCALAR.
+        self.tokens.append(self.scan_block_scalar(style))
+
+    def fetch_single(self):
+        self.fetch_flow_scalar(style='\'')
+
+    def fetch_double(self):
+        self.fetch_flow_scalar(style='"')
+
+    def fetch_flow_scalar(self, style):
+
+        # A flow scalar could be a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after flow scalars.
+        self.allow_simple_key = False
+
+        # Scan and add SCALAR.
+        self.tokens.append(self.scan_flow_scalar(style))
+
+    def fetch_plain(self):
+
+        # A plain scalar could be a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after plain scalars. But note that `scan_plain` will
+        # change this flag if the scan is finished at the beginning of the
+        # line.
+        self.allow_simple_key = False
+
+        # Scan and add SCALAR. May change `allow_simple_key`.
+        self.tokens.append(self.scan_plain())
+
+    # Checkers.
+
+    def check_directive(self):
+
+        # DIRECTIVE:        ^ '%' ...
+        # The '%' indicator is already checked.
+        if self.column == 0:
+            return True
+
+    def check_document_start(self):
+
+        # DOCUMENT-START:   ^ '---' (' '|'\n')
+        if self.column == 0:
+            if self.prefix(3) == u'---'  \
+                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                return True
+
+    def check_document_end(self):
+
+        # DOCUMENT-END:     ^ '...' (' '|'\n')
+        if self.column == 0:
+            if self.prefix(3) == u'...'  \
+                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                return True
+
+    def check_block_entry(self):
+
+        # BLOCK-ENTRY:      '-' (' '|'\n')
+        return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+
+    def check_key(self):
+
+        # KEY(flow context):    '?'
+        if self.flow_level:
+            return True
+
+        # KEY(block context):   '?' (' '|'\n')
+        else:
+            return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+
+    def check_value(self):
+
+        # VALUE(flow context):  ':'
+        if self.flow_level:
+            return True
+
+        # VALUE(block context): ':' (' '|'\n')
+        else:
+            return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+
+    def check_plain(self):
+
+        # A plain scalar may start with any non-space character except:
+        #   '-', '?', ':', ',', '[', ']', '{', '}',
+        #   '#', '&', '*', '!', '|', '>', '\'', '\"',
+        #   '%', '@', '`'.
+        #
+        # It may also start with
+        #   '-', '?', ':'
+        # if it is followed by a non-space character.
+        #
+        # Note that we limit the last rule to the block context (except the
+        # '-' character) because we want the flow context to be space
+        # independent.
+        ch = self.peek()
+        return ch not in u'\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`'  \
+                or (self.peek(1) not in u'\0 \t\r\n\x85\u2028\u2029'
+                        and (ch == u'-' or (not self.flow_level and ch in u'?:')))
+
+    # Scanners.
+
+    def scan_to_next_token(self):
+        # We ignore spaces, line breaks and comments.
+        # If we find a line break in the block context, we set the flag
+        # `allow_simple_key` on.
+        # The byte order mark is stripped if it's the first character in the
+        # stream. We do not yet support BOM inside the stream as the
+        # specification requires. Any such mark will be considered as a part
+        # of the document.
+        #
+        # TODO: We need to make tab handling rules more sane. A good rule is
+        #   Tabs cannot precede tokens
+        #   BLOCK-SEQUENCE-START, BLOCK-MAPPING-START, BLOCK-END,
+        #   KEY(block), VALUE(block), BLOCK-ENTRY
+        # So the checking code is
+        #   if <TAB>:
+        #       self.allow_simple_keys = False
+        # We also need to add the check for `allow_simple_keys == True` to
+        # `unwind_indent` before issuing BLOCK-END.
+        # Scanners for block, flow, and plain scalars need to be modified.
+
+        if self.index == 0 and self.peek() == u'\uFEFF':
+            self.forward()
+        found = False
+        while not found:
+            while self.peek() == u' ':
+                self.forward()
+            if self.peek() == u'#':
+                while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+                    self.forward()
+            if self.scan_line_break():
+                if not self.flow_level:
+                    self.allow_simple_key = True
+            else:
+                found = True
+
+    def scan_directive(self):
+        # See the specification for details.
+        start_mark = self.get_mark()
+        self.forward()
+        name = self.scan_directive_name(start_mark)
+        value = None
+        if name == u'YAML':
+            value = self.scan_yaml_directive_value(start_mark)
+            end_mark = self.get_mark()
+        elif name == u'TAG':
+            value = self.scan_tag_directive_value(start_mark)
+            end_mark = self.get_mark()
+        else:
+            end_mark = self.get_mark()
+            while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+                self.forward()
+        self.scan_directive_ignored_line(start_mark)
+        return DirectiveToken(name, value, start_mark, end_mark)
+
+    def scan_directive_name(self, start_mark):
+        # See the specification for details.
+        length = 0
+        ch = self.peek(length)
+        while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'    \
+                or ch in u'-_':
+            length += 1
+            ch = self.peek(length)
+        if not length:
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected alphabetic or numeric character, but found %r"
+                    % ch.encode('utf-8'), self.get_mark())
+        value = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
+        if ch not in u'\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected alphabetic or numeric character, but found %r"
+                    % ch.encode('utf-8'), self.get_mark())
+        return value
+
+    def scan_yaml_directive_value(self, start_mark):
+        # See the specification for details.
+        while self.peek() == u' ':
+            self.forward()
+        major = self.scan_yaml_directive_number(start_mark)
+        if self.peek() != '.':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected a digit or '.', but found %r"
+                    % self.peek().encode('utf-8'),
+                    self.get_mark())
+        self.forward()
+        minor = self.scan_yaml_directive_number(start_mark)
+        if self.peek() not in u'\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected a digit or ' ', but found %r"
+                    % self.peek().encode('utf-8'),
+                    self.get_mark())
+        return (major, minor)
+
+    def scan_yaml_directive_number(self, start_mark):
+        # See the specification for details.
+        ch = self.peek()
+        if not (u'0' <= ch <= u'9'):
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected a digit, but found %r" % ch.encode('utf-8'),
+                    self.get_mark())
+        length = 0
+        while u'0' <= self.peek(length) <= u'9':
+            length += 1
+        value = int(self.prefix(length))
+        self.forward(length)
+        return value
+
+    def scan_tag_directive_value(self, start_mark):
+        # See the specification for details.
+        while self.peek() == u' ':
+            self.forward()
+        handle = self.scan_tag_directive_handle(start_mark)
+        while self.peek() == u' ':
+            self.forward()
+        prefix = self.scan_tag_directive_prefix(start_mark)
+        return (handle, prefix)
+
+    def scan_tag_directive_handle(self, start_mark):
+        # See the specification for details.
+        value = self.scan_tag_handle('directive', start_mark)
+        ch = self.peek()
+        if ch != u' ':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected ' ', but found %r" % ch.encode('utf-8'),
+                    self.get_mark())
+        return value
+
+    def scan_tag_directive_prefix(self, start_mark):
+        # See the specification for details.
+        value = self.scan_tag_uri('directive', start_mark)
+        ch = self.peek()
+        if ch not in u'\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected ' ', but found %r" % ch.encode('utf-8'),
+                    self.get_mark())
+        return value
+
+    def scan_directive_ignored_line(self, start_mark):
+        # See the specification for details.
+        while self.peek() == u' ':
+            self.forward()
+        if self.peek() == u'#':
+            while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+                self.forward()
+        ch = self.peek()
+        if ch not in u'\0\r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected a comment or a line break, but found %r"
+                        % ch.encode('utf-8'), self.get_mark())
+        self.scan_line_break()
+
+    def scan_anchor(self, TokenClass):
+        # The specification does not restrict characters for anchors and
+        # aliases. This may lead to problems, for instance, the document:
+        #   [ *alias, value ]
+        # can be interpteted in two ways, as
+        #   [ "value" ]
+        # and
+        #   [ *alias , "value" ]
+        # Therefore we restrict aliases to numbers and ASCII letters.
+        start_mark = self.get_mark()
+        indicator = self.peek()
+        if indicator == u'*':
+            name = 'alias'
+        else:
+            name = 'anchor'
+        self.forward()
+        length = 0
+        ch = self.peek(length)
+        while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'    \
+                or ch in u'-_':
+            length += 1
+            ch = self.peek(length)
+        if not length:
+            raise ScannerError("while scanning an %s" % name, start_mark,
+                    "expected alphabetic or numeric character, but found %r"
+                    % ch.encode('utf-8'), self.get_mark())
+        value = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
+        if ch not in u'\0 \t\r\n\x85\u2028\u2029?:,]}%@`':
+            raise ScannerError("while scanning an %s" % name, start_mark,
+                    "expected alphabetic or numeric character, but found %r"
+                    % ch.encode('utf-8'), self.get_mark())
+        end_mark = self.get_mark()
+        return TokenClass(value, start_mark, end_mark)
+
+    def scan_tag(self):
+        # See the specification for details.
+        start_mark = self.get_mark()
+        ch = self.peek(1)
+        if ch == u'<':
+            handle = None
+            self.forward(2)
+            suffix = self.scan_tag_uri('tag', start_mark)
+            if self.peek() != u'>':
+                raise ScannerError("while parsing a tag", start_mark,
+                        "expected '>', but found %r" % self.peek().encode('utf-8'),
+                        self.get_mark())
+            self.forward()
+        elif ch in u'\0 \t\r\n\x85\u2028\u2029':
+            handle = None
+            suffix = u'!'
+            self.forward()
+        else:
+            length = 1
+            use_handle = False
+            while ch not in u'\0 \r\n\x85\u2028\u2029':
+                if ch == u'!':
+                    use_handle = True
+                    break
+                length += 1
+                ch = self.peek(length)
+            handle = u'!'
+            if use_handle:
+                handle = self.scan_tag_handle('tag', start_mark)
+            else:
+                handle = u'!'
+                self.forward()
+            suffix = self.scan_tag_uri('tag', start_mark)
+        ch = self.peek()
+        if ch not in u'\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a tag", start_mark,
+                    "expected ' ', but found %r" % ch.encode('utf-8'),
+                    self.get_mark())
+        value = (handle, suffix)
+        end_mark = self.get_mark()
+        return TagToken(value, start_mark, end_mark)
+
+    def scan_block_scalar(self, style):
+        # See the specification for details.
+
+        if style == '>':
+            folded = True
+        else:
+            folded = False
+
+        chunks = []
+        start_mark = self.get_mark()
+
+        # Scan the header.
+        self.forward()
+        chomping, increment = self.scan_block_scalar_indicators(start_mark)
+        self.scan_block_scalar_ignored_line(start_mark)
+
+        # Determine the indentation level and go to the first non-empty line.
+        min_indent = self.indent+1
+        if min_indent < 1:
+            min_indent = 1
+        if increment is None:
+            breaks, max_indent, end_mark = self.scan_block_scalar_indentation()
+            indent = max(min_indent, max_indent)
+        else:
+            indent = min_indent+increment-1
+            breaks, end_mark = self.scan_block_scalar_breaks(indent)
+        line_break = u''
+
+        # Scan the inner part of the block scalar.
+        while self.column == indent and self.peek() != u'\0':
+            chunks.extend(breaks)
+            leading_non_space = self.peek() not in u' \t'
+            length = 0
+            while self.peek(length) not in u'\0\r\n\x85\u2028\u2029':
+                length += 1
+            chunks.append(self.prefix(length))
+            self.forward(length)
+            line_break = self.scan_line_break()
+            breaks, end_mark = self.scan_block_scalar_breaks(indent)
+            if self.column == indent and self.peek() != u'\0':
+
+                # Unfortunately, folding rules are ambiguous.
+                #
+                # This is the folding according to the specification:
+                
+                if folded and line_break == u'\n'   \
+                        and leading_non_space and self.peek() not in u' \t':
+                    if not breaks:
+                        chunks.append(u' ')
+                else:
+                    chunks.append(line_break)
+                
+                # This is Clark Evans's interpretation (also in the spec
+                # examples):
+                #
+                #if folded and line_break == u'\n':
+                #    if not breaks:
+                #        if self.peek() not in ' \t':
+                #            chunks.append(u' ')
+                #        else:
+                #            chunks.append(line_break)
+                #else:
+                #    chunks.append(line_break)
+            else:
+                break
+
+        # Chomp the tail.
+        if chomping is not False:
+            chunks.append(line_break)
+        if chomping is True:
+            chunks.extend(breaks)
+
+        # We are done.
+        return ScalarToken(u''.join(chunks), False, start_mark, end_mark,
+                style)
+
+    def scan_block_scalar_indicators(self, start_mark):
+        # See the specification for details.
+        chomping = None
+        increment = None
+        ch = self.peek()
+        if ch in u'+-':
+            if ch == '+':
+                chomping = True
+            else:
+                chomping = False
+            self.forward()
+            ch = self.peek()
+            if ch in u'0123456789':
+                increment = int(ch)
+                if increment == 0:
+                    raise ScannerError("while scanning a block scalar", start_mark,
+                            "expected indentation indicator in the range 1-9, but found 0",
+                            self.get_mark())
+                self.forward()
+        elif ch in u'0123456789':
+            increment = int(ch)
+            if increment == 0:
+                raise ScannerError("while scanning a block scalar", start_mark,
+                        "expected indentation indicator in the range 1-9, but found 0",
+                        self.get_mark())
+            self.forward()
+            ch = self.peek()
+            if ch in u'+-':
+                if ch == '+':
+                    chomping = True
+                else:
+                    chomping = False
+                self.forward()
+        ch = self.peek()
+        if ch not in u'\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a block scalar", start_mark,
+                    "expected chomping or indentation indicators, but found %r"
+                        % ch.encode('utf-8'), self.get_mark())
+        return chomping, increment
+
+    def scan_block_scalar_ignored_line(self, start_mark):
+        # See the specification for details.
+        while self.peek() == u' ':
+            self.forward()
+        if self.peek() == u'#':
+            while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+                self.forward()
+        ch = self.peek()
+        if ch not in u'\0\r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a block scalar", start_mark,
+                    "expected a comment or a line break, but found %r"
+                        % ch.encode('utf-8'), self.get_mark())
+        self.scan_line_break()
+
+    def scan_block_scalar_indentation(self):
+        # See the specification for details.
+        chunks = []
+        max_indent = 0
+        end_mark = self.get_mark()
+        while self.peek() in u' \r\n\x85\u2028\u2029':
+            if self.peek() != u' ':
+                chunks.append(self.scan_line_break())
+                end_mark = self.get_mark()
+            else:
+                self.forward()
+                if self.column > max_indent:
+                    max_indent = self.column
+        return chunks, max_indent, end_mark
+
+    def scan_block_scalar_breaks(self, indent):
+        # See the specification for details.
+        chunks = []
+        end_mark = self.get_mark()
+        while self.column < indent and self.peek() == u' ':
+            self.forward()
+        while self.peek() in u'\r\n\x85\u2028\u2029':
+            chunks.append(self.scan_line_break())
+            end_mark = self.get_mark()
+            while self.column < indent and self.peek() == u' ':
+                self.forward()
+        return chunks, end_mark
+
+    def scan_flow_scalar(self, style):
+        # See the specification for details.
+        # Note that we loose indentation rules for quoted scalars. Quoted
+        # scalars don't need to adhere indentation because " and ' clearly
+        # mark the beginning and the end of them. Therefore we are less
+        # restrictive then the specification requires. We only need to check
+        # that document separators are not included in scalars.
+        if style == '"':
+            double = True
+        else:
+            double = False
+        chunks = []
+        start_mark = self.get_mark()
+        quote = self.peek()
+        self.forward()
+        chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
+        while self.peek() != quote:
+            chunks.extend(self.scan_flow_scalar_spaces(double, start_mark))
+            chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
+        self.forward()
+        end_mark = self.get_mark()
+        return ScalarToken(u''.join(chunks), False, start_mark, end_mark,
+                style)
+
+    ESCAPE_REPLACEMENTS = {
+        u'0':   u'\0',
+        u'a':   u'\x07',
+        u'b':   u'\x08',
+        u't':   u'\x09',
+        u'\t':  u'\x09',
+        u'n':   u'\x0A',
+        u'v':   u'\x0B',
+        u'f':   u'\x0C',
+        u'r':   u'\x0D',
+        u'e':   u'\x1B',
+        u' ':   u'\x20',
+        u'\"':  u'\"',
+        u'\\':  u'\\',
+        u'N':   u'\x85',
+        u'_':   u'\xA0',
+        u'L':   u'\u2028',
+        u'P':   u'\u2029',
+    }
+
+    ESCAPE_CODES = {
+        u'x':   2,
+        u'u':   4,
+        u'U':   8,
+    }
+
+    def scan_flow_scalar_non_spaces(self, double, start_mark):
+        # See the specification for details.
+        chunks = []
+        while True:
+            length = 0
+            while self.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029':
+                length += 1
+            if length:
+                chunks.append(self.prefix(length))
+                self.forward(length)
+            ch = self.peek()
+            if not double and ch == u'\'' and self.peek(1) == u'\'':
+                chunks.append(u'\'')
+                self.forward(2)
+            elif (double and ch == u'\'') or (not double and ch in u'\"\\'):
+                chunks.append(ch)
+                self.forward()
+            elif double and ch == u'\\':
+                self.forward()
+                ch = self.peek()
+                if ch in self.ESCAPE_REPLACEMENTS:
+                    chunks.append(self.ESCAPE_REPLACEMENTS[ch])
+                    self.forward()
+                elif ch in self.ESCAPE_CODES:
+                    length = self.ESCAPE_CODES[ch]
+                    self.forward()
+                    for k in range(length):
+                        if self.peek(k) not in u'0123456789ABCDEFabcdef':
+                            raise ScannerError("while scanning a double-quoted scalar", start_mark,
+                                    "expected escape sequence of %d hexdecimal numbers, but found %r" %
+                                        (length, self.peek(k).encode('utf-8')), self.get_mark())
+                    code = int(self.prefix(length), 16)
+                    chunks.append(unichr(code))
+                    self.forward(length)
+                elif ch in u'\r\n\x85\u2028\u2029':
+                    self.scan_line_break()
+                    chunks.extend(self.scan_flow_scalar_breaks(double, start_mark))
+                else:
+                    raise ScannerError("while scanning a double-quoted scalar", start_mark,
+                            "found unknown escape character %r" % ch.encode('utf-8'), self.get_mark())
+            else:
+                return chunks
+
+    def scan_flow_scalar_spaces(self, double, start_mark):
+        # See the specification for details.
+        chunks = []
+        length = 0
+        while self.peek(length) in u' \t':
+            length += 1
+        whitespaces = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
+        if ch == u'\0':
+            raise ScannerError("while scanning a quoted scalar", start_mark,
+                    "found unexpected end of stream", self.get_mark())
+        elif ch in u'\r\n\x85\u2028\u2029':
+            line_break = self.scan_line_break()
+            breaks = self.scan_flow_scalar_breaks(double, start_mark)
+            if line_break != u'\n':
+                chunks.append(line_break)
+            elif not breaks:
+                chunks.append(u' ')
+            chunks.extend(breaks)
+        else:
+            chunks.append(whitespaces)
+        return chunks
+
+    def scan_flow_scalar_breaks(self, double, start_mark):
+        # See the specification for details.
+        chunks = []
+        while True:
+            # Instead of checking indentation, we check for document
+            # separators.
+            prefix = self.prefix(3)
+            if (prefix == u'---' or prefix == u'...')   \
+                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                raise ScannerError("while scanning a quoted scalar", start_mark,
+                        "found unexpected document separator", self.get_mark())
+            while self.peek() in u' \t':
+                self.forward()
+            if self.peek() in u'\r\n\x85\u2028\u2029':
+                chunks.append(self.scan_line_break())
+            else:
+                return chunks
+
+    def scan_plain(self):
+        # See the specification for details.
+        # We add an additional restriction for the flow context:
+        #   plain scalars in the flow context cannot contain ',', ':' and '?'.
+        # We also keep track of the `allow_simple_key` flag here.
+        # Indentation rules are loosed for the flow context.
+        chunks = []
+        start_mark = self.get_mark()
+        end_mark = start_mark
+        indent = self.indent+1
+        # We allow zero indentation for scalars, but then we need to check for
+        # document separators at the beginning of the line.
+        #if indent == 0:
+        #    indent = 1
+        spaces = []
+        while True:
+            length = 0
+            if self.peek() == u'#':
+                break
+            while True:
+                ch = self.peek(length)
+                if ch in u'\0 \t\r\n\x85\u2028\u2029'   \
+                        or (not self.flow_level and ch == u':' and
+                                self.peek(length+1) in u'\0 \t\r\n\x85\u2028\u2029') \
+                        or (self.flow_level and ch in u',:?[]{}'):
+                    break
+                length += 1
+            # It's not clear what we should do with ':' in the flow context.
+            if (self.flow_level and ch == u':'
+                    and self.peek(length+1) not in u'\0 \t\r\n\x85\u2028\u2029,[]{}'):
+                self.forward(length)
+                raise ScannerError("while scanning a plain scalar", start_mark,
+                    "found unexpected ':'", self.get_mark(),
+                    "Please check http://pyyaml.org/wiki/YAMLColonInFlowContext for details.")
+            if length == 0:
+                break
+            self.allow_simple_key = False
+            chunks.extend(spaces)
+            chunks.append(self.prefix(length))
+            self.forward(length)
+            end_mark = self.get_mark()
+            spaces = self.scan_plain_spaces(indent, start_mark)
+            if not spaces or self.peek() == u'#' \
+                    or (not self.flow_level and self.column < indent):
+                break
+        return ScalarToken(u''.join(chunks), True, start_mark, end_mark)
+
+    def scan_plain_spaces(self, indent, start_mark):
+        # See the specification for details.
+        # The specification is really confusing about tabs in plain scalars.
+        # We just forbid them completely. Do not use tabs in YAML!
+        chunks = []
+        length = 0
+        while self.peek(length) in u' ':
+            length += 1
+        whitespaces = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
+        if ch in u'\r\n\x85\u2028\u2029':
+            line_break = self.scan_line_break()
+            self.allow_simple_key = True
+            prefix = self.prefix(3)
+            if (prefix == u'---' or prefix == u'...')   \
+                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                return
+            breaks = []
+            while self.peek() in u' \r\n\x85\u2028\u2029':
+                if self.peek() == ' ':
+                    self.forward()
+                else:
+                    breaks.append(self.scan_line_break())
+                    prefix = self.prefix(3)
+                    if (prefix == u'---' or prefix == u'...')   \
+                            and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                        return
+            if line_break != u'\n':
+                chunks.append(line_break)
+            elif not breaks:
+                chunks.append(u' ')
+            chunks.extend(breaks)
+        elif whitespaces:
+            chunks.append(whitespaces)
+        return chunks
+
+    def scan_tag_handle(self, name, start_mark):
+        # See the specification for details.
+        # For some strange reasons, the specification does not allow '_' in
+        # tag handles. I have allowed it anyway.
+        ch = self.peek()
+        if ch != u'!':
+            raise ScannerError("while scanning a %s" % name, start_mark,
+                    "expected '!', but found %r" % ch.encode('utf-8'),
+                    self.get_mark())
+        length = 1
+        ch = self.peek(length)
+        if ch != u' ':
+            while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'    \
+                    or ch in u'-_':
+                length += 1
+                ch = self.peek(length)
+            if ch != u'!':
+                self.forward(length)
+                raise ScannerError("while scanning a %s" % name, start_mark,
+                        "expected '!', but found %r" % ch.encode('utf-8'),
+                        self.get_mark())
+            length += 1
+        value = self.prefix(length)
+        self.forward(length)
+        return value
+
+    def scan_tag_uri(self, name, start_mark):
+        # See the specification for details.
+        # Note: we do not check if URI is well-formed.
+        chunks = []
+        length = 0
+        ch = self.peek(length)
+        while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'    \
+                or ch in u'-;/?:@&=+$,_.!~*\'()[]%':
+            if ch == u'%':
+                chunks.append(self.prefix(length))
+                self.forward(length)
+                length = 0
+                chunks.append(self.scan_uri_escapes(name, start_mark))
+            else:
+                length += 1
+            ch = self.peek(length)
+        if length:
+            chunks.append(self.prefix(length))
+            self.forward(length)
+            length = 0
+        if not chunks:
+            raise ScannerError("while parsing a %s" % name, start_mark,
+                    "expected URI, but found %r" % ch.encode('utf-8'),
+                    self.get_mark())
+        return u''.join(chunks)
+
+    def scan_uri_escapes(self, name, start_mark):
+        # See the specification for details.
+        bytes = []
+        mark = self.get_mark()
+        while self.peek() == u'%':
+            self.forward()
+            for k in range(2):
+                if self.peek(k) not in u'0123456789ABCDEFabcdef':
+                    raise ScannerError("while scanning a %s" % name, start_mark,
+                            "expected URI escape sequence of 2 hexdecimal numbers, but found %r" %
+                                (self.peek(k).encode('utf-8')), self.get_mark())
+            bytes.append(chr(int(self.prefix(2), 16)))
+            self.forward(2)
+        try:
+            value = unicode(''.join(bytes), 'utf-8')
+        except UnicodeDecodeError, exc:
+            raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark)
+        return value
+
+    def scan_line_break(self):
+        # Transforms:
+        #   '\r\n'      :   '\n'
+        #   '\r'        :   '\n'
+        #   '\n'        :   '\n'
+        #   '\x85'      :   '\n'
+        #   '\u2028'    :   '\u2028'
+        #   '\u2029     :   '\u2029'
+        #   default     :   ''
+        ch = self.peek()
+        if ch in u'\r\n\x85':
+            if self.prefix(2) == u'\r\n':
+                self.forward(2)
+            else:
+                self.forward()
+            return u'\n'
+        elif ch in u'\u2028\u2029':
+            self.forward()
+            return ch
+        return u''
+
+#try:
+#    import psyco
+#    psyco.bind(Scanner)
+#except ImportError:
+#    pass
+
diff --git a/pynxc/yaml/serializer.py b/pynxc/yaml/serializer.py
new file mode 100644
index 0000000..0bf1e96
--- /dev/null
+++ b/pynxc/yaml/serializer.py
@@ -0,0 +1,111 @@
+
+__all__ = ['Serializer', 'SerializerError']
+
+from error import YAMLError
+from events import *
+from nodes import *
+
+class SerializerError(YAMLError):
+    pass
+
+class Serializer(object):
+
+    ANCHOR_TEMPLATE = u'id%03d'
+
+    def __init__(self, encoding=None,
+            explicit_start=None, explicit_end=None, version=None, tags=None):
+        self.use_encoding = encoding
+        self.use_explicit_start = explicit_start
+        self.use_explicit_end = explicit_end
+        self.use_version = version
+        self.use_tags = tags
+        self.serialized_nodes = {}
+        self.anchors = {}
+        self.last_anchor_id = 0
+        self.closed = None
+
+    def open(self):
+        if self.closed is None:
+            self.emit(StreamStartEvent(encoding=self.use_encoding))
+            self.closed = False
+        elif self.closed:
+            raise SerializerError("serializer is closed")
+        else:
+            raise SerializerError("serializer is already opened")
+
+    def close(self):
+        if self.closed is None:
+            raise SerializerError("serializer is not opened")
+        elif not self.closed:
+            self.emit(StreamEndEvent())
+            self.closed = True
+
+    #def __del__(self):
+    #    self.close()
+
+    def serialize(self, node):
+        if self.closed is None:
+            raise SerializerError("serializer is not opened")
+        elif self.closed:
+            raise SerializerError("serializer is closed")
+        self.emit(DocumentStartEvent(explicit=self.use_explicit_start,
+            version=self.use_version, tags=self.use_tags))
+        self.anchor_node(node)
+        self.serialize_node(node, None, None)
+        self.emit(DocumentEndEvent(explicit=self.use_explicit_end))
+        self.serialized_nodes = {}
+        self.anchors = {}
+        self.last_anchor_id = 0
+
+    def anchor_node(self, node):
+        if node in self.anchors:
+            if self.anchors[node] is None:
+                self.anchors[node] = self.generate_anchor(node)
+        else:
+            self.anchors[node] = None
+            if isinstance(node, SequenceNode):
+                for item in node.value:
+                    self.anchor_node(item)
+            elif isinstance(node, MappingNode):
+                for key, value in node.value:
+                    self.anchor_node(key)
+                    self.anchor_node(value)
+
+    def generate_anchor(self, node):
+        self.last_anchor_id += 1
+        return self.ANCHOR_TEMPLATE % self.last_anchor_id
+
+    def serialize_node(self, node, parent, index):
+        alias = self.anchors[node]
+        if node in self.serialized_nodes:
+            self.emit(AliasEvent(alias))
+        else:
+            self.serialized_nodes[node] = True
+            self.descend_resolver(parent, index)
+            if isinstance(node, ScalarNode):
+                detected_tag = self.resolve(ScalarNode, node.value, (True, False))
+                default_tag = self.resolve(ScalarNode, node.value, (False, True))
+                implicit = (node.tag == detected_tag), (node.tag == default_tag)
+                self.emit(ScalarEvent(alias, node.tag, implicit, node.value,
+                    style=node.style))
+            elif isinstance(node, SequenceNode):
+                implicit = (node.tag
+                            == self.resolve(SequenceNode, node.value, True))
+                self.emit(SequenceStartEvent(alias, node.tag, implicit,
+                    flow_style=node.flow_style))
+                index = 0
+                for item in node.value:
+                    self.serialize_node(item, node, index)
+                    index += 1
+                self.emit(SequenceEndEvent())
+            elif isinstance(node, MappingNode):
+                implicit = (node.tag
+                            == self.resolve(MappingNode, node.value, True))
+                self.emit(MappingStartEvent(alias, node.tag, implicit,
+                    flow_style=node.flow_style))
+                for key, value in node.value:
+                    self.serialize_node(key, node, None)
+                    self.serialize_node(value, node, key)
+                self.emit(MappingEndEvent())
+            self.ascend_resolver()
+
diff --git a/pynxc/yaml/tokens.py b/pynxc/yaml/tokens.py
new file mode 100644
index 0000000..4d0b48a
--- /dev/null
+++ b/pynxc/yaml/tokens.py
@@ -0,0 +1,104 @@
+
+class Token(object):
+    def __init__(self, start_mark, end_mark):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+    def __repr__(self):
+        attributes = [key for key in self.__dict__
+                if not key.endswith('_mark')]
+        attributes.sort()
+        arguments = ', '.join(['%s=%r' % (key, getattr(self, key))
+                for key in attributes])
+        return '%s(%s)' % (self.__class__.__name__, arguments)
+
+#class BOMToken(Token):
+#    id = '<byte order mark>'
+
+class DirectiveToken(Token):
+    id = '<directive>'
+    def __init__(self, name, value, start_mark, end_mark):
+        self.name = name
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class DocumentStartToken(Token):
+    id = '<document start>'
+
+class DocumentEndToken(Token):
+    id = '<document end>'
+
+class StreamStartToken(Token):
+    id = '<stream start>'
+    def __init__(self, start_mark=None, end_mark=None,
+            encoding=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.encoding = encoding
+
+class StreamEndToken(Token):
+    id = '<stream end>'
+
+class BlockSequenceStartToken(Token):
+    id = '<block sequence start>'
+
+class BlockMappingStartToken(Token):
+    id = '<block mapping start>'
+
+class BlockEndToken(Token):
+    id = '<block end>'
+
+class FlowSequenceStartToken(Token):
+    id = '['
+
+class FlowMappingStartToken(Token):
+    id = '{'
+
+class FlowSequenceEndToken(Token):
+    id = ']'
+
+class FlowMappingEndToken(Token):
+    id = '}'
+
+class KeyToken(Token):
+    id = '?'
+
+class ValueToken(Token):
+    id = ':'
+
+class BlockEntryToken(Token):
+    id = '-'
+
+class FlowEntryToken(Token):
+    id = ','
+
+class AliasToken(Token):
+    id = '<alias>'
+    def __init__(self, value, start_mark, end_mark):
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class AnchorToken(Token):
+    id = '<anchor>'
+    def __init__(self, value, start_mark, end_mark):
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class TagToken(Token):
+    id = '<tag>'
+    def __init__(self, value, start_mark, end_mark):
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class ScalarToken(Token):
+    id = '<scalar>'
+    def __init__(self, value, plain, start_mark, end_mark, style=None):
+        self.value = value
+        self.plain = plain
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.style = style
+