Changeset 486 for nodebox/branches/try-qt-graphics-view/nodebox/graphics/qt.py

Timestamp:

09/04/08 15:44:34 (19 months ago)

Author:

stefan

Message:

initial changes

Files:

• nodebox/branches/try-qt-graphics-view/nodebox/graphics/qt.py (modified) (37 diffs)

nodebox/branches/try-qt-graphics-view/nodebox/graphics/qt.py

@@ -3 +3 @@
 from random import choice, shuffle
 
-from PyQt4.QtGui import QPainterPath, QColor, QTransform, QBrush, QPen, QImage, QPrinter, QPainter, QFontMetrics, QFont
-from PyQt4.QtCore import Qt, QSize, QPointF, QRectF
+from PyQt4.QtGui import *
+from PyQt4.QtCore import Qt, QSize, QSizeF, QPointF, QRectF
 from PyQt4.QtSvg import QSvgGenerator
 
 from nodebox.util import _copy_attr, _copy_attrs
+from nodebox.graphics.qgraphics import *
 
 __all__ = [
@@ -36 +37 @@
 CORNER = "corner"
 
-MOVETO = 0
-LINETO = 1
-CURVETO = 2
-CLOSE = 3
+MOVETO = QPainterPath.MoveToElement
+LINETO = QPainterPath.LineToElement
+CURVETO = QPainterPath.CurveToElement
+CLOSE = "close"
 
 LEFT = 0
@@ -67 +68 @@
     '_lineheight':    'lineheight',
 }
-
-#def _save():
-#    NSGraphicsContext.currentContext().saveGraphicsState()
-
-#def _restore():
-#    NSGraphicsContext.currentContext().restoreGraphicsState()
 
 class NodeBoxError(Exception): pass
@@ -201 +196 @@
     strokewidth = property(_get_strokewidth, _set_strokewidth)
 
+
 class BezierPath(Grob, TransformMixin, ColorMixin):
     """A BezierPath provides a wrapper around QPainterPath."""
@@ -212 +208 @@
         ColorMixin.__init__(self, **kwargs)
         self._segment_cache = None
+        self._qpath_segment_cache = None
         if path is None:
             self._qpath = QPainterPath()
@@ -237 +234 @@
     def moveto(self, x, y):
         self._segment_cache = None
+        self._qpath_segment_cache = None
         self._qpath.moveTo(x, y)
 
     def lineto(self, x, y):
         self._segment_cache = None
+        self._qpath_segment_cache = None
         self._qpath.lineTo(x, y)
 
     def curveto(self, x1, y1, x2, y2, x3, y3):
         self._segment_cache = None
+        self._qpath_segment_cache = None
         self._qpath.cubicTo(x1, y1, x2, y2, x3, y3)
 
     def closepath(self):
         self._segment_cache = None
+        self._qpath_segment_cache = None
         self._qpath.closeSubpath() # XXX: Is this correct?
 
@@ -272 +273 @@
     def rect(self, x, y, width, height):
         self._segment_cache = None
+        self._qpath_segment_cache = None
         self._qpath.addRect(x, y, width, height)
         
     def oval(self, x, y, width, height):
         self._segment_cache = None
+        self._qpath_segment_cache = None
         self._qpath.addEllipse(x, y, width, height)
         
     def line(self, x1, y1, x2, y2):
         self._segment_cache = None
+        self._qpath_segment_cache = None
         self._qpath.moveTo(x1, y1)
         self._qpath.lineTo(x2, y2)
@@ -286 +290 @@
 
     def __getitem__(self, index):
-        el = self._qpath.elementAt(index)
-        return PathElement(el)
+        if self._qpath_segment_cache == None:
+            self._set_qpath_segment_cache()
+        cmd, el = self._qpath_segment_cache[index]
+        return PathElement(cmd, el)
 
     def __iter__(self):
@@ -294 +300 @@
 
     def __len__(self):
-        return self._qpath.elementCount()
+        if self._qpath_segment_cache == None:
+            self._set_qpath_segment_cache()
+        return len(self._qpath_segment_cache)
+
+    def _set_qpath_segment_cache(self):
+        self._qpath_segment_cache = []
+        length = self._qpath.elementCount()
+        temp = []
+        for i in range(length):
+            el = self._qpath.elementAt(i)
+            if el.type in [LINETO, MOVETO, CURVETO, CLOSE]:
+                temp.append(i)
+        for i in temp:
+            el = self._qpath.elementAt(i)
+            if el.type in [LINETO, MOVETO, CLOSE]:
+                self._qpath_segment_cache.append((el.type, ((el.x, el.y),)))
+            elif el.type == CURVETO:
+                ctrl1 = self._qpath.elementAt(i+1)
+                ctrl2 = self._qpath.elementAt(i+2)
+                self._qpath_segment_cache.append((el.type, ((el.x, el.y), (ctrl1.x, ctrl1.y), (ctrl2.x, ctrl2.y))))
 
     def extend(self, pathElements):
         self._segment_cache = None
+        self._qpath_segment_cache = None
         for el in pathElements:
             if isinstance(el, (list, tuple)):
@@ -313 +339 @@
     def append(self, el):
         self._segment_cache = None
+        self._qpath_segment_cache = None
         if el.cmd == MOVETO:
             self.moveto(el.x, el.y)
@@ -344 +371 @@
     transform = property(_get_transform)
 
-    def _draw(self, painter):
-        painter.save()
-        self.transform.concat(painter)
+    def _draw(self):
+        item = GraphicsPathItem()
+        self.transform.concat(item)
+        item.setPath(self._qpath)
         if self._fillcolor:
-            painter.fillPath(self._qpath, QBrush(self._fillcolor._rgb))
+            item.setBrush(QBrush(self._fillcolor._rgb))
         if self._strokecolor:
             p = QPen(QBrush(self._strokecolor._rgb), self._strokewidth)
-            painter.setPen(p)
-            painter.drawPath(self._qpath)
-        painter.restore()
+            item.setPen(p)
+        else:
+            item.setPen(QPen(Qt.NoPen))
+        self._scene.addItem(item)
+        
+    def fit(self, x=None, y=None, width=None, height=None, stretch=False):
+
+        """Fits this path to the specified bounds.
+    
+        All parameters are optional; if no parameters are specified, nothing will happen.
+        Specifying a parameter will constrain its value:
+    
+        - x: The path will be positioned at the specified x value
+        - y: The path will be positioned at the specified y value
+        - width: The path will be of the specified width
+        - height: The path will be of the specified height
+        - stretch: If both width and height are defined, either stretch the path or
+                keep the aspect ratio.
+        """
+
+        (px, py), (pw, ph) = self.bounds
+        t = Transform()
+        if x is not None and y is None:
+            t.translate(x, py)
+        elif x is None and y is not None:
+            t.translate(px, y)
+        elif x is not None and y is not None:
+            t.translate(x, y)
+        else:
+            t.translate(px, py)
+        if width is not None and height is None:
+            t.scale(width / pw)
+        elif width is None and height is not None:
+            t.scale(height / ph)
+        elif width is not None and height is not None:
+            if stretch:
+                t.scale(width /pw, height / ph)
+            else:
+                t.scale(min(width /pw, height / ph))
+        t.translate(-px, -py)
+        self._qpath = t.transformBezierPath(self)._qpath
+        self._qpath_segment_cache = None
         
     ### Mathematics ###
@@ -394 +461 @@
     def addpoint(self, t):
         import bezier
-        self._nsBezierPath = bezier.insert_point(self, t)._nsBezierPath
+        self._qpath = bezier.insert_point(self, t)._qpath
         self._segment_cache = None
+        self._qpath_segment_cache = None
+
+    ### Clipping operations ###
+
+    def intersects(self, other):
+        return self._qpath.intersects(other._qpath)
+
+    def union(self, other, flatness=0.6):
+        return BezierPath(self._ctx, self._qpath.united(other._qpath))
+
+    def intersect(self, other, flatness=0.6):
+        return BezierPath(self._ctx, self._qpath.intersected(other._qpath))
+
+    def difference(self, other, flatness=0.6):
+        return BezierPath(self._ctx, self._qpath.subtracted(other._qpath))
+
+    def xor(self, other, flatness=0.6):
+        union = self._qpath.united(other._qpath)
+        intersection = self._qpath.intersected(other._qpath)
+        return BezierPath(self._ctx, union.subtracted(intersection))
 
 class PathElement(object):
@@ -446 +533 @@
         return not self.__eq__(other)
 
+
 class ClippingPath(Grob):
 
@@ -457 +545 @@
         
     def _draw(self):
-        _save()
         cp = self.path.transform.transformBezierPath(self.path)
-        cp._nsBezierPath.addClip()
+        item = GraphicsClipItem(self._scene)
+        self._scene.addItem(item)
+        item.setPath(cp._qpath)        
+
         for grob in self._grobs:
+            grob._scene = item
             grob._draw()
-        _restore()
 
 class Rect(BezierPath):
@@ -468 +558 @@
     def __init__(self, ctx, x, y, width, height, **kwargs):
         warnings.warn("Rect is deprecated. Use BezierPath's rect method.", DeprecationWarning, stacklevel=2)
-        r = (x,y), (width,height)
-        super(Rect, self).__init__(ctx, NSBezierPath.bezierPathWithRect_(r), **kwargs)
+        p=QPainterPath()
+        p.addRect(x, y, width, height)
+        super(Rect, self).__init__(ctx, p, **kwargs)
 
     def copy(self):
@@ -478 +569 @@
     def __init__(self, ctx, x, y, width, height, **kwargs):
         warnings.warn("Oval is deprecated. Use BezierPath's oval method.", DeprecationWarning, stacklevel=2)
-        r = (x,y), (width,height)
-        super(Oval, self).__init__(ctx, NSBezierPath.bezierPathWithOvalInRect_(r), **kwargs)
+        p=QPainterPath()
+        p.addEllipse(x, y, width, height)
+        super(Oval, self).__init__(ctx, p, **kwargs)
 
     def copy(self):
         raise NotImplementedError, "Please don't use Oval anymore"
-
+        
 class Color(object):
 
@@ -519 +611 @@
             args = self._normalizeList(args)
             h, s, b = args
+            if h == 1.0:
+                h = .99998
             clr = QColor.fromHsvF(h, s, b, 1)
         elif params == 4 and self._ctx._colormode == RGB: # RGB and alpha
@@ -527 +621 @@
             args = self._normalizeList(args)
             h, s, b, a = args
+            if h == 1.0:
+                h = .99998
             clr = QColor.fromHsvF(h, s, b, a)
         elif params == 4 and self._ctx._colormode == CMYK: # CMYK, no alpha
@@ -557 +653 @@
     qColor = property(_get_qColor)
         
-
     def copy(self):
         new = self.__class__(self._ctx)
         new._rgb = QColor(self._rgb)
-        new._updateCmyk()
+#        new._updateCmyk()
         return new
 
@@ -573 +668 @@
 
     def _get_hue(self):
-        return self._rgb.hueF()
+        hue = self._rgb.hueF()
+        if round(hue, 4) == 1.0:
+            return 1.0
+        if hue < 0.0:
+            return 0.0
+        return hue
     def _set_hue(self, val):
         val = self._normalize(val)
-        c = self._rgb
-        h, s, b, a = c.hueF(), c.saturationF(), c.valueF(), c.alpha()
+        if val == 1.0:
+           val = .99998
+        h, s, b, a = self.hsba
         self._rgb.setHsvF(val, s, b, a)
         self._updateCmyk()
     h = hue = property(_get_hue, _set_hue, doc="the hue of the color")
+
+    def _get_saturation(self):
+        return self._rgb.saturationF()
+    def _set_saturation(self, val):
+        val = self._normalize(val)
+        h, s, b, a = self.hsba
+        self._rgb.setHsvF(h, val, b, a)
+        self._updateCmyk()
+    s = saturation = property(_get_saturation, _set_saturation, doc="the saturation of the color")
+
+    def _get_brightness(self):
+        return self._rgb.valueF()
+    def _set_brightness(self, val):
+        val = self._normalize(val)
+        h, s, b, a = self.hsba
+        self._rgb.setHsvF(h, s, val, a)
+        self._updateCmyk()
+    v = brightness = property(_get_brightness, _set_brightness, doc="the saturation of the color")
+
+    def _get_hsba(self):
+        c = self._rgb
+        return c.hueF(), c.saturationF(), c.valueF(), c.alphaF()
+    def _set_hsba(self, values):
+        values = self._normalizeList(values)
+        h, s, b, a = values
+        self._rgb.setHsvF(h, s, b, a)
+    hsba = property(_get_hsba, _set_hsba, doc="the hue, saturation, brightness and alpha of the color")
+
+    def _get_red(self):
+        return self._rgb.redF()
+    def _set_red(self, val):
+        val = self._normalize(val)
+        r, g, b, a = self.rgba
+        self._rgb.setRgbF(val, g, b, a)
+        self._updateCmyk()        
+    r = red = property(_get_red, _set_red, doc="the red component of the color")
+
+    def _get_green(self):
+        return self._rgb.greenF()
+    def _set_green(self, val):
+        val = self._normalize(val)
+        r, g, b, a = self.rgba
+        self._rgb.setRgbF(r, val, b, a)
+        self._updateCmyk()        
+    g = green = property(_get_green, _set_green, doc="the green component of the color")
+
+    def _get_blue(self):
+        return self._rgb.blueF()
+    def _set_blue(self, val):
+        val = self._normalize(val)
+        r, g, b, a = self.rgba
+        self._rgb.setRgbF(r, g, val, a)
+        self._updateCmyk()        
+    b = blue = property(_get_blue, _set_blue, doc="the blue component of the color")
+
+    def _get_alpha(self):
+        return self._rgb.alphaF()
+    def _set_alpha(self, val):
+        val = self._normalize(val)
+        r, g, b, a = self.rgba
+        self._rgb.setRgbF(r, g, b, val)
+        self._updateCmyk()        
+    a = alpha = property(_get_alpha, _set_alpha, doc="the alpha component of the color")
+   
+    def _get_rgba(self):
+        c = self._rgb
+        return c.redF(), c.greenF(), c.blueF(), c.alphaF()
+    def _set_rgba(self, values):
+        values = self._normalizeList(values)
+        r, g, b, a = values
+        self._rgb.setRgbF(r, g, b, a)
+    rgba = property(_get_rgba, _set_rgba, doc="the red, green, blue and alpha values of the color")
+
+    def _get_cyan(self):
+        return self._rgb.cyanF()
+    def _set_cyan(self, val):
+        val = self._normalize(val)
+        c, m, y, k, a = self.cmyka
+        self._rgb.setCmykF(val, m, y, k, a)
+        self._updateRgb()        
+    c = cyan = property(_get_cyan, _set_cyan, doc="the cyan component of the color")
+
+    def _get_magenta(self):
+        return self._rgb.magentaF()
+    def _set_magenta(self, val):
+        val = self._normalize(val)
+        c, m, y, k, a = self.cmyka
+        self._rgb.setCmykF(c, val, y, k, a)
+        self._updateRgb()        
+    m = magenta = property(_get_magenta, _set_magenta, doc="the magenta component of the color")
+
+    def _get_yellow(self):
+        return self._rgb.yellowF()
+    def _set_yellow(self, val):
+        val = self._normalize(val)
+        c, m, y, k, a = self.cmyka
+        self._rgb.setCmykF(c, m, val, k, a)
+        self._updateRgb()        
+    y = yellow = property(_get_yellow, _set_yellow, doc="the yellow component of the color")
+
+    def _get_black(self):
+        return self._rgb.blackF()
+    def _set_black(self, val):
+        val = self._normalize(val)
+        c, m, y, k, a = self.cmyka
+        self._rgb.setCmykF(c, m, y, val, a)
+        self._updateRgb()        
+    k = black = property(_get_black, _set_black, doc="the black component of the color")
+
+    def _get_cmyka(self):
+        c = self._rgb
+        return c.cyanF(), c.magentaF(), c.yellowF(), c.blackF(), c.alphaF()
+    cmyka = property(_get_cmyka, doc="a tuple containing the CMYKA values for this color")
 
     def _normalize(self, v):
@@ -604 +818 @@
         elif isinstance(transform, (list, tuple)):
             matrix = tuple(transform)
-            transform = QTransform()
-            transform.setMatrix(*matrix)
+            transform = QTransform(*matrix)
         elif isinstance(transform, QTransform):
             pass
@@ -622 +835 @@
     def concat(self, painter):
         trans = painter.transform()
-        painter.setTransform(trans * self._qtransform)
+        painter.setTransform(self._qtransform * trans)
 
     def copy(self):
@@ -637 +850 @@
     def _get_matrix(self):
         q = self._qtransform
-        return (q.m11(), q.m12(), q.m13(), q.m21(), q.m22(), q.m23(), q.m31(), q.m32(), q.m33())
+        return (q.m11(), q.m12(), q.m21(), q.m22(), q.m31(), q.m32())
     def _set_matrix(self, value):
-        self._qtransform.setMatrix(value)
+        self._qtransform = QTransform(*value)
     matrix = property(_get_matrix, _set_matrix)
 
@@ -657 +870 @@
 
     def skew(self, x=0, y=0):
-        self._qtransform.shear(x, y)
+        import math
+        x = math.pi * x / 180.
+        y = math.pi * y / 180.
+        t = Transform()
+        t.matrix = 1, math.tan(y), -math.tan(x), 1, 0, 0
+        self.prepend(t)
 
     def invert(self):
@@ -711 +929 @@
         TransformMixin.__init__(self)
         if data is not None:
-            self._nsImage = QImage(data)
+            self._qimage = QImage(data)
             if self._qimage is None:
                 raise NodeBoxError, "can't read image %r" % path
@@ -731 +949 @@
             if image is None:
                 image = QImage(path)
+                pxm = QPixmap.fromImage(image)
                 if image is None:
                     raise NodeBoxError, "Can't read image %r" % path
@@ -753 +972 @@
 
     def getSize(self):
-        return self._nsImage.size()
+        return self._qimage.width(), self._qimage.height()
 
     size = property(getSize)
 
-    def _draw(self, painter):
+    def _draw(self):
         """Draw an image on the given coordinates."""
 
-        srcW, srcH = self._qimage.width(), self._qimage.height()
+        srcW, srcH = float(self._qimage.width()), float(self._qimage.height())
         srcRect = ((0, 0), (srcW, srcH))
+
+        if self.debugImage:
+            item = QGraphicsRectItem()
+        else:
+            item = GraphicsImageItem(self._qimage, self.alpha)
 
         # Width or height given
@@ -771 +995 @@
             elif self.height is not None:
                 factor = self.height / srcH
-            painter.save()
 
             # Center-mode transforms: translate to image center
@@ -777 +1000 @@
                 # This is the hardest case: center-mode transformations with given width or height.
                 # Order is very important in this code.
-
                 # 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()
                 t.translate(self.x, self.y)
-                t.concat(painter)
-
+                t.concat(item)
+                
                 # Set new width and height factors. Note that no scaling is done yet: they're just here
-                # to set the new center of the image according to the scaling factors.
+                # to set the new center of the image according to the scaling factors
                 srcW = srcW * factor
                 srcH = srcH * factor
 
-                # Move image to newly calculated center.
+                # Move image to newly calculated center.                
                 dX = srcW / 2
                 dY = srcH / 2
                 t = Transform()
                 t.translate(dX, dY)
-                t.concat(painter)
-
+                t.concat(item)
+                
                 # Do current transformation.
-                self._transform.concat(painter)
-
-                # Move back to the previous position.
+                self._transform.concat(item)
+
+                # Move back to the previous position.                
                 t = Transform()
                 t.translate(-dX, -dY)
-                t.concat(painter)
-
-                # Finally, scale the image according to the factors.
+                t.concat(item)
+
+                # Finally, scale the image according to the factors.                
                 t = Transform()
                 t.scale(factor)
-                t.concat(painter)
+                t.concat(item)                
             else:
                 # Do current transformation
-                #self._transform.concat()
+                self._transform.concat(item)
                 # Scale according to width or height factor
                 t = Transform()
                 t.translate(self.x, self.y) # Here we add the positioning of the image.
                 t.scale(factor)
-                t.concat(painter)
+                t.concat(item)
 
             # A debugImage draws a black rectangle instead of an image.
             if self.debugImage:
-                painter.setBrush(QBrush(Qt.SolidPattern))
-                painter.fillRect(QRectF(0, 0, srcW / factor, srcH / factor))
-            else:
-                # TODO: Stuff with composition modes to allow for alpha transparency
-                painter.drawImage(QPointF(0, 0), self._qimage, QRectF(0, 0, srcW, srcH))
-            painter.restore()
+                item.setRect(0, 0, srcW / factor, srcH / factor)
+                item.setPen(QPen(Qt.NoPen))
+                item.setBrush(QBrush(Qt.black))
+
+            self._scene.addItem(item)            
         # No width or height given
         else:
-            painter.save()
             x,y = self.x, self.y
             # Center-mode transforms: translate to image center
@@ -835 +1055 @@
                 t = Transform()
                 t.translate(x+deltaX, y+deltaY)
-                t.concat(painter)
+                t.concat(item)
                 x = -deltaX
                 y = -deltaY
             # Do current transformation
-            self._transform.concat(painter)
+            self._transform.concat(item)
             # A debugImage draws a black rectangle instead of an image.
             if self.debugImage:
-                painter.setBrush(QBrush(Qt.SolidPattern))
-                painter.fillRect(QRectF(0, 0, srcW, srcH))
+                item.setRect(x, y, srcW, srcH)
+                item.setPen(QPen(Qt.NoPen))
+                item.setBrush(QBrush(Qt.black))
             else:
-                # TODO: Stuff with composition modes to allow for alpha transparency
-                painter.drawImage(QPointF(0, 0), self._qimage, QRectF(0, 0, srcW, srcH))
-            painter.restore()
+                t = Transform()
+                t.translate(x, y)
+                t.concat(item)
+            self._scene.addItem(item)
 
 class Text(Grob, TransformMixin, ColorMixin):
@@ -855 +1077 @@
 
     __dummy_color = QColor()
-    __alignMap = { LEFT: Qt.AlignLeft, RIGHT: Qt.AlignRight, CENTER: Qt.AlignCenter, JUSTIFY: Qt.AlignJustify }
+    __alignMap = { LEFT: Qt.AlignLeft, RIGHT: Qt.AlignRight, CENTER: Qt.AlignHCenter, JUSTIFY: Qt.AlignJustify }
     
     def __init__(self, ctx, text, x=0, y=0, width=None, height=None, **kwargs):
@@ -885 +1107 @@
 
     def _get_font(self):
-        return QFont(self._fontname, self._fontsize)
+        f = QFont(self._fontname)
+        f.setPointSizeF(self._fontsize / textScaleFactor)
+        return f
     _qfont = property(_get_font)
 
-    def _draw(self, painter):
-        if self.width is None:
-            w = 100000
-        else:
-            w = self.width
-        if self.height is None:
-            h = 100000
-        else:
-            h = self.height
-        fm = painter.fontMetrics()
-        flags = self.__alignMap[self._align]
-        r = fm.boundingRect(self.x, self.y, w, h, flags, self.text)
-
+    def _draw(self):
         if self._fillcolor is None: return
-        x,y = r.x(), r.y()
+        flags = self.__alignMap[self._align] | Qt.TextWordWrap
+        fm = QFontMetricsF(self._qfont)                
+        w = self.width or 100000
+        h = self.height or 100000
+        preferredWidth, preferredHeight = w, h
+        r = fm.boundingRect(QRectF(self.x, self.y, w, h), flags, self.text)
+        x, y = r.x(), r.y()
         w, h = r.width(), r.height()
-        preferredWidth, preferredHeight = r.width(), r.height()
         if self.width is not None:
             if self._align == RIGHT:
@@ -911 +1128 @@
                 x += preferredWidth/2 - w/2
 
-        painter.save()
-        painter.setFont(self._qfont)
-        self._fillcolor._set(painter)
-        #painter.setBrush(QBrush(self._fillcolor))
+        textLayout = QTextLayout()
+        textLayout.setFont(self._qfont)
+        textLayout.setText(self.text)
+        opt = QTextOption()
+        opt.setAlignment(self.__alignMap[self._align])
+        opt.setWrapMode(QTextOption.WrapAtWordBoundaryOrAnywhere)
+        textLayout.setTextOption(opt)
+        textLayout.beginLayout()
+        lineSpacing = (fm.ascent() + fm.descent() + fm.leading()) * self._lineheight
+
+        advance = 0
+        while True:
+            line = textLayout.createLine()
+            if not line.isValid():
+                break
+            line.setLineWidth(w)
+            line.setPosition(QPointF(0, advance))
+            advance += lineSpacing
+        textLayout.endLayout()
+
+        item = GraphicsTextItem(textLayout, x, y, w, h)
+        item.setPen(QPen(QBrush(self._fillcolor._rgb), 0))
+
         # Center-mode transforms: translate to image center
         if self._transformmode == CENTER:
+            lc = textLayout.lineCount()*lineSpacing
             deltaX = w / 2
             deltaY = h / 2
             t = Transform()
-            #t.translate(x+deltaX, y+fm.ascent()+deltaY)
-            t.concat(painter)
-            self._transform.concat(painter)
-            painter.drawText(x, y, w, h, flags, self.text)
-            #layoutManager.drawGlyphsForGlyphRange_atPoint_(glyphRange, (-deltaX-dx,-deltaY-dy))
-        else:
-            self._transform.concat()
-            painter.drawText(x, y, w, h, flags, self.text)
-            #layoutManager.drawGlyphsForGlyphRange_atPoint_(glyphRange, (x-dx,y-dy-self.font.defaultLineHeightForFont()))
-        painter.restore()
+            t.translate(deltaX,lc/2)
+            t.concat(item)
+            self._transform.concat(item)
+            t = Transform()
+            t.translate(-deltaX,-lc/2)
+            t.concat(item)
+        else:
+            self._transform.concat(item)
+        self._scene.addItem(item)
         return (w, h)
 
     def _get_metrics(self):
         # TODO: Measure using boundingRect
-        flags = self.__alignMap[self._align]
-        fm = QFontMetrics(self._qfont)
-        
-        if self.width is None:
-            w = 100000
-        else:
-            w = self.width
-        if self.height is None:
-            h = 100000
-        else:
-            h = self.height
-
-        r = fm.boundingRect(self.x, self.y, w, h, flags, self.text)
+        flags = self.__alignMap[self._align] | Qt.TextWordWrap
+        fm = QFontMetricsF(self._qfont)
+        w = self.width or 100000
+        h = self.height or 100000
+        r = fm.boundingRect(QRectF(self.x, self.y, w, h), flags, self.text)
         return r.width(), r.height()
     metrics = property(_get_metrics)
@@ -1024 +1252 @@
         self.speed = None
         self.mousedown = False
+        self._scene = None
         self.clear()
 
@@ -1059 +1288 @@
             raise NodeBoxError, "pop: too many canvas pops!"
 
-    def draw(self, painter):
+    def _setTextScaleFactor(self, factor):
+        global textScaleFactor
+        textScaleFactor = factor
+        
+    def draw(self):
+        self._scene.setSceneRect(0,0,self.width,self.height)
         if self.background is not None:
-            painter.fillRect(0,0, self.width, self.height, self.background._rgb)
+            self._scene.addRect(QRectF(0,0,self.width,self.height), QPen(Qt.NoPen), QBrush(self.background._rgb))
+            self._scene.num += 1
         for grob in self._grobs:
-            grob._draw(painter)
+            grob._scene = self._scene
+            grob._draw()
 
     def save(self, fname, format=None):
@@ -1073 +1309 @@
             svgGen.setFileName(fname)
             svgGen.setSize(QSize(self.width, self.height))
-            painter = QPainter(svgGen)
-            self.draw(painter)
+            painter = QPainter()
+            painter.begin(svgGen)
+            if self._scene:
+                self._scene.render(painter)
             painter.end()
         elif format == "pdf":
@@ -1081 +1319 @@
             printer.setOutputFileName(fname)
             printer.setFullPage(True)
-            #printer.setPageSize(QPrinter.Custom)
-            painter = QPainter(printer)
-            self.draw(painter)
+            printer.setPaperSize(QSizeF(self.width, self.height), QPrinter.Point)
+            painter = QPainter()
+            painter.begin(printer)
+            if self._scene:
+                self._scene.render(painter)
             painter.end()
         elif format in ("png", "tiff", "jpg", "jpeg"):
             img = QImage(self.width, self.height, QImage.Format_ARGB32)
-            painter = QPainter(img)
-            painter.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing)
-            self.draw(painter)
+            painter = QPainter()
+            painter.begin(img)
+            painter.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing | QPainter.SmoothPixmapTransform)
+            if format in ("jpg", "jpeg"):
+                painter.fillRect(0, 0, self.width, self.height, Qt.white)
+            if self._scene:
+                self._scene.render(painter)
             painter.end()
             img.save(fname, None, 100)