Changeset 634

Show
Ignore:
Timestamp:
07/16/03 02:13:14 (5 years ago)
Author:
sholloway
Message:

*** empty log message ***

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/RBFoundation/RBFoundation/SubObs/Event.py

    r597 r634  
    4747from LogicRules import ListCollection 
    4848 
    49 class EventSubjectWeakList(EventSubjectBase, ListCollection.ListCollection, BaseCollection.WeakWrapCallableMixin): pass 
    50 class EventSubjectStrongList(EventSubjectBase, ListCollection.ListCollection, BaseCollection.StrongWrapCallableMixin): pass 
     49class EventSubjectWeakList(EventSubjectBase, ListCollection.ListCollection, BaseCollection.WeakWrapCallableMixin): 
     50    prepend = True 
     51class EventSubjectStrongList(EventSubjectBase, ListCollection.ListCollection, BaseCollection.StrongWrapCallableMixin): 
     52    prepend = True 
    5153EventSubjectList = EventSubjectWeakList 
    5254EventSubject = EventSubjectWeakList # Set the default 
    …… 
    5860#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    5961 
    60 class ObjectEventSubjectWeakList(ObjectEventSubjectBase, ListCollection.ListCollection, BaseCollection.WeakWrapCallableMixin): pass 
    61 class ObjectEventSubjectStrongList(ObjectEventSubjectBase, ListCollection.ListCollection, BaseCollection.StrongWrapCallableMixin): pass 
     62class ObjectEventSubjectWeakList(ObjectEventSubjectBase, ListCollection.ListCollection, BaseCollection.WeakWrapCallableMixin): 
     63    prepend = True 
     64class ObjectEventSubjectStrongList(ObjectEventSubjectBase, ListCollection.ListCollection, BaseCollection.StrongWrapCallableMixin): 
     65    prepend = True 
    6266ObjectEventSubjectList = ObjectEventSubjectWeakList 
    6367ObjectEventSubject = ObjectEventSubjectWeakList # Set the default 

  • trunk/RBFoundation/RBFoundation/SubObs/LogicRules/ListCollection.py

    r620 r634  
    3737 
    3838    _collection_class = list 
    39     insertidx = 0 
     39    prepend = False 
    4040 
    4141    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    …… 
    4545    def Add(self, Callback, *data): 
    4646        wr = self._WrapCallable(Callback) 
    47         if self.insertidx is None: 
     47        if self.prepend: 
     48            self.collection.insert(0, data + (wr,)) 
     49        else: 
    4850            self.collection.append(data + (wr,)) 
    49         else: 
    50             self.collection.insert(self.insertidx, data + (wr,)) 
    5151 
    5252    def Remove(self, Callback): 

  • trunk/RBRapier/RBRapier/Formats/Attic/SVG.old/Renderers/Rapier.py

    r631 r634  
    2424#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    2525 
    26 import warnings 
    2726from OpenGL import GL 
    2827 
    …… 
    3938#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    4039 
    41 class RapierPathFactory(Abstract.AbstractPathFactory): 
    42     __slots__ = 'pos', 'pathlist' 
    43  
    44     def BeginPath(self, pathstr):  
    45         self.pathlist = [] 
    46         self.pos = 0., 0. 
    47  
    48     def AddPathElement(self, name, *args): 
    49         name, relative = self.command_table[name] 
    50         getattr(self, name.lower())(relative, *args) 
    51  
    52     def EndPath(self, pathstr):  
    53         pass 
    54  
    55     def move(self, relative, x, y):  
    56         if relative: 
    57             dx, dy = self.pos 
    58             x += dx 
    59             y += dy 
    60         self.pathlist.append([(x,y)]) 
    61         self.pos = x,y 
    62  
    63     def closepath(self, relative):  
    64         lastpath = self.pathlist[-1] 
    65         self.pos = lastpath[0] 
    66         lastpath.append(self.pos) 
    67  
    68     def line(self, relative, x, y):  
    69         if relative: 
    70             dx, dy = self.pos 
    71             x += dx 
    72             y += dy 
    73         self.pathlist[-1].append((x,y)) 
    74         self.pos = x,y 
    75  
    76     def hline(self, relative, x):  
    77         dx, y = self.pos 
    78         if relative: 
    79             x += dx 
    80         self.pathlist[-1].append((x,y)) 
    81         self.pos = x,y 
    82  
    83     def vline(self, relative, y):  
    84         x, dy = self.pos 
    85         if relative: 
    86             y += dy 
    87         self.pathlist[-1].append((x,y)) 
    88         self.pos = x,y 
    89  
    90     def cubicbezier(self, relative, x1, y1, x2, y2, x, y):  
    91         if relative: 
    92             dx, dy = self.x, self.y 
    93             x1 += dx 
    94             y1 += dy 
    95             x2 += dx 
    96             y2 += dy 
    97             x += dx 
    98             y += dy 
    99         warnings.warn( "TODO: path.cubicbezier") 
    100         self.pathlist[-1].append((x,y)) 
    101         self.pos = x,y 
    102  
    103     def smoothcurve(self, relative, x2, y2, x, y):  
    104         if relative: 
    105             dx, dy = self.pos 
    106             x2 += dx 
    107             y2 += dy 
    108             x += dx 
    109             y += dy 
    110         warnings.warn( "TODO: path.smoothcurve") 
    111         self.pathlist[-1].append((x,y)) 
    112         self.pos = x,y 
    113  
    114     def quadraticbezier(self, relative, x1, y1, x, y):  
    115         if relative: 
    116             dx, dy = self.pos 
    117             x1 += dx 
    118             y1 += dy 
    119             x += dx 
    120             y += dy 
    121         warnings.warn( "TODO: path.quadraticbezier") 
    122         self.pathlist[-1].append((x,y)) 
    123         self.pos = x,y 
    124  
    125     def smoothquadraticbezier(self, relative, x, y):  
    126         if relative: 
    127             dx, dy = self.pos 
    128             x += dx 
    129             y += dy 
    130         warnings.warn( "TODO: path.smoothquadraticbezier") 
    131         self.pathlist[-1].append((x,y)) 
    132         self.pos = x,y 
    133  
    134     def ellipticarc(self, relative, rx, ry, xrotation, largeArcFlag, sweepFlag, x, y):  
    135         if relative: 
    136             dx, dy = self.pos 
    137             x += dx 
    138             y += dy 
    139         warnings.warn( "TODO: path.ellipticarc") 
    140         self.pathlist[-1].append((x,y)) 
    141         self.pos = x,y 
    142  
    143 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    144  
    145 class RapierTransformFactory(object): 
    146     def __init__(self, xform): 
    147         pass 
    148  
    149     def BeginTransform(self, transformstr):  
    150         pass 
    151     def AddTransformElement(self, name, *args):  
    152         pass 
    153     def EndTransform(self, transformstr):  
    154         pass 
    155  
    156     def translate(self, x=0.0, y=0.0):  
    157         warnings.warn( "TODO: transform.translate") 
    158     def scale(self, x=1., y=None):  
    159         warnings.warn( "TODO: transform.scale") 
    160     def rotate(self, angle=0.0, x=0, y=0):  
    161         warnings.warn( "TODO: transform.rotate") 
    162     def skewx(self, angle=0.0):  
    163         warnings.warn( "TODO: transform.skewx") 
    164     def skewy(self, angle=0.0):  
    165         warnings.warn( "TODO: transform.skewy") 
    166     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):  
    167         warnings.warn( "TODO: transform.matrix") 
     40class RapierContext(object): 
     41    sequence = None 
     42    currentColor = None 
     43    fillcolor = None 
     44    strokecolor = None 
     45    fillopacity = 1. 
     46    strokeopacity = 1. 
     47 
     48    resolver = {} 
     49 
     50    def __init__(self, *kwin, **kw): 
     51        for each in kwin: 
     52            self.__dict__.update(each) 
     53        self.__dict__.update(kw) 
     54 
     55    def Branch(self, **kw): 
     56        return self.__class__(self.__dict__, **kw) 
     57 
     58    def GetFillColor(self, allowstroke=True): 
     59        result = self.fillcolor 
     60        if result is not None: 
     61            return self.fillcolor + (int(255*self.fillopacity),) 
     62        elif allowstroke: 
     63            return self.GetStrokeColor(False) 
     64 
     65    def GetStrokeColor(self, allowfill=True): 
     66        result = self.strokecolor 
     67        if result is not None: 
     68            return self.strokecolor + (int(255*self.strokeopacity),) 
     69        elif allowfill: 
     70            return self.GetFillColor(False) 
     71 
     72    def GetColors(self): 
     73        return {'stroke': self.GetStrokeColor(False), 'fill': self.GetFillColor(False)} 
    16874 
    16975#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    …… 
    17480    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    17581 
    176     PathFactory = RapierPathFactory 
    177     TransformFactory = RapierTransformFactory 
     82    PathFactory = RapierObjects.RapierPathFactory 
     83    TransformFactory = RapierObjects.RapierTransformFactory 
    17884    SequenceFactory = SequenceMgr.Sequence 
    17985 
    …… 
    18490    def Display(self, ri): 
    18591        rootsequence = self.SequenceFactory() 
    186         self.sequence = rootsequence 
    187         self.style = {} 
    188  
    189         # SVG coordinate system is upside down from OpenGL's  
     92 
     93        # SVG coordinate system is upside down from OpenGL's , so scale y by -1 
    19094        xform = Transformations.ScaleMgd(GL.GL_PROJECTION, True, (1, -1, 1)) 
    191         self.sequence.AddElement(xform.Select) 
    192         self.sequence.AddPostElement(xform.Deselect) 
     95        rootsequence.AddElement(xform.Select) 
     96        rootsequence.AddPostElement(xform.Deselect) 
    19397 
    19498        xform = Transformations.IdentityMgd(GL.GL_MODELVIEW, True) 
    195         self.sequence.AddElement(xform.Select) 
    196         self.sequence.AddPostElement(xform.Deselect) 
    197  
    198         self.context = [] 
    199         self.resolver = [] 
     99        rootsequence.AddElement(xform.Select) 
     100        rootsequence.AddPostElement(xform.Deselect) 
     101 
     102        self.contextstack = [] 
     103        self.context = RapierContext() 
     104        self.context.sequence = rootsequence 
    200105 
    201106        try: 
    202107            ri.DisplayOn(self) 
    203108        finally: 
    204             del self.resolver 
    205109            del self.context 
    206             del self.sequence 
     110            del self.contextstack 
    207111        return rootsequence 
    208112 
    …… 
    219123    def DisplaySVG(self, ri_svg):  
    220124        self.PushContext(ri_svg, True) 
    221         self.resolver.append(ri_svg.idmapping) 
     125        self.context.resolver = ri_svg.idmapping 
    222126        try: 
    223127            ri_svg.DisplayChildrenOn(self) 
    224128        finally: 
    225             self.resolver.pop() 
    226129            self.PopContext(ri_svg) 
    227130 
    …… 
    254157        self.PushContext(ri_line) 
    255158        try: 
    256             self.sequence.AddElement(RapierObjects.Line((ri_line.x1, ri_line.y1), (ri_line.x2, ri_line.y2))) 
     159            ro = RapierObjects.Line((ri_line.x1, ri_line.y1), (ri_line.x2, ri_line.y2)) 
     160            ro.SetColors(**self.context.GetColors()) 
     161            if ro: self.context.sequence.AddElement(ro) 
    257162        finally: 
    258163            self.PopContext(ri_line) 
    …… 
    261166        self.PushContext(ri_rect) 
    262167        try: 
    263             self.sequence.AddElement(RapierObjects.Rect(ri_rect.width, ri_rect.height)) 
     168            ro = RapierObjects.Rect(ri_rect.width, ri_rect.height) 
     169            ro.SetColors(**self.context.GetColors()) 
     170            if ro: self.context.sequence.AddElement(ro) 
    264171        finally: 
    265172            self.PopContext(ri_rect) 
    …… 
    268175        self.PushContext(ri_circle) 
    269176        try: 
    270             warnings.warn( "TODO: DisplayCircle") 
     177            ro = RapierObjects.Circle(ri_circle.cx, ri_circle.cy, ri_circle.r) 
     178            ro.SetColors(**self.context.GetColors()) 
     179            if ro: self.context.sequence.AddElement(ro) 
    271180        finally: 
    272181            self.PopContext(ri_circle) 
    …… 
    275184        self.PushContext(ri_ellipse) 
    276185        try: 
    277             warnings.warn( "TODO: DisplayEllipse") 
     186            ro = RapierObjects.Ellipse(ri_ellipse.cx, ri_ellipse.cy, ri_ellipse.rx, ri_ellipse.ry) 
     187            ro.SetColors(**self.context.GetColors()) 
     188            if ro: self.context.sequence.AddElement(ro) 
    278189        finally: 
    279190            self.PopContext(ri_ellipse) 
    …… 
    282193        self.PushContext(ri_polygon) 
    283194        try: 
    284             self.sequence.AddElement(RapierObjects.Polygon(ri_polygon.points)) 
     195            ro = RapierObjects.Polygon(ri_polygon.points) 
     196            ro.SetColors(**self.context.GetColors()) 
     197            if ro: self.context.sequence.AddElement(ro) 
    285198        finally: 
    286199            self.PopContext(ri_polygon) 
    …… 
    289202        self.PushContext(ri_polyline) 
    290203        try: 
    291             self.sequence.AddElement(RapierObjects.Polyline(ri_polyline.points)) 
     204            ro = RapierObjects.Polyline(ri_polyline.points) 
     205            ro.SetColors(**self.context.GetColors()) 
     206            if ro: self.context.sequence.AddElement(ro) 
    292207        finally: 
    293208            self.PopContext(ri_polyline) 
    …… 
    297212        try: 
    298213            pathlist = ri_path.path.RestoreTo(self.PathFactory()).pathlist 
    299             self.sequence.AddElement(RapierObjects.Path(pathlist)) 
     214            ro = RapierObjects.Path(pathlist) 
     215            ro.SetColors(**self.context.GetColors()) 
     216            if ro: self.context.sequence.AddElement(ro) 
    300217        finally: 
    301218            self.PopContext(ri_path) 
    …… 
    304221        self.PushContext(ri_text) 
    305222        try: 
    306             warnings.warn( "TODO: DisplayText") 
     223            ro = RapierObjects.Text() 
     224            ro.SetColors(**self.context.GetColors()) 
     225            if ro: self.context.sequence.AddElement(ro) 
    307226        finally: 
    308227            self.PopContext(ri_text) 
    …… 
    312231    def ResolveReference(self, reference): 
    313232        base, tag = reference 
    314         return self.resolver[-1].get(tag, None) 
     233        return self.context.resolver.get(tag, None) 
    315234 
    316235    def PushContext(self, ri, extendTransform=False): 
    317         self.context.append([self.sequence, self.style]) 
     236        self.contextstack.append(self.context) 
     237        self.context = self.context.Branch() 
    318238 
    319239        if extendTransform: 
    …… 
    324244 
    325245    def PopContext(self, ri): 
    326         self.sequence, self.style = self.context.pop() 
     246        self.context = self.contextstack.pop() 
    327247 
    328248    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    …… 
    330250    def PushSequence(self): 
    331251        newsequence = self.SequenceFactory() 
    332         self.sequence.AddElement(newsequence.Execute) 
    333         self.sequence = newsequence  
    334         return self.sequence 
     252        self.context.sequence.AddElement(newsequence.Execute) 
     253        self.context.sequence = newsequence  
     254        return newsequence 
    335255 
    336256    def _DoStyle(self, ri): 
    337         try: newstyle = ri.style 
     257        try: style = ri.style 
    338258        except AttributeError: pass 
    339259 
    340         if newstyle: 
    341             self.style = self.style.copy() 
    342             self.style.update(newstyle) 
    343  
    344         if self.style: 
    345             color = self.style.get('fill') or self.style.get('stroke') 
    346             if color: 
    347                 self.sequence.AddElement(RapierObjects.Color(color)) 
     260        if style: 
     261            if 'color' in style: 
     262                self.context.currentColor = style['color'] 
     263 
     264            # fill 
     265            if 'fill' in style: 
     266                fillcolor = style['fill'] 
     267                if fillcolor == 'currentColor': 
     268                    fillcolor = self.context.currentColor 
     269                self.context.fillcolor = fillcolor 
     270 
     271            if 'fill-opacity' in style: 
     272                self.context.fillopacity = style['fill-opacity'] 
     273 
     274            # stroke 
     275            if 'stroke' in style: 
     276                strokecolor = style['stroke'] 
     277                if strokecolor == 'currentColor': 
     278                    strokecolor = self.context.currentColor 
     279                self.context.strokecolor = strokecolor 
     280 
     281            if 'stroke-opacity' in style: 
     282                self.context.strokeopacity = style['stroke-opacity'] 
    348283 
    349284    def _DoTransform(self, ri): 
    …… 
    367302 
    368303    def _DoExtendedTransform(self, ri): 
    369         l, b, w, h = ri.viewBox 
    370         xform = Transformations.OrthographicMgd(None, True, l, l+w, b, b+h) 
     304        x, y, w, h = ri.viewBox 
     305        xform = Transformations.OrthographicMgd(None, True, x, x+w, y, y+h) 
    371306 
    372307        sequence = self.PushSequence() 

  • trunk/RBRapier/RBRapier/Formats/Attic/SVG.old/Renderers/RapierObjects.py

    r631 r634  
    2727from OpenGL import GL 
    2828 
     29from RBRapier.Tools.Geometry.gluPolygonTesselation import gluPolygonTesselator 
     30 
     31import Abstract 
     32 
    2933#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    3034#~ Definitions  
    3135#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    3236 
    33 class Color(object): 
    34     __slots__ = 'color', 
    35  
    36     def __init__(self, color): 
    37         self.color = color 
    38  
    39     def Execute(self, context): 
    40         GL.glColor3ubv(self.color) 
    41  
    42 class Rect(object): 
     37class Base(object): 
     38    __slots__ = 'strokecolor', 'fillcolor' 
     39 
     40    def SetColors(self, stroke, fill): 
     41        self.strokecolor = stroke 
     42        self.fillcolor = fill 
     43 
     44#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     45 
     46class Text(Base): 
     47    __slots__ = () 
     48 
     49    def __nonzero__(self): 
     50        return False 
     51 
     52    def __init__(self): 
     53        warnings.warn( "TODO: Text") 
     54 
     55    def Execute(self, context): 
     56        pass 
     57 
     58#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     59 
     60class Line(Base): 
     61    __slots__ = 'v0', 'v1' 
     62 
     63    def __init__(self, v0, v1): 
     64        self.v0 = v0 
     65        self.v1 = v1 
     66 
     67    def Execute(self, context): 
     68        if self.strokecolor: 
     69            GL.glColor4ubv(self.strokecolor) 
     70 
     71        GL.glBegin(GL.GL_LINES) 
     72        GL.glVertex2fv(self.v0) 
     73        GL.glVertex2fv(self.v1) 
     74        GL.glEnd() 
     75 
     76#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     77 
     78class Rect(Base): 
    4379    __slots__ = 'w', 'h' 
    4480 
    …… 
    4884 
    4985    def Execute(self, context): 
     86        if self.fillcolor: 
     87            GL.glColor4ubv(self.fillcolor) 
     88        elif self.strokecolor: 
     89            GL.glColor4ubv(self.strokecolor) 
    5090        GL.glRectf(0., 0., self.w, self.h) 
    5191 
    52 def Line(v0, v1): 
    53     return Polyline((v0, v1)) 
    54  
    55 class Polyline(object): 
    56     __slots__ = 'vertices', 
    57  
    58     def __init__(self, vertices): 
    59         self.vertices = vertices 
    60  
    61     def Execute(self, context): 
    62         GL.glBegin(GL.GL_LINE_STRIP) 
    63         for v in self.vertices: 
    64             GL.glVertex2fv(v) 
    65         GL.glEnd() 
    66  
    67 def Polygon(*args): 
    68     warnings.warn( "TODO: Polygon") 
    69     return Polyline(*args) 
    70  
    71 class Path(object): 
    72     __slots__ = 'paths', 
     92#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     93 
     94class Ellipse(Base): 
     95    __slots__ = 'cx', 'cy', 'rx', 'ry' 
     96 
     97    def __init__(self, cx, cy, rx, ry): 
     98        self.cx = cx 
     99        self.cy = cy 
     100        self.rx = rx 
     101        self.ry = ry 
     102        warnings.warn( "TODO: Ellipse") 
     103 
     104    def Execute(self, context): 
     105        if self.fillcolor: 
     106            GL.glColor4ubv(self.fillcolor) 
     107        elif self.strokecolor: 
     108            GL.glColor4ubv(self.strokecolor) 
     109 
     110        x0 = self.cx - self.rx 
     111        y0 = self.cy - self.ry 
     112        x1 = self.cx + self.rx 
     113        y1 = self.cy + self.ry 
     114        GL.glRectf(x0, y0, x1, y1) 
     115 
     116#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     117 
     118class Circle(Ellipse): 
     119    def __init__(self, cx, cy, r): 
     120        warnings.warn( "TODO: Circle") 
     121        Ellipse.__init__(self, cx, cy, r, r) 
     122 
     123#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     124 
     125class Polyline(Base): 
     126    __slots__ = 'verticies', 'listid' 
     127 
     128    def __init__(self, verticies): 
     129        self.verticies = [(x,y,0) for x,y in verticies] 
     130        self.listid = None 
     131 
     132    def Execute(self, context): 
     133        if self.listid is None: 
     134            self.listid = GL.glGenLists(1) 
     135            GL.glNewList(self.listid, GL.GL_COMPILE) 
     136            gluPolygonTesselator([self.verticies]) 
     137            GL.glEndList() 
     138            self.verticies = None 
     139 
     140        if self.fillcolor: 
     141            GL.glColor4ubv(self.fillcolor) 
     142        GL.glCallList(self.listid) 
     143 
     144        #if self.strokecolor: 
     145        #    GL.glColor4ubv(self.strokecolor) 
     146        #GL.glCallList(self.listid) 
     147 
     148#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     149 
     150class Polygon(Polyline): 
     151    pass 
     152 
     153#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     154 
     155class Path(Base): 
     156    __slots__ = 'paths', 'listid' 
    73157 
    74158    def __init__(self, paths): 
    75159        self.paths = paths 
    76  
    77     def Execute(self, context): 
    78         for vertices in self.paths: 
    79             GL.glBegin(GL.GL_LINE_STRIP) 
    80             for v in vertices: 
    81                 GL.glVertex2fv(v) 
    82             GL.glEnd() 
    83  
     160        self.listid = None 
     161 
     162    def Execute(self, context): 
     163        if self.listid is None: 
     164            self.listid = GL.glGenLists(1) 
     165            GL.glNewList(self.listid, GL.GL_COMPILE) 
     166            if self.fillcolor: 
     167                gluPolygonTesselator(self.paths) 
     168            else: 
     169                for verticies in self.paths: 
     170                    GL.glBegin(GL.GL_LINE_STRIP) 
     171                    for v in verticies: 
     172                        GL.glVertex2fv(v) 
     173                    GL.glEnd() 
     174            GL.glEndList() 
     175            self.paths = None 
     176 
     177        if self.fillcolor: 
     178            GL.glColor4ubv(self.fillcolor) 
     179        elif self.strokecolor: 
     180            GL.glColor4ubv(self.strokecolor) 
     181        GL.glCallList(self.listid) 
     182 
     183#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     184#~ Paths 
     185#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     186 
     187class RapierPathFactory(Abstract.AbstractPathFactory): 
     188    __slots__ = 'pos', 'pathlist' 
     189 
     190    def BeginPath(self, pathstr):  
     191        self.pathlist = [] 
     192        self.pos = 0., 0. 
     193 
     194    def AddPathElement(self, name, *args): 
     195        name, relative = self.command_table[name] 
     196        getattr(self, name.lower())(relative, *args) 
     197 
     198    def EndPath(self, pathstr):  
     199        pass 
     200 
     201    def move(self, relative, x, y):  
     202        if relative: 
     203            dx, dy = self.pos 
     204            x += dx 
     205            y += dy 
     206        self.pathlist.append([(x,y)]) 
     207        self.pos = x,y 
     208 
     209    def closepath(self, relative):  
     210        lastpath = self.pathlist[-1] 
     211        self.pos = lastpath[0] 
     212        lastpath.append(self.pos) 
     213 
     214    def line(self, relative, x, y):  
     215        if relative: 
     216            dx, dy = self.pos 
     217            x += dx 
     218            y += dy 
     219        self.pathlist[-1].append((x,y)) 
     220        self.pos = x,y 
     221 
     222    def hline(self, relative, x):  
     223        dx, y = self.pos 
     224        if relative: 
     225            x += dx 
     226        self.pathlist[-1].append((x,y)) 
     227        self.pos = x,y 
     228 
     229    def vline(self, relative, y):  
     230        x, dy = self.pos 
     231        if relative: 
     232            y += dy 
     233        self.pathlist[-1].append((x,y)) 
     234        self.pos = x,y 
     235 
     236    def cubicbezier(self, relative, x1, y1, x2, y2, x, y):  
     237        if relative: 
     238            dx, dy = self.pos 
     239            x1 += dx 
     240            y1 += dy 
     241            x2 += dx 
     242            y2 += dy 
     243            x += dx 
     244            y += dy 
     245        warnings.warn( "TODO: path.cubicbezier") 
     246        self.pathlist[-1].append((x,y)) 
     247        self.pos = x,y 
     248 
     249    def smoothcurve(self, relative, x2, y2, x, y):  
     250        if relative: 
     251            dx, dy = self.pos 
     252            x2 += dx 
     253            y2 += dy 
     254            x += dx 
     255            y += dy 
     256        warnings.warn( "TODO: path.smoothcurve") 
     257        self.pathlist[-1].append((x,y)) 
     258        self.pos = x,y 
     259 
     260    def quadraticbezier(self, relative, x1, y1, x, y):  
     261        if relative: 
     262            dx, dy = self.pos 
     263            x1 += dx 
     264            y1 += dy 
     265            x += dx 
     266            y += dy 
     267        warnings.warn( "TODO: path.quadraticbezier") 
     268        self.pathlist[-1].append((x,y)) 
     269        self.pos = x,y 
     270 
     271    def smoothquadraticbezier(self, relative, x, y):  
     272        if relative: 
     273            dx, dy = self.pos 
     274            x += dx 
     275            y += dy 
     276        warnings.warn( "TODO: path.smoothquadraticbezier") 
     277        self.pathlist[-1].append((x,y)) 
     278        self.pos = x,y 
     279 
     280    def ellipticarc(self, relative, rx, ry, xrotation, largeArcFlag, sweepFlag, x, y):  
     281        if relative: 
     282            dx, dy = self.pos 
     283            x += dx 
     284            y += dy 
     285        warnings.warn( "TODO: path.ellipticarc") 
     286        self.pathlist[-1].append((x,y)) 
     287        self.pos = x,y 
     288 
     289#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     290#~ Transforms 
     291#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     292 
     293class RapierTransformFactory(object): 
     294    def __init__(self, xform): 
     295        pass 
     296 
     297    def BeginTransform(self, transformstr):  
     298        pass 
     299    def AddTransformElement(self, name, *args):  
     300        pass 
     301    def EndTransform(self, transformstr):  
     302        pass 
     303 
     304    def translate(self, x=0.0, y=0.0):  
     305        warnings.warn( "TODO: transform.translate") 
     306    def scale(self, x=1., y=None):  
     307        warnings.warn( "TODO: transform.scale") 
     308    def rotate(self, angle=0.0, x=0, y=0):  
     309        warnings.warn( "TODO: transform.rotate") 
     310    def skewx(self, angle=0.0):  
     311        warnings.warn( "TODO: transform.skewx") 
     312    def skewy(self, angle=0.0):  
     313        warnings.warn( "TODO: transform.skewy") 
     314    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):  
     315        warnings.warn( "TODO: transform.matrix") 
     316 
     317#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     318 

  • trunk/RBRapier/RBRapier/Formats/Attic/SVG.old/SVGSkin/RenderItems/Common.py

    r631 r634  
    2424#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    2525 
     26import re 
    2627import TransformBuilder 
     28 
     29#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     30#~ Constants / Variables / Etc.  
     31#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     32 
     33_re_coordwithunits = re.compile(r'([-+]?(?:\d+(?:\.\d*)?|\d*\.\d+)(?:[eE][-+]?\d+)?)(\w*)') 
    2734 
    2835#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    …… 
    128135 
    129136    def _asCoord(self, coord): 
    130         return float(coord) 
     137        try: 
     138            return float(coord) 
     139        except ValueError: 
     140            match = _re_coordwithunits.match(coord) 
     141            if match: 
     142                value, units = match.groups() 
     143                return float(value) 
    131144 
    132145    def _asCoordTuple(self, coords): 

  • trunk/RBRapier/RBRapier/Formats/Attic/SVG.old/SVGSkin/RenderItems/Groups.py

    r631 r634  
    151151                alignment, specifier = alignment.split() 
    152152            else: specifier = 'meet' 
    153             return [alignment[0:4], alignment[4:8], specifier.strip().lower()] 
     153            return [alignment[0:4], alignment[4:8], specifier.lower()] 
    154154 
    155155    def _asViewBox(self, viewBox): 

  • trunk/RBRapier/RBRapier/Formats/Attic/SVG.old/SVGSkin/RenderItems/Styled.py

    r631 r634  
    134134 
    135135        "stroke": _asColor, 
    136         "stroke-width": TransformableRenderItem._asCoord, 
    137136        "stroke-opacity": _asOpacity, 
    138         "stroke-dasharray": _asDashArray, 
    139         "stroke-linecap": _asString, 
    140         "stroke-linejoin": _asString, 
    141         "stroke-meterlimit": _asString, 
     137        #"stroke-width": TransformableRenderItem._asCoord, 
     138        #"stroke-dasharray": _asDashArray, 
     139        #"stroke-linecap": _asString, 
     140        #"stroke-linejoin": _asString, 
     141        #"stroke-meterlimit": _asString, 
    142142 
    143143        "fill": _asColor, 

  • trunk/RBRapier/RBRapier/Renderer/SequenceMgr.py

    r457 r634  
    6262        self.OnEndExecute = SubjectList() 
    6363 
     64    def __len__(self): 
     65        return len(self.Elements) 
     66 
    6467    def AddSetupElement(self, Element, PriorityDelta=0): 
    6568        self._AddElement(Element, self.SetupPhase + PriorityDelta) 
    …… 
    103106        if priority <= 0: 
    104107            idx = bisect.bisect_right(self.Elements, (priority, _MatchAll, _MatchAll)) 
    105         else: idx = bisect.bisect_left(self.Elements, (priority, _MatchAll, _MatchAll)) 
     108        else:  
     109            idx = bisect.bisect_left(self.Elements, (priority, _MatchAll, _MatchAll)) 
     110 
    106111        if isinstance(Element, types.MethodType): 
    107112            ElementFn, Element = Element, Element.im_self 
    108         elif isinstance(getattr(Element, 'Execute', None), types.MethodType): 
     113        elif callable(getattr(Element, 'Execute', None)): 
    109114            ElementFn = Element.Execute 
    110         elif isinstance(getattr(Element, 'Select', None), types.MethodType): 
     115        elif callable(getattr(Element, 'Select', None)): 
    111116            ElementFn = Element.Select 
     117        else: 
     118            raise ValueError, "Unsuppored element type %r: %r" % (type(Element), Element) 
     119 
    112120        self.Elements.insert(idx, (priority, ElementFn, Element)) 
    113121 

  • trunk/RBRapier/RBRapier/Renderer/View/Transformations.py

    r379 r634  
    5050    def __init__(self, Mode=None, Save=0, *args, **kw): 
    5151        super(ManagedTransformationMixin, self).__init__(*args, **kw) 
    52         self.Mode = Mode 
    53         self.Save = Save 
     52        if Mode is not None: 
     53            self.Mode = Mode 
     54        if Save is not 0: 
     55            self.Save = Save 
    5456 
    5557    def Select(self, context): 

  • trunk/RBRapier/RBRapier/Tools/Projections.py

    r362 r634  
    6464        self.Right, self.Top, self.Far = Higher 
    6565 
    66     def _getWidth(self): 
     66    def GetWidth(self): 
    6767        return self.Right - self.Left 
    68     def _setWidth(self, value): 
     68    def SetWidth(self, value): 
    6969        delta = (self.Width - value) * 0.5 
    7070        self.Right -= delta 
    7171        self.Left += delta 
    72     Width = property(_getWidth, _setWidth) 
    73     def _getHCenter(self, mult=0.5): 
     72    Width = property(GetWidth, SetWidth) 
     73    def GetHCenter(self, mult=0.5): 
    7474        return (self.Left + self.Right) * mult 
    75     def _setHCenter(self, value): 
     75    def SetHCenter(self, value): 
    7676        hw = self.Width * 0.5 
    7777        self.Right = value + hw 
    7878        self.Left = value - hw 
    79     HCenter = property(_getHCenter, _setHCenter) 
    80  
    81     def _getHeight(self): 
     79    HCenter = property(GetHCenter, SetHCenter) 
     80 
     81    def GetHeight(self): 
    8282        return self.Top - self.Bottom 
    83     def _setHeight(self, value): 
     83    def SetHeight(self, value): 
    8484        delta = (self.Height - value) * 0.5 
    8585        self.Top -= delta 
    8686        self.Bottom += delta 
    87     Height = property(_getHeight, _setHeight) 
    88     def _getVCenter(self, mult=0.5): 
     87    Height = property(GetHeight, SetHeight) 
     88    def GetVCenter(self, mult=0.5): 
    8989        return (self.Top + self.Bottom) * mult 
    90     def _setVCenter(self, value): 
     90    def SetVCenter(self, value): 
    9191        hw = self.Height * 0.5 
    9292        self.Top = value + hw 
    9393        self.Bottom = value - hw 
    94     VCenter = property(_getVCenter, _setVCenter) 
    95  
    96     def _getDeprojh(self): 
     94    VCenter = property(GetVCenter, SetVCenter) 
     95 
     96    def GetDeprojh(self): 
    9797        return self.Far - self.Near 
    98     def _setDeprojh(self, value): 
     98    def SetDeprojh(self, value): 
    9999        delta = (self.Deprojh - value) * 0.5 
    100100        self.Far -= delta 
    101101        self.Near += delta 
    102     Deprojh = property(_getDeprojh, _setDeprojh) 
    103     def _getDCenter(self, mult=0.5): 
     102    Deprojh = property(GetDeprojh, SetDeprojh) 
     103    def GetDCenter(self, mult=0.5): 
    104104        return (self.Far + self.Near) * mult 
    105     def _setDCenter(self, value): 
     105    def SetDCenter(self, value): 
    106106        hw = self.Deprojh * 0.5 
    107107        self.Far = value + hw 
    108108        self.Near = value - hw 
    109     DCenter = property(_getDCenter, _setDCenter) 
    110  
    111     def _getCenter(self): 
     109    DCenter = property(GetDCenter, SetDCenter) 
     110 
     111    def GetCenter(self): 
    112112        return (self.HCenter, self.VCenter, self.DCenter) 
    113     def _setCenter(self, value): 
     113    def SetCenter(self, value): 
    114114        self.HCenter, self.VCenter, self.DCenter = value 
    115     Center = property(_getCenter, _setCenter) 
    116     def _getDimensions(self): 
     115    Center = property(GetCenter, SetCenter) 
     116    def GetDimensions(self): 
    117117        return (self.Width, self.Height, self.Deprojh) 
    118     def _setDimensions(self, value): 
     118    def SetDimensions(self, value): 
    119119        self.Width, self.Height, self.Deprojh = value 
    120     Dimensions = property(_getDimensions, _setDimensions) 
     120    Dimensions = property(GetDimensions, SetDimensions) 
     121 
     122    def GetAspectRatio(self): 
     123        return self.Height / self.Width 
     124    def SetAspectRatio(self, value, byWidth=None): 
     125        if byWidth is None: 
     126            byWidth = value < 1 #self.Width < self.Height 
     127        if byWidth: 
     128            self.Width = self.Height / float(value) 
     129        else: 
     130            self.Height = self.Width * float(value) 
     131    AspectRatio = property(GetAspectRatio, SetAspectRatio) 
    121132 
    122133    def _asTuple(self): 
    …… 
    144155        height = self.Height 
    145156        deprojh = self.Deprojh 
    146         xoff = self._getHCenter(1.) / width 
    147         yoff = self._getVCenter(1.) / height 
    148         zoff = self._getDCenter(1.) / deprojh 
     157        xoff = self.GetHCenter(1.) / width 
     158        yoff = self.GetVCenter(1.) / height 
     159        zoff = self.GetDCenter(1.) / deprojh 
    149160 
    150161        result = Numeric.asarray([ 
    …… 
    208219        halfheight = 0.5 * self.Height 
    209220        halfdeprojh = 0.5 * self.Deprojh 
    210         xoff = self._getHCenter() 
    211         yoff = self._getVCenter() 
    212         zoff = self._getDCenter() 
     221        xoff = self.GetHCenter() 
     222        yoff = self.GetVCenter() 
     223        zoff = self.GetDCenter() 
    213224 
    214225