root/trunk/RBRapier/RBRapier/Formats/SVG/SVGSkin/SVGItems/TransformBuilder.py

#!/usr/bin/env python
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
##~ License 
##~ 
##- The RuneBlade Foundation library is intended to ease some 
##- aspects of writing intricate Jabber, XML, and User Interface (wxPython, etc.) 
##- applications, while providing the flexibility to modularly change the 
##- architecture. Enjoy.
##~ 
##~ Copyright (C) 2002  TechGame Networks, LLC.
##~ 
##~ This library is free software; you can redistribute it and/or
##~ modify it under the terms of the BSD style License as found in the 
##~ LICENSE file included with this distribution.
##~ 
##~ TechGame Networks, LLC can be reached at:
##~ 3578 E. Hartsel Drive #211
##~ Colorado Springs, Colorado, USA, 80920
##~
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

"""
Translate commands

    translate(x=0, y=0)
    scale(x=1, y=x)
    rotate(angle, x=0, y=0)
    skewX(angle)
    skewY(angle)
    matrix(xx, xy, yx, yy)
"""

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Imports 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

import re

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Definitions 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def _transformcommand(name, argtypes):
    return {'name':name, 'argtypes':argtypes}

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Transform Factories
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class AbstractTransformFactory(object):
    __slots__ = ()

    def BeginTransform(self, transformcmd): 
        raise NotImplementedError
    def AddTransformElement(self, name, *args):
        raise NotImplementedError
    def EndTransform(self, transformcmd): 
        raise NotImplementedError

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    #def translate(self, x=0.0, y=0.0):
    #    raise NotImplementedError
    #def scale(self, x=1., y=x):
    #    raise NotImplementedError
    #def rotate(self, angle=0.0, x=0, y=0):
    #    raise NotImplementedError
    #def skewx(self, angle=0.0):
    #    raise NotImplementedError
    #def skewy(self, angle=0.0):
    #    raise NotImplementedError
    #def matrix(self, xx=1.0, xy=0.0, xh=0.0, yx=0.0, yy=1.0, yh=0.0, hx=0.0, hy=0.0, hh=1.0):
    #    raise NotImplementedError

class SaveTransformFactory(AbstractTransformFactory):
    __slots__ = ('transformcmd', 'transforms')

    def BeginTransform(self, transformcmd): 
        self.transformcmd = transformcmd
        self.transforms = []

    def AddTransformElement(self, *args):
        self.transforms.append(args)
        
    def EndTransform(self, transformcmd): 
        assert self.transformcmd is transformcmd

    def RestoreTo(self, transformfactory):
        self.RestoreToEx(
            onbegin=transformfactory.BeginTransform, 
            onadd=transformfactory.AddTransformElement, 
            onend=transformfactory.EndTransform)
        return transformfactory

    def RestoreToEx(self, onbegin=lambda xformcmd:None, onadd=lambda name, *args:None, onend=lambda xformcmd:None):
        onbegin(self.transformcmd)
        for args in self.transforms:
            onadd(*args)
        onend(self.transformcmd)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Transform Builder/Interpreter
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class TransformCommandBuilder(object):
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Constants / Variables / Etc. 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    _delim = '\s*,?\s*'
    _re_command = re.compile(r'\s*(\w+)\s*\(([^\)]*)\)\s*')
    _re_argument = re.compile(r'([-+]?(?:\d+(?:\.\d*)?|\d*\.\d+)(?:[eE][-+]?\d+)?)'+_delim)

    def __init__(self, transformfactory=None):
        self.transformfactory = transformfactory

    def Build(self, transformcmd, transformfactory=None):
        transformfactory = transformfactory or self.transformfactory

        transformfactory.BeginTransform(transformcmd)

        matchidx = 0
        # MoveTo is the default command
        while matchidx < len(transformcmd):
            # Find out what command we're dealing with
            commandmatch = self._re_command.match(transformcmd, matchidx)
            assert commandmatch is not None
            command, args = commandmatch.groups()
            matchidx = commandmatch.end()

            # parse out the arguments for the transform element
            arguments = []
            args = args.strip()
            while args:
                argmatch = self._re_argument.match(args)
                arguments.extend(map(float, argmatch.groups()))
                args = args[argmatch.end():]

            # go get the transform factory method for our command
            transformfactory.AddTransformElement(command, *arguments)

        transformfactory.EndTransform(transformcmd)
        return transformfactory

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Testing 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if __name__=='__main__':
    class TestTransformFactory(AbstractTransformFactory):
        def __iter__(self):
            return iter(self.results)
        def BeginTransform(self, pathstr): 
            self.results = ["begin()"]
        def AddTransformElement(self, name, *args):
            self.results.append('%s%r' % (name, args))
        def EndTransform(self, pathstr): 
            self.results.append("end()")

    builder = TransformCommandBuilder(TestTransformFactory())

    print
    print "Example 1:"
    for each in builder.Build('scale(2, 3)'):
        print '   ', each

    print
    print "Example 2:"
    for each in builder.Build('translate(-3, 4)'):
        print '   ', each

    print
    print "Example 3:"
    for each in builder.Build('translate(-3, 4) scale(3)'):
        print '   ', each

    print
    print "Example 4:"
    for each in builder.Build('scale(.5-4)skewx(3)'):
        print '   ', each