Changeset 147 for nodebox/trunk/src/DrawingPrimitives.py

Timestamp:

09/18/07 10:59:03 (16 months ago)

Author:

fdb

Message:

- Put direct objects on the canvas, not bound methods
- Add "ClippingPath?" object -- object contains BezierPath? and other grobs.
- Text now converts to unicode text.
- bezierpath.copy voor drawpath
- try/catch rond draw: "error while drawing"
- outputmode
- fixed the blacks
- inheritFromContext uses kwargs to know what to ignore
- keyword args for all states
- updated examples and play scripts

Files:

• nodebox/trunk/src/DrawingPrimitives.py (modified) (69 diffs)

nodebox/trunk/src/DrawingPrimitives.py

@@ +1 @@
+import os
+from random import choice, shuffle
 from AppKit import *
 from Foundation import *
-from random import choice, shuffle
-import os
 
 __all__ = [
@@ -13 +13 @@
         "NORMAL","FORTYFIVE",
         "NUMBER", "TEXT", "BOOLEAN","BUTTON",
-        "Point", "Grob", "BezierPath", "PathElement", "Rect", "Oval", "Color", "Transform", "Image", "Text",
+        "Point", "Grob", "BezierPath", "PathElement", "ClippingPath", "Rect", "Oval", "Color", "Transform", "Image", "Text",
         "Variable", "Canvas", "Context",
         "grid", "random","choice", "files","autotext",
@@ -48 +48 @@
 BOOLEAN = 3
 BUTTON = 4
+
+_STATE_NAMES = {
+    '_outputmode':    'outputmode',
+    '_colorrange':    'colorrange',
+    '_fillcolor':     'fill',
+    '_strokecolor':   'stroke',
+    '_strokewidth':   'strokewidth',
+    '_transform':     'transform',
+    '_transformmode': 'transformmode',
+    '_fontname':      'font',
+    '_fontsize':      'fontsize',
+    '_align':         'align',
+    '_lineheight':    'lineheight',
+}
 
 def _save():
@@ -89 +103 @@
         """Appends the grob to the canvas.
            This will result in a draw later on, when the scene graph is rendered."""
-        self._ctx._canvas.append( (self._draw) )
-
-class BezierPath(Grob):
+        self._ctx._canvas.append( self )
+        
+    def copy(self):
+        """Returns a deep copy of this grob."""
+        raise NotImplementedError, "Copy is not implemented on this Grob class."
+        
+    def inheritFromContext(self, ignore=()):
+        attrs_to_copy = list(self.__class__.stateAttributes)
+        [attrs_to_copy.remove(k) for k, v in _STATE_NAMES.items() if v in ignore]
+        _copy_attrs(self._ctx, self, attrs_to_copy)
+        
+    def checkKwargs(self, kwargs):
+        remaining = [arg for arg in kwargs.keys() if arg not in self.kwargs]
+        if remaining:
+            raise NodeBoxError, "Unknown argument(s) '%s'" % ", ".join(remaining)
+    checkKwargs = classmethod(checkKwargs)
+
+class TransformMixin(object):
+
+    """Mixin class for transformation support.
+    Adds the _transform and _transformmode attributes to the class."""
+    
+    def __init__(self):
+        self._reset()
+        
+    def _reset(self):
+        self._transform = Transform()
+        self._transformmode = CENTER
+        
+    def transform(self, mode):
+        self._transformmode = mode
+        
+    def translate(self, x, y):
+        self._transform.translate(x, y)
+        
+    def transform(self, mode=None):
+        if mode is not None:
+            self._transformmode = mode
+        return self._transformmode
+
+    def reset(self):
+        self._transform = Transform()
+
+    def rotate(self, degrees=0, radians=0):
+        self._transform.rotate(-degrees,-radians)
+
+    def translate(self, x=0, y=0):
+        self._transform.translate(x,y)
+
+    def scale(self, x=1, y=None):
+        self._transform.scale(x,y)
+
+    def skew(self, x=0, y=0):
+        self._transform.skew(x,y)
+        
+class ColorMixin(object):
+    
+    """Mixin class for color support.
+    Adds the _fillcolor, _strokecolor and _strokewidth attributes to the class."""
+
+    def __init__(self, **kwargs):
+        try:
+            self._fillcolor = Color(self._ctx, kwargs['fill'])
+        except KeyError:
+            self._fillcolor = Color(self._ctx)
+        try:
+            self._strokecolor = Color(self._ctx, kwargs['stroke'])
+        except KeyError:
+            self._strokecolor = None
+        self._strokewidth = kwargs.get('strokewidth', 1.0)
+
+    def nofill(self):
+        self._fillcolor = None
+
+    def fill(self, *args):
+        if len(args) > 0:
+            self._fillcolor = Color(self._ctx, *args)
+        return self._fillcolor
+
+    def nostroke(self):
+        self._strokecolor = None
+
+    def stroke(self, *args):
+        if len(args) > 0:
+            self._strokecolor = Color(self._ctx, *args)
+        return self._strokecolor
+
+    def strokewidth(self, width=None):
+        if width is not None:
+            self._strokewidth = width
+        return self._strokewidth
+
+class BezierPath(Grob, TransformMixin, ColorMixin):
     """A BezierPath provides a wrapper around NSBezierPath."""
-
-    def __init__(self, ctx, path=None):
-        Grob.__init__(self, ctx)
+    
+    stateAttributes = ('_fillcolor', '_strokecolor', '_strokewidth', '_transform', '_transformmode')
+    kwargs = ('fill', 'stroke', 'strokewidth')
+
+    def __init__(self, ctx, path=None, **kwargs):
+        super(BezierPath, self).__init__(ctx)
+        TransformMixin.__init__(self)
+        ColorMixin.__init__(self, **kwargs)
+        self._segment_cache = None
         if path is None:
             self.path = NSBezierPath.bezierPath()
@@ -101 +211 @@
             self.path = NSBezierPath.bezierPath()
             self.extend(path)
+        elif isinstance(path, BezierPath):
+            self.path = path.path.copy()
+            _copy_attrs(path, self, self.stateAttributes)
+        elif isinstance(path, NSBezierPath):
+            self.path = path
         else:
-            self.path = path
-        self._transform = Transform(self._ctx)
-        self.transformmode = CENTER
-        self.fillcolor = Color(self._ctx)
-        self.strokecolor = None
-        self.strokewidth = 1.0
-        self._segment_cache = None
-
-    def inheritFromContext(self):
-        self.fillcolor = self._ctx._fillcolor
-        self.strokecolor = self._ctx._strokecolor
-        self.strokewidth = self._ctx._strokewidth
-        self._transform = self._ctx._transform.copy()
-        self.transformmode = self._ctx._transformmode
-
-    def addclip(self):
-        self.inheritFromContext()
-        self._ctx._canvas.append(self._addclip)
-    addClip = addclip
-
-    def _addclip(self):
-        p = self.transform.transformBezierPath(self)
-        p.path.addClip()
-
-    def setclip(self):
-        self.inheritFromContext()
-        self._ctx._canvas.append(self._setclip)
-    setClip = setclip
-
-    def _setclip(self):
-        # XXX: setClip here has the effect of setting the clip independent of the view,
-        # meaning that we can draw over the bounds of the view, which is not good.
-        #
-        # setclip should restore the original graphicscontext (and save it back immediately
-        # so the stack is left intact) and add (not set) the clip there.
-        # Also, we need a place for endclip to store its code, since it can not
-        # be part of the current path.
-        p = self.transform.transformBezierPath(self)
-        _restore()
-        _save()
-        p.path.addClip()
+            raise NodeBoxError, "Don't know what to do with %s." % path
+
+    def copy(self):
+        return self.__class__(self._ctx, self)
 
     ### Path methods ###
@@ -176 +254 @@
     def contains(self, x, y):
         return self.path.containsPoint_((x,y))
+        
+    ### Basic shapes ###
+    
+    def rect(self, x, y, width, height):
+        self._segment_cache = None
+        self.path.appendBezierPathWithRect_( ((x, y), (width, height)) )
+        
+    def oval(self, x, y, width, height):
+        self._segment_cache = None
+        self.path.appendBezierPathWithOvalInRect_( ((x, y), (width, height)) )
+        
+    def line(self, x1, y1, x2, y2):
+        self._segment_cache = None
+        self.path.moveToPoint_( (x1, y1) )
+        self.path.lineToPoint_( (x2, y2) )
 
     ### List methods ###
@@ -216 +309 @@
         trans = self._transform.copy()
 
-        if (self.transformmode == CENTER):
+        if (self._transformmode == CENTER):
             (x, y), (w, h) = self.bounds
             deltax = x+w/2
             deltay = y+h/2
-            t = Transform(self._ctx)
+            t = Transform()
             t.translate(-deltax,-deltay)
             trans.prepend(t)
-            t = Transform(self._ctx)
+            t = Transform()
             t.translate(deltax,deltay)
             trans.append(t)
@@ -234 +327 @@
         _save()
         self.transform.concat()
-        if (self.fillcolor):
-            self.fillcolor.set()
+        if (self._fillcolor):
+            self._fillcolor.set()
             self.path.fill()
-        if (self.strokecolor):
-            self.strokecolor.set()
-            self.path.setLineWidth_(self.strokewidth)
+        if (self._strokecolor):
+            self._strokecolor.set()
+            self.path.setLineWidth_(self._strokewidth)
             self.path.stroke()
         _restore()
@@ -286 +379 @@
 
 class PathElement(object):
+
     def __init__(self, cmd=None, pts=None):
         self.cmd = cmd
@@ -312 +406 @@
             self.ctrl1 = Point()
             self.ctrl2 = Point()
-        #else:
-        #    raise NodeBoxError, "PathElement: unknown command %s" % cmd
 
     def __repr__(self):
@@ -335 +427 @@
         return not self.__eq__(other)
 
+class ClippingPath(Grob):
+
+    def __init__(self, ctx, path):
+        self._ctx = ctx
+        self.path = path
+        self._grobs = []
+        
+    def append(self, grob):
+        self._grobs.append(grob)
+        
+    def _draw(self):
+        _save()
+        cp = self.path.transform.transformBezierPath(self.path)
+        cp.path.addClip()
+        for grob in self._grobs:
+            grob._draw()
+        _restore()
+
 class Rect(BezierPath):
-    def __init__(self, ctx, x, y, width, height):
+
+    def __init__(self, ctx, x, y, width, height, **kwargs):
         r = (x,y), (width,height)
-        BezierPath.__init__(self, ctx, NSBezierPath.bezierPathWithRect_(r))
+        super(Rect, self).__init__(ctx, NSBezierPath.bezierPathWithRect_(r), **kwargs)
+
+    def copy(self):
+        raise NotImplementedError, "Please don't use Rect anymore"
 
 class Oval(BezierPath):
-    def __init__(self, ctx, x, y, width, height):
+
+    def __init__(self, ctx, x, y, width, height, **kwargs):
         r = (x,y), (width,height)
-        BezierPath.__init__(self, ctx, NSBezierPath.bezierPathWithOvalInRect_(r))
+        super(Oval, self).__init__(ctx, NSBezierPath.bezierPathWithOvalInRect_(r), **kwargs)
+
+    def copy(self):
+        raise NotImplementedError, "Please don't use Oval anymore"
 
 class Color(object):
@@ -352 +470 @@
 
         # Decompose the arguments into tuples. 
-        # This is done in a loop, because giving a fill with a tuple
-        # wraps the tuple in a tuple.
-        while(params == 1 and isinstance(args[0], tuple)):
+        if params == 1 and isinstance(args[0], tuple):
             args = args[0]
             params = len(args)
@@ -365 +481 @@
             args = self._normalizeList(args)
             g, = args
-            clr = NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(0, 0, 0, 1.0-g, 1)
+            clr = NSColor.colorWithDeviceWhite_alpha_(g, 1)
         elif params == 2: # Gray and alpha
             args = self._normalizeList(args)
             g, a = args
-            clr = NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(0, 0, 0, 1.0-g, a)
+            clr = NSColor.colorWithDeviceWhite_alpha_(g, a)
         elif params == 3 and self._ctx._colormode == RGB: # RGB, no alpha
             args = self._normalizeList(args)
             r,g,b = args
-            clr = NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, 1)
+            clr = NSColor.colorWithDeviceRed_green_blue_alpha_(r, g, b, 1)
         elif params == 3 and self._ctx._colormode == HSB: # HSB, no alpha
             args = self._normalizeList(args)
             h, s, b = args
-            clr = NSColor.colorWithCalibratedHue_saturation_brightness_alpha_(h, s, b, 1)
+            clr = NSColor.colorWithDeviceHue_saturation_brightness_alpha_(h, s, b, 1)
         elif params == 4 and self._ctx._colormode == RGB: # RGB and alpha
             args = self._normalizeList(args)
             r,g,b, a = args
-            clr = NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, a)
+            clr = NSColor.colorWithDeviceRed_green_blue_alpha_(r, g, b, a)
         elif params == 4 and self._ctx._colormode == HSB: # HSB and alpha
             args = self._normalizeList(args)
             h, s, b, a = args
-            clr = NSColor.colorWithCalibratedHue_saturation_brightness_alpha_(h, s, b, a)
+            clr = NSColor.colorWithDeviceHue_saturation_brightness_alpha_(h, s, b, a)
         elif params == 4 and self._ctx._colormode == CMYK: # CMYK, no alpha
             args = self._normalizeList(args)
@@ -395 +511 @@
             clr = NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(c, m, y, k, a)
         else:
-            clr = NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_(0, 0, 0, 1, 1)
+            clr = NSColor.colorWithDeviceWhite_alpha_(0, 1)
 
         self._cmyk = clr.colorUsingColorSpaceName_(NSDeviceCMYKColorSpace)
-        self._rgb = clr.colorUsingColorSpaceName_(NSCalibratedRGBColorSpace)
+        self._rgb = clr.colorUsingColorSpaceName_(NSDeviceRGBColorSpace)
 
     def __repr__(self):
@@ -405 +521 @@
 
     def set(self):
-        self._cmyk.set()
+        if self._ctx._outputmode == RGB:
+            self._rgb.set()
+        else:
+            self._cmyk.set()
 
     def copy(self):
-        return self.__class__(color=self._rgb.copy())
+        new = self.__class__(self._ctx)
+        new._rgb = self._rgb.copy()
+        new._updateCmyk()
+        return new
 
     def _updateCmyk(self):
@@ -414 +536 @@
 
     def _updateRgb(self):
-        self._rgb = self._cmyk.colorUsingColorSpaceName_(NSCalibratedRGBColorSpace)
+        self._rgb = self._cmyk.colorUsingColorSpaceName_(NSDeviceRGBColorSpace)
 
     def _get_hue(self):
@@ -421 +543 @@
         val = self._normalize(val)
         h, s, b, a = self._rgb.getHue_saturation_brightness_alpha_()
-        self._rgb = NSColor.colorWithCalibratedHue_saturation_brightness_alpha_(val, s, b, a)
+        self._rgb = NSColor.colorWithDeviceHue_saturation_brightness_alpha_(val, s, b, a)
         self._updateCmyk()
     h = hue = property(_get_hue, _set_hue, doc="the hue of the color")
@@ -430 +552 @@
         val = self._normalize(val)
         h, s, b, a = self._rgb.getHue_saturation_brightness_alpha_()
-        self._rgb = NSColor.colorWithCalibratedHue_saturation_brightness_alpha_(h, val, b, a)
+        self._rgb = NSColor.colorWithDeviceHue_saturation_brightness_alpha_(h, val, b, a)
         self._updateCmyk()
     s = saturation = property(_get_saturation, _set_saturation, doc="the saturation of the color")
@@ -439 +561 @@
         val = self._normalize(val)
         h, s, b, a = self._rgb.getHue_saturation_brightness_alpha_()
-        self._rgb = NSColor.colorWithCalibratedHue_saturation_brightness_alpha_(h, s, val, a)
+        self._rgb = NSColor.colorWithDeviceHue_saturation_brightness_alpha_(h, s, val, a)
         self._updateCmyk()
     v = brightness = property(_get_brightness, _set_brightness, doc="the brightness of the color")
@@ -448 +570 @@
         val = self._normalize(val)
         h, s, b, a = values
-        self._rgb = NSColor.colorWithCalibratedHue_saturation_brightness_alpha_(h, s, b, a)
+        self._rgb = NSColor.colorWithDeviceHue_saturation_brightness_alpha_(h, s, b, a)
         self._updateCmyk()
     hsba = property(_get_hsba, _set_hsba, doc="the hue, saturation, brightness and alpha of the color")
@@ -457 +579 @@
         val = self._normalize(val)
         r, g, b, a = self._rgb.getRed_green_blue_alpha_()
-        self._rgb = NSColor.colorWithCalibratedRed_green_blue_alpha_(val, g, b, a)
+        self._rgb = NSColor.colorWithDeviceRed_green_blue_alpha_(val, g, b, a)
         self._updateCmyk()
     r = red = property(_get_red, _set_red, doc="the red component of the color")
@@ -466 +588 @@
         val = self._normalize(val)
         r, g, b, a = self._rgb.getRed_green_blue_alpha_()
-        self._rgb = NSColor.colorWithCalibratedRed_green_blue_alpha_(r, val, b, a)
+        self._rgb = NSColor.colorWithDeviceRed_green_blue_alpha_(r, val, b, a)
         self._updateCmyk()
     g = green = property(_get_green, _set_green, doc="the green component of the color")
@@ -475 +597 @@
         val = self._normalize(val)
         r, g, b, a = self._rgb.getRed_green_blue_alpha_()
-        self._rgb = NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, val, a)
+        self._rgb = NSColor.colorWithDeviceRed_green_blue_alpha_(r, g, val, a)
         self._updateCmyk()
     b = blue = property(_get_blue, _set_blue, doc="the blue component of the color")
@@ -484 +606 @@
         val = self._normalize(val)
         r, g, b, a = self._rgb.getRed_green_blue_alpha_()
-        self._rgb = NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, val)
+        self._rgb = NSColor.colorWithDeviceRed_green_blue_alpha_(r, g, b, val)
         self._updateCmyk()
     a = alpha = property(_get_alpha, _set_alpha, doc="the alpha component of the color")
@@ -493 +615 @@
         val = self._normalizeList(val)
         r, g, b, a = val
-        self._rgb = NSColor.colorWithCalibratedRed_green_blue_alpha_(r, g, b, a)
+        self._rgb = NSColor.colorWithDeviceRed_green_blue_alpha_(r, g, b, a)
         self._updateCmyk()
     rgba = property(_get_rgba, _set_rgba, doc="the red, green, blue and alpha values of the color")
@@ -556 +678 @@
 color = Color
 
-def Gray(ctx, g, alpha=1):
-    return Color(ctx, g, g, g, alpha)
-
 class Transform(object):
-    def __init__(self, ctx, transform=None):
-        self._ctx = ctx
+    def __init__(self, transform=None):
         if transform is None:
             transform = NSAffineTransform.transform()
@@ -577 +695 @@
 
     def copy(self):
-        return self.__class__(self._ctx, self.transform.copy())
+        return self.__class__(self.transform.copy())
 
     def __repr__(self):
@@ -611 +729 @@
         x = math.pi * x / 180
         y = math.pi * y / 180
-        t = Transform(self._ctx)
+        t = Transform()
         t.matrix = 1, math.tan(y), -math.tan(x), 1, 0, 0
         self.prepend(t)
@@ -633 +751 @@
     def transformBezierPath(self, path):
         if isinstance(path, BezierPath):
+            ctx = path._ctx
             path = path.path
+        elif isinstance(path, NSBezierPath):
+            ctx = None
+        else:
+            raise NodeBoxError, "Can only transform BezierPaths"
         path = self.transform.transformBezierPath_(path)
-        return BezierPath(self._ctx, path)
-
-class Image(Grob):
+        return BezierPath(ctx, path)
+
+class Image(Grob, TransformMixin):
+
+    stateAttributes = ('_transform', '_transformmode')
+    kwargs = ()
+
     def __init__(self, ctx, path=None, x=0, y=0, width=None, height=None, alpha=1.0, image=None, data=None):
         """
@@ -652 +779 @@
          - data: a stream of bytes of image data.
         """
-        Grob.__init__(self, ctx)
+        super(Image, self).__init__(ctx)
+        TransformMixin.__init__(self)
         if data is not None:
             d = NSData.dataWithBytes_length_(data, len(data))
@@ -684 +812 @@
         self.width = width
         self.height = height
-        self.transform = Transform(self._ctx)
         self.alpha = alpha
         self.debugImage = False
 
+    def copy(self):
+        new = self.__class__(self._ctx)
+        _copy_attrs(self, new, ('image', 'x', 'y', 'width', 'height', '_transform', '_transformmode', 'alpha', 'debugImage'))
+        return new
+
     def getSize(self):
         return self.image.size()
 
     size = property(getSize)
-
-    def inheritFromContext(self):
-        self.transform = self._ctx._transform.copy()
-        self.transformmode = self._ctx._transformmode
 
     def _draw(self):
@@ -714 +842 @@
 
             # Center-mode transforms: translate to image center
-            if self.transformmode == CENTER:
+            if self._transformmode == CENTER:
                 # This is the hardest case: center-mode transformations with given width or height.
                 # Order is very important in this code.
@@ -720 +848 @@
                 # Set the position first, before any of the scaling or transformations are done.
                 # Context transformations might change the translation, and we don't want that.
-                t = Transform(self._ctx)
+                t = Transform()
                 t.translate(self.x, self.y)
                 t.concat()
@@ -732 +860 @@
                 dX = srcW / 2
                 dY = srcH / 2
-                t = Transform(self._ctx)
+                t = Transform()
                 t.translate(dX, dY)
                 t.concat()
 
                 # Do current transformation.
-                self.transform.concat()
+                self._transform.concat()
 
                 # Move back to the previous position.
-                t = Transform(self._ctx)
+                t = Transform()
                 t.translate(-dX, -dY)
                 t.concat()
 
                 # Finally, scale the image according to the factors.
-                t = Transform(self._ctx)
+                t = Transform()
                 t.scale(factor)
                 t.concat()
             else:
                 # Do current transformation
-                self.transform.concat()
+                self._transform.concat()
                 # Scale according to width or height factor
-                t = Transform(self._ctx)
+                t = Transform()
                 t.translate(self.x, self.y) # Here we add the positioning of the image.
                 t.scale(factor)
@@ -769 +897 @@
             x,y = self.x, self.y
             # Center-mode transforms: translate to image center
-            if self.transformmode == CENTER:
+            if self._transformmode == CENTER:
                 deltaX = srcW / 2
                 deltaY = srcH / 2
-                t = Transform(self._ctx)
+                t = Transform()
                 t.translate(x+deltaX, y+deltaY)
                 t.concat()
@@ -778 +906 @@
                 y = -deltaY
             # Do current transformation
-            self.transform.concat()
+            self._transform.concat()
             # A debugImage draws a black rectangle instead of an image.
             if self.debugImage:
@@ -791 +919 @@
                 # is better: always use zero coordinates for drawAtPoint and use a transform to set the
                 # final position.
-                t = Transform(self._ctx)
+                t = Transform()