Changeset 484

Timestamp:

09/04/08 15:29:15 (4 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):