Changeset 484

Timestamp:

09/04/08 15:29:15 (19 months ago)

Author:

stefan

Message:

initial changes

Location:

nodebox/branches/try-qt-painter/nodebox

Files:

• graphics/qt.py (modified) (36 diffs)
• gui/qt/__init__.py (modified) (21 diffs)

nodebox/branches/try-qt-painter/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.QtGui import QPainterPath, QColor, QTransform, QBrush, QPen, QImage, QPrinter, QPainter, QFontMetrics, QFontMetricsF, QFont, QTextLayout, QTextOption
 from PyQt4.QtCore import Qt, QSize, QPointF, QRectF
 from PyQt4.QtSvg import QSvgGenerator
@@ -36 +36 @@
 CORNER = "corner"
 
-MOVETO = 0
-LINETO = 1
-CURVETO = 2
-CLOSE = 3
+MOVETO = QPainterPath.MoveToElement
+LINETO = QPainterPath.LineToElement
+CURVETO = QPainterPath.CurveToElement
+CLOSE = "close"
 
 LEFT = 0
@@ -212 +212 @@
         ColorMixin.__init__(self, **kwargs)
         self._segment_cache = None
+        self._qpath_segment_cache = None
         if path is None:
             self._qpath = QPainterPath()
@@ -237 +238 @@
     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 +277 @@
     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 +294 @@
 
     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 +304 @@
 
     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 +343 @@
     def append(self, el):
         self._segment_cache = None
+        self._qpath_segment_cache = None
         if el.cmd == MOVETO:
             self.moveto(el.x, el.y)
@@ -355 +386 @@
         painter.restore()
         
+    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
+        
     ### Mathematics ###
     
@@ -394 +462 @@
     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):
@@ -456 +544 @@
         self._grobs.append(grob)
         
-    def _draw(self):
-        _save()
-        cp = self.path.transform.transformBezierPath(self.path)
-        cp._nsBezierPath.addClip()
+    def _draw(self, painter):
+        painter.save()
+        transform = self.path.transform
+        cp = transform.transformBezierPath(self.path)
+        painter.setClipPath(cp._qpath)
         for grob in self._grobs:
-            grob._draw()
-        _restore()
+            grob._draw(painter)
+        painter.restore()
 
 class Rect(BezierPath):
@@ -468 +557 @@
     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 +568 @@
     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):
@@ -519 +610 @@
             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 +620 @@
             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 +652 @@
     qColor = property(_get_qColor)
         
-
     def copy(self):
         new = self.__class__(self._ctx)
         new._rgb = QColor(self._rgb)
-        new._updateCmyk()
+#        new._updateCmyk()
         return new
 
@@ -573 +667 @@
 
     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 +817 @@
         elif isinstance(transform, (list, tuple)):
             matrix = tuple(transform)
-            transform = QTransform()
-            transform.setMatrix(*matrix)
+            transform = QTransform(*matrix)
         elif isinstance(transform, QTransform):
             pass
@@ -622 +834 @@
     def concat(self, painter):
         trans = painter.transform()
-        painter.setTransform(trans * self._qtransform)
+        painter.setTransform(self._qtransform * trans)
 
     def copy(self):
@@ -637 +849 @@
     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 +869 @@
 
     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 +928 @@
         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
@@ -753 +970 @@
 
     def getSize(self):
-        return self._nsImage.size()
+        return self._qimage.width(), self._qimage.height()
 
     size = property(getSize)
@@ -760 +977 @@
         """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))
 
@@ -777 +994 @@
                 # 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.
@@ -783 +999 @@
                 t.translate(self.x, self.y)
                 t.concat(painter)
-
+                
                 # 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
@@ -799 +1015 @@
                 self._transform.concat(painter)
 
-                # Move back to the previous position.
+                # Move back to the previous position.                
                 t = Transform()
                 t.translate(-dX, -dY)
                 t.concat(painter)
 
-                # Finally, scale the image according to the factors.
+                # Finally, scale the image according to the factors.                
                 t = Transform()
                 t.scale(factor)
-                t.concat(painter)
+                t.concat(painter)          
             else:
                 # Do current transformation
-                #self._transform.concat()
+                self._transform.concat(painter)
                 # Scale according to width or height factor
                 t = Transform()
@@ -819 +1035 @@
             # 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))
+                painter.setBrush(QBrush(Qt.black))
+                painter.setPen(QPen(Qt.NoPen))
+                painter.drawRect(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.setOpacity(self.alpha)
+                painter.drawImage(0, 0, self._qimage)
             painter.restore()
         # No width or height given
@@ -842 +1059 @@
             # 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))
+                painter.setBrush(QBrush(Qt.black))
+                painter.setPen(QPen(Qt.NoPen))
+                painter.drawRect(QRectF(x, y, srcW, srcH))
             else:
-                # TODO: Stuff with composition modes to allow for alpha transparency
-                painter.drawImage(QPointF(0, 0), self._qimage, QRectF(0, 0, srcW, srcH))
+                t = Transform()
+                t.translate(x, y)
+                t.concat(painter)
+                painter.setOpacity(self.alpha)
+                painter.drawImage(0, 0, self._qimage)
             painter.restore()
 
@@ -855 +1076 @@
 
     __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 +1106 @@
 
     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)
-
         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 +1127 @@
                 x += preferredWidth/2 - w/2
 
+        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()
+        
         painter.save()
-        painter.setFont(self._qfont)
-        self._fillcolor._set(painter)
-        #painter.setBrush(QBrush(self._fillcolor))
+        p = QPen(QBrush(self._fillcolor._rgb), 0)
+        painter.setPen(p)
+        
         # 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.translate(deltaX,lc/2)
             t.concat(painter)
             self._transform.concat(painter)
-            painter.drawText(x, y, w, h, flags, self.text)
-            #layoutManager.drawGlyphsForGlyphRange_atPoint_(glyphRange, (-deltaX-dx,-deltaY-dy))
+            t = Transform()
+            t.translate(-deltaX,-lc/2)
+            t.concat(painter)
         else:
-            self._transform.concat()
-            painter.drawText(x, y, w, h, flags, self.text)
-            #layoutManager.drawGlyphsForGlyphRange_atPoint_(glyphRange, (x-dx,y-dy-self.font.defaultLineHeightForFont()))
+            self._transform.concat(painter)
+
+        textLayout.draw(painter, QPointF(x, y))
         painter.restore()
         return (w, h)
@@ -934 +1172 @@
     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)
@@ -1059 +1289 @@
             raise NodeBoxError, "pop: too many canvas pops!"
 
+    def _setTextScaleFactor(self, factor):
+        global textScaleFactor
+        textScaleFactor = factor
+        
     def draw(self, painter):
         if self.background is not None:
+            painter.save()
             painter.fillRect(0,0, self.width, self.height, self.background._rgb)
+            painter.restore()
         for grob in self._grobs:
             grob._draw(painter)
@@ -1073 +1309 @@
             svgGen.setFileName(fname)
             svgGen.setSize(QSize(self.width, self.height))
-            painter = QPainter(svgGen)
+            painter = QPainter()
+            painter.begin(svgGen)
             self.draw(painter)
             painter.end()
@@ -1081 +1318 @@
             printer.setOutputFileName(fname)
             printer.setFullPage(True)
-            #printer.setPageSize(QPrinter.Custom)
-            painter = QPainter(printer)
+            printer.setPaperSize(QSizeF(self.width, self.height), QPrinter.Point)
+            painter = QPainter()
+            painter.begin(printer)
             self.draw(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)
+            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)
             self.draw(painter)
             painter.end()

nodebox/branches/try-qt-painter/nodebox/gui/qt/__init__.py

@@ -7 +7 @@
 import random
 
-from PyQt4.QtGui import QApplication, QWidget, QColor, QPainter, QMenuBar, QMenu, QKeySequence, QTextEdit, QSplitter, QGridLayout, QDialog, QScrollArea, QFont, QTextCharFormat, QFileDialog, QTextCursor, QPixmap, QPrinter, QImage, QMainWindow
-from PyQt4.QtCore import Qt, SIGNAL, SLOT, pyqtSignature, QTimer, QRectF, QSize, QCoreApplication, QSettings, QVariant
+from PyQt4.QtGui import QApplication, QWidget, QColor, QPainter, QMenuBar, QMenu, QKeySequence, QTextEdit, QSplitter, QGridLayout, QDialog, QScrollArea, QFont, QTextCharFormat, QFileDialog, QTextCursor, QPixmap, QPrinter, QImage, QMainWindow, QVBoxLayout, QHBoxLayout, QLabel, QSlider, QPushButton, QIcon, QTransform, QCursor
+from PyQt4.QtCore import Qt, SIGNAL, SLOT, pyqtSignature, QTimer, QRectF, QSize, QCoreApplication, QSettings, QVariant, QPoint
 from PyQt4.QtSvg import QSvgGenerator
-
-from nodebox.gui.qt.editor import PythonHighlighter, CodeEdit, loadConfig
+from PyQt4.QtOpenGL import QGLWidget, QGLFormat, QGL
+
+from nodebox.gui.qt.ValueLadder import MAGICVAR
+from nodebox.gui.qt.pytextview import PythonHighlighter, PyTextView, loadConfig, Config
+from nodebox.gui.qt.dashboard import DashboardController
 
 MAGICVAR = "__magic_var__"
@@ -32 +35 @@
         self.data.append((self.isErr, data))
 
-class NodeBoxGraphicsView(QWidget):
-
-    def __init__(self, parent=None):
-        QWidget.__init__(self, parent)
-        self.setMinimumSize(300, 300)
+class NodeBoxGraphicsView():
+    zoomLevels = [0.1, 0.25, 0.5, 0.75]
+    zoom = 1.0
+    while zoom <= 20.0:
+        zoomLevels.append(zoom)
+        zoom += 1.0
+
+    def __init__(self):
         self._canvas = None
         self._image = None
         self._dirty = True
-        
+        self._zoom = 1.0
+        self._mouseDown = False
+        
+    def mousePressEvent(self, event):
+        if event.button() == Qt.LeftButton:
+            self._mouseDown = True
+
+    def mouseReleaseEvent(self, event):
+        if event.button() == Qt.LeftButton:
+            self._mouseDown = False
+
+    def mousePosition(self):
+        pos = self.mapFromGlobal(QCursor.pos())
+        return QPoint(pos.x(), pos.y())
+
     def _get_canvas(self):
         return self._canvas
     def _set_canvas(self, canvas):
         self._canvas = canvas
-        size = self.width(), self.height()
-        if size != self.canvas.size:
-            self.resize(*self.canvas.size)
+        if canvas is not None:
+            size = int(self.width()/float(self._zoom)), int(self.height()/float(self._zoom))
+            if size != self.canvas.size:
+                width, height = self.canvas.size
+                self.resize(width*self._zoom, height*self._zoom)
         self.markDirty()
     canvas = property(_get_canvas, _set_canvas)
         
+    def _get_zoom(self):
+        return self._zoom
+    def _set_zoom(self, zoom):
+        self._zoom = zoom
+        self.document.zoomLevel.setText("%i%%" % (self._zoom * 100.0))
+        self.document.zoomSlider.setValue(self._zoom * 100.0)
+        self.canvas = self.canvas
+    zoom = property(_get_zoom, _set_zoom)
+
+    def findNearestZoomIndex(self, zoom):
+        """Returns the nearest zoom level, and whether we found a direct, exact
+        match or a fuzzy match."""
+        try: # Search for a direct hit first.
+            idx = self.zoomLevels.index(zoom)
+            return idx, True
+        except ValueError: # Can't find the zoom level, try looking at the indexes.
+            idx = 0
+            try:
+                while self.zoomLevels[idx] < zoom:
+                    idx += 1
+            except KeyError: # End of the list
+                idx = len(self.zoomLevels) - 1 # Just return the last index.
+            return idx, False
+
+    def zoomIn_(self):
+        idx, direct = self.findNearestZoomIndex(self.zoom)
+        # Direct hits are perfect, but indirect hits require a bit of help.
+        # Because of the way indirect hits are calculated, they are already
+        # rounded up to the upper zoom level; this means we don't need to add 1.
+        if direct:
+            idx += 1
+        idx = max(min(idx, len(self.zoomLevels)-1), 0)
+        self.zoom = self.zoomLevels[idx]
+
+    def zoomOut_(self):
+        idx, direct = self.findNearestZoomIndex(self.zoom)
+        idx -= 1
+        idx = max(min(idx, len(self.zoomLevels)-1), 0)
+        self.zoom = self.zoomLevels[idx]
+
+    def zoomTo_(self, value):
+        self.zoom = value
+
+    def zoomToFit_(self, scroll):
+        w, h = self.canvas.size
+        viewport = scroll.viewport()
+        fw = viewport.width()
+        fh = viewport.height()
+        factor = min(fw / float(w), fh / float(h))
+        self.zoom = factor        
+
+    def dragZoom_(self, value):
+        self.zoom = value / 100.0
+
     def markDirty(self, redraw=True):
         self._dirty = True
@@ -59 +135 @@
         self._image = None
         if self.canvas is None: return
-        img = QPixmap(self.canvas.width, self.canvas.height)
-        p = QPainter(img)
-        p.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing)
-        p.setClipRect(QRectF(0, 0, self.canvas.width, self.canvas.height))
+        p = QPainter()
+        p.begin(self)
+        p.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing | QPainter.SmoothPixmapTransform | QPainter.HighQualityAntialiasing)
+        p.setClipRect(QRectF(0, 0, self.canvas.width * self.zoom, self.canvas.height * self.zoom))
+
+        if self.zoom != 1.0:
+            p.scale(self.zoom, self.zoom)
         try:
+            p.save()
             self.canvas.draw(p)
         except:
@@ -76 +156 @@
             outputView.insertPlainText(data)
         finally:
+            p.restore()
             p.end() # TODO: This doesn't fix the QWidget warning if error happens during drawing.
-        self._image = img
         
     def paintEvent(self, event):
-        p = QPainter(self)
-        p.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing)
         if self.canvas is None:
+            p = QPainter(self)
             p.fillRect(0, 0, self.width(), self.height(), QColor(Qt.white))
         else:
             if self._dirty:
                 self._updateImage()
-            p.drawPixmap(0, 0, self._image)
-        
+
+class QGLNodeBoxGraphicsView(QGLWidget, NodeBoxGraphicsView):
+    def __init__(self, parent=None):
+        QGLWidget.__init__(self, QGLFormat(QGL.SampleBuffers | QGL.AlphaChannel), parent)
+        NodeBoxGraphicsView.__init__(self)
+        
+class QNodeBoxGraphicsView(QWidget, NodeBoxGraphicsView):
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent)
+        NodeBoxGraphicsView.__init__(self)
+
 class NodeBoxDocument(QMainWindow):
     def __init__(self):
@@ -98 +186 @@
         self.namespace = {}
         self.canvas = graphics.Canvas()
+        textScaleFactor = QPixmap().logicalDpiX() / 72.0
+        self.canvas._setTextScaleFactor(textScaleFactor)
         self.context = graphics.Context(self.canvas, self.namespace)
         self.animationTimer = None
@@ -110 +200 @@
 
     def createMenu(self):
-        #self.menuBar = QMenuBar()
-
         self.fileMenu = QMenu(self.tr("&File"), self)
         self.fileMenu.addAction(self.tr("&New"), self, SLOT("doNew()"), QKeySequence("Ctrl+N"))
@@ -136 +224 @@
         self.menuBar().addMenu(self.editMenu)
 
+        self.viewMenu = QMenu(self.tr("&View"), self)
+        self.viewMenu.addAction(self.tr("Zoom &In"), self, SLOT("zoomIn_()"), QKeySequence("Ctrl++"))
+        self.viewMenu.addAction(self.tr("Zoom &Out"), self, SLOT("zoomOut_()"), QKeySequence("Ctrl+-"))
+        self.zoomToMenu = QMenu(self.tr("Zoom to"), self)
+        self.zoomToMenu.addAction(self.tr("To &Fit"), self, SLOT("zoomToFit_()"), QKeySequence("Ctrl+0"))
+        self.zoomToMenu.addAction(self.tr("Actual &Size"), self, SLOT("zoomTo100_()"), QKeySequence("Ctrl+1"))
+        self.zoomToMenu.addAction(self.tr("200%"), self, SLOT("zoomTo200_()"), QKeySequence("Ctrl+2"))
+        self.zoomToMenu.addAction(self.tr("300%"), self, SLOT("zoomTo300_()"), QKeySequence("Ctrl+3"))
+        self.zoomToMenu.addAction(self.tr("400%"), self, SLOT("zoomTo400_()"), QKeySequence("Ctrl+4"))
+        self.zoomToMenu.addAction(self.tr("50%"), self, SLOT("zoomTo50_()"), QKeySequence("Ctrl+5"))
+        self.viewMenu.addMenu(self.zoomToMenu)
+        self.menuBar().addMenu(self.viewMenu)
+
         self.pythonMenu = QMenu(self.tr("&Python"), self)
         self.runAction = self.pythonMenu.addAction(self.tr("&Run"), self, SLOT("doRun()"), QKeySequence("Ctrl+R"))
-        self.runAction = self.pythonMenu.addAction(self.tr("&Stop"), self, SLOT("doStop()"), QKeySequence("Ctrl+."))
+        self.runAction = self.pythonMenu.addAction(self.tr("&Stop"), self, SLOT("doStop()"), QKeySequence("Ctrl+B"))
         self.menuBar().addMenu(self.pythonMenu)
 
@@ -163 +264 @@
         codeFormat = QTextCharFormat()
         codeFormat.setFont(codeFont)
-        
-        self.graphicsView = NodeBoxGraphicsView()
+
+        global app
+        self.graphicsView = app._NodeBoxGraphicsView(self)
         self.graphicsView.document = self
         self.graphicsView.resize(1000, 1000)
         self.graphicsScroll = QScrollArea()
         self.graphicsScroll.setWidget(self.graphicsView)
-        self.graphicsScroll.setMinimumSize(300, 300)
-        self.codeView = CodeEdit()
+        self.graphicsScroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
+        self.graphicsScroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
+        self.codeView = PyTextView()
+        self.codeView._document = self
         self.codeView.setFontFamily(codeFont.defaultFamily())
         self.codeView.setCurrentFont(codeFont)
@@ -176 +280 @@
         self.codeView.setMinimumSize(300, 300)
         self.codeView.setAcceptRichText(False)
+        self.codeView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
+        self.codeView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
         PythonHighlighter(self.codeView.document())
         self.outputView = QTextEdit()
@@ -184 +290 @@
         self.outputView.setAcceptRichText(False)
         self.outputView.setReadOnly(True)
+        self.outputView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
         
         self.code_errors = QSplitter(Qt.Vertical)
@@ -189 +296 @@
         self.code_errors.addWidget(self.outputView)
 
+        self.zoomLevel = QLabel("100%")
+        ft = self.zoomLevel.font()
+        ft.setPointSizeF(10)
+        self.zoomLevel.setFont(ft)
+        self.zoomSlider = QSlider(Qt.Horizontal)
+        self.zoomSlider.setMinimumWidth(130)
+        self.zoomSlider.setMinimum(1)
+        self.zoomSlider.setMaximum(1000)
+        self.zoomSlider.setValue(100)
+        self.zoom_small = QPushButton()
+        self.zoom_small.setIcon(QIcon(os.path.join(app.dir_gui, "zoomsmall.png")))
+        self.zoom_small.setStyleSheet("border: 0;")
+        self.zoom_big = QPushButton()
+        self.zoom_big.setIcon(QIcon(os.path.join(app.dir_gui, "zoombig.png")))
+        self.zoom_big.setStyleSheet("border: 0;")
+        self.connect(self.zoom_small, SIGNAL("clicked()"), self, SLOT("zoomOut_()"))
+        self.connect(self.zoom_big, SIGNAL("clicked()"), self, SLOT("zoomIn_()"))
+        self.connect(self.zoomSlider, SIGNAL("valueChanged(int)"), self, SLOT("dragZoom_(int)"))
+
+        lh = QHBoxLayout()
+        lh.addWidget(self.zoomLevel)
+        lh.addWidget(self.zoom_small)
+        lh.addWidget(self.zoomSlider)
+        lh.addWidget(self.zoom_big)
+        lh.setContentsMargins(0,0,0,0)
+        lh.setSpacing(8)
+
+        self.zoom = QWidget(self)
+        self.zoom.setLayout(lh)
+
+        lv = QVBoxLayout()
+        lv.addWidget(self.graphicsScroll)
+        lv.addWidget(self.zoom, 0, Qt.AlignRight)
+        lv.setContentsMargins(0, 0, 0, 0)
+
+        self.graphics_zoom = QWidget(self)
+        self.graphics_zoom.setLayout(lv)
+
         self.view_edit = QSplitter()
-        self.view_edit.addWidget(self.graphicsScroll)
+        self.view_edit.addWidget(self.graphics_zoom)
         self.view_edit.addWidget(self.code_errors)
         self.view_edit.setObjectName("view_edit")
-        self.view_edit.setStyleSheet("QSplitter#view_edit { margin: 10px 10px 20px 10px; border: 0 }")
+        self.view_edit.setStyleSheet("#view_edit { margin: 10px 10px 20px 10px; border: 0 }")
         l = QGridLayout()
         l.setHorizontalSpacing(10)
         l.setVerticalSpacing(10)
         self.view_edit.setLayout(l)
-        
-        #self.centralWidget = QWidget()
-        #self.centralWidget.addWidget(self.view_edit)
-        #self.centralWidget.setLayout(QGridLayout())
-        
         self.setCentralWidget(self.view_edit)
         self.setUnifiedTitleAndToolBarOnMac(True)
@@ -208 +348 @@
 
         self.setWindowTitle(self.tr("Untitled"))
+        self.dashboardController = DashboardController(self)
         self.resize(800, 600)
-        
+
+    @pyqtSignature("")
+    def zoomIn_(self):
+        if self.fullScreen is not None: return        
+        self.graphicsView.zoomIn_()        
+        
+    @pyqtSignature("")
+    def zoomOut_(self):
+        if self.fullScreen is not None: return
+        self.graphicsView.zoomOut_()        
+
+    @pyqtSignature("int")
+    def dragZoom_(self, value):
+        if self.fullScreen is not None: return
+        self.graphicsView.dragZoom_(value)        
+
+    @pyqtSignature("")
+    def zoomTo100_(self):
+        if self.fullScreen is not None: return
+        self.graphicsView.zoomTo_(1.0)
+
+    @pyqtSignature("")
+    def zoomTo200_(self):
+        if self.fullScreen is not None: return
+        self.graphicsView.zoomTo_(2.0)
+
+    @pyqtSignature("")
+    def zoomTo300_(self):
+        if self.fullScreen is not None: return
+        self.graphicsView.zoomTo_(3.0)
+
+    @pyqtSignature("")
+    def zoomTo400_(self):
+        if self.fullScreen is not None: return
+        self.graphicsView.zoomTo_(4.0)
+
+    @pyqtSignature("")
+    def zoomTo50_(self):
+        if self.fullScreen is not None: return
+        self.graphicsView.zoomTo_(0.5)
+
+    @pyqtSignature("")
+    def zoomToFit_(self):
+        if self.fullScreen is not None: return
+        self.graphicsView.zoomToFit_(self.graphicsScroll)
+
     @pyqtSignature("")
     def doNew(self):
@@ -279 +465 @@
 
     @pyqtSignature("")
+    def doExportAsMovie(self):
+        pass
+
+    @pyqtSignature("")
+    def doPrint(self):
+        pass
+
+    @pyqtSignature("")
     def doRun(self):
         if self.fullScreen is not None: return
@@ -317 +511 @@
     fileName = property(_get_fileName, _set_fileName)
 
+    def buildInterface_(self):
+        if not self.dashboardController:
+            self.dashboardController = DashboardController(self)
+        self.dashboardController.buildInterface_(self.vars)
+
     def _runScript(self, compile=True, newSeed=True):
-        if not self.cleanRun(self._execScript):
+        if not self.cleanRun(self._execScript, newSeed):
             pass
 
@@ -337 +536 @@
             if self.namespace.has_key("setup"):
                 self.fastRun(self.namespace["setup"])
-            window = self.currentView.window()
+#            window = self.currentView.window()
             #window.makeFirstResponder_(self.currentView)
 
@@ -344 +543 @@
             self.connect(self.animationTimer, SIGNAL("timeout()"), self, SLOT("doFrame()"))
             self.animationTimer.start(1000.0 / self.speed)
-
+            
     def runScriptFast_(self):        
         if self.animationTimer is None:
@@ -365 +564 @@
             # Build the interface
             self.vars = self.namespace["_ctx"]._vars
-            if len(self.vars) > 0:
+            if newSeed and len(self.vars) > 0:
                 self.buildInterface_()
 
@@ -406 +605 @@
 
         # Set the mouse position
-        # TODO: Get correct mouse position
-        #window = self.currentView.window()
-        pt = 0, 0 # window.mouseLocationOutsideOfEventStream()
-        mx, my = 0, 0 # window.contentView().convertPoint_toView_(pt, self.currentView)
-        # Hack: mouse coordinates are flipped vertically in FullscreenView.
-        # This flips them back.
-        if isinstance(self.currentView, FullscreenView):
-            my = self.currentView.bounds()[1][1] - my
+        pos = self.currentView.mousePosition()
+        mx, my = pos.x(), pos.y()
+
+#        if isinstance(self.currentView, FullscreenView):
+#            my = self.currentView.bounds()[1][1] - my
+
+        if self.fullScreen is None:
+            mx /= self.currentView.zoom
+            my /= self.currentView.zoom            
         self.namespace["MOUSEX"], self.namespace["MOUSEY"] = mx, my
-        #self.namespace["mousedown"] = QApplication.mouseButtons() & Qt.LeftButton
+        self.namespace["mousedown"] = self.currentView._mouseDown
         #self.namespace["keydown"] = self.currentView.keydown
         #self.namespace["key"] = self.currentView.key
@@ -563 +763 @@
 class FullscreenView(QDialog):
     pass
+
+def overrideConfig(app):
+    settings = app.settings
+    Config["fontfamily"] = settings.value("fontfamily",
+            QVariant("Monaco")).toString()
+    Config["fontsize"] = settings.value("fontsize",
+            QVariant(11)).toInt()[0]
+    for name, color, bold, italic in (
+            ("normal", "#000000", False, False),
+            ("keyword", "#0000FF", False, False),
+            ("builtin", "#000000", False, False),
+            ("constant", "#0000FF", False, False),
+            ("decorator", "#000000", False, False),
+            ("comment", "#808080", False, False),
+            ("string", "#FF00FF", False, False),
+            ("number", "#000000", False, False),
+            ("error", "#FF0000", False, False),
+            ("pyqt", "#000000", False, False)):
+        Config["%sfontcolor" % name] = settings.value(
+                "%sfontcolor" % name, QVariant(color)).toString()
+        Config["%sfontbold" % name] = settings.value(
+                "%sfontbold" % name, QVariant(bold)).toBool()
+        Config["%sfontitalic" % name] = settings.value(
+                "%sfontitalic" % name, QVariant(italic)).toBool()
     
 class NodeBoxApplication(QApplication):
@@ -572 +796 @@
         self.settings = QSettings()
         loadConfig()
+        overrideConfig(self)
         self.documents = []
         if sys.platform == "win32":
@@ -591 +816 @@
         except OSError: pass
         except IOError: pass
+        import nodebox.gui
+        dir_gui = nodebox.gui.__file__
+        self.dir_gui = os.path.split(os.path.realpath(dir_gui))[0]
+        if '-gl' in args:
+            self._NodeBoxGraphicsView = QGLNodeBoxGraphicsView
+        else:            
+            self._NodeBoxGraphicsView = QNodeBoxGraphicsView
             
     def newDocument(self):