Changeset 516 for nodebox

Timestamp:

10/09/08 13:55:29 (3 months ago)

Author:

stefan

Message:

 

Files:

• nodebox/branches/try-qt-painter/nodebox/graphics/qt.py (modified) (13 diffs)

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

@@ -222 +222 @@
         ColorMixin.__init__(self, **kwargs)
         self._segment_cache = None
-        self._qpath_segment_cache = None
+        self._qPath_segment_cache = None
         if path is None:
-            self._qpath = QPainterPath()
+            self._qPath = QPainterPath()
         elif isinstance(path, (list,tuple)):
-            self._qpath = QPainterPath()
+            self._qPath = QPainterPath()
             self.extend(path)
         elif isinstance(path, BezierPath):
-            self._qpath = QPainterPath(path._qpath)
+            self._qPath = QPainterPath(path._qPath)
             _copy_attrs(path, self, self.stateAttributes)
         elif isinstance(path, QPainterPath):
-            self._qpath = path
+            self._qPath = path
         else:
             raise NodeBoxError, "Don't know what to do with %s." % path
             
     def _get_path(self):
-        warnings.warn("The 'path' attribute is deprecated. Please use _qpath instead.", DeprecationWarning, stacklevel=2)
-        return self._qpath
+        warnings.warn("The 'path' attribute is deprecated. Please use _qPath instead.", DeprecationWarning, stacklevel=2)
+        return self._qPath
     path = property(_get_path)
 
@@ -248 +248 @@
     def moveto(self, x, y):
         self._segment_cache = None
-        self._qpath_segment_cache = None
-        self._qpath.moveTo(x, y)
+        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)
+        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)
+        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?
+        self._qPath_segment_cache = None
+        self._qPath.closeSubpath() # XXX: Is this correct?
 
     def setlinewidth(self, width):
@@ -271 +271 @@
     def _get_bounds(self):
         try:
-            r = self._qpath.boundingRect()
+            r = self._qPath.boundingRect()
             return (r.x(), r.y()), (r.width(), r.height())
         except:
@@ -280 +280 @@
 
     def contains(self, x, y):
-        return self._qpath.contains(QPointF(x,y))
+        return self._qPath.contains(QPointF(x,y))
         
     ### Basic shapes ###
@@ -286 +286 @@
     def rect(self, x, y, width, height):
         self._segment_cache = None
-        self._qpath_segment_cache = None
-        self._qpath.addRect(x, y, width, height)
+        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)
+        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)
+        self._qPath_segment_cache = None
+        self._qPath.moveTo(x1, y1)
+        self._qPath.lineTo(x2, y2)
 
     ### List methods ###
 
     def __getitem__(self, index):
-        if self._qpath_segment_cache == None:
-            self._set_qpath_segment_cache()
-        cmd, el = self._qpath_segment_cache[index]
+        if self._qPath_segment_cache == None:
+            self._set_qPath_segment_cache()
+        cmd, el = self._qPath_segment_cache[index]
         return PathElement(cmd, el)
 
@@ -313 +313 @@
 
     def __len__(self):
-        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),)))
+        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 = []
+        count = self._qPath.elementCount()
+        for i in xrange(count):
+            el = self._qPath.elementAt(i)
+            if el.type == CLOSE:
+                self._qPath_segment_cache.append((el.type, ()))
+            elif el.type in [LINETO, MOVETO]:
+                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))))
+                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
+        self._qPath_segment_cache = None
         for el in pathElements:
             if isinstance(el, (list, tuple)):
@@ -352 +349 @@
     def append(self, el):
         self._segment_cache = None
-        self._qpath_segment_cache = None
+        self._qPath_segment_cache = None
         if el.cmd == MOVETO:
             self.moveto(el.x, el.y)
@@ -395 +392 @@
         else:
             painter.setPen(Qt.NoPen)
-        painter.drawPath(self._qpath)
+        painter.drawPath(self._qPath)
         painter.restore()
         
@@ -433 +430 @@
                 t.scale(min(width /pw, height / ph))
         t.translate(-px, -py)
-        self._qpath = t.transformBezierPath(self)._qpath
+        self._qPath = t.transformBezierPath(self)._qPath
         
     ### Mathematics ###
@@ -476 +473 @@
         self._qPath = bezier.insert_point(self, t)._qPath
         self._segment_cache = None
-        self._qpath_segment_cache = None
+        self._qPath_segment_cache = None
 
     ### Clipping operations ###
 
     def intersects(self, other):
-        return self._qpath.intersects(other._qpath)
+        return self._qPath.intersects(other._qPath)
 
     def union(self, other, flatness=0.6):
-        return BezierPath(self._ctx, self._qpath.united(other._qpath))
+        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))
+        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))
+        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)
+        union = self._qPath.united(other._qPath)
+        intersection = self._qPath.intersected(other._qPath)
         return BezierPath(self._ctx, union.subtracted(intersection))
 
@@ -559 +556 @@
         painter.save()
         cp = self.path.transform.transformBezierPath(self.path)
-        painter.setClipPath(cp._qpath)
+        painter.setClipPath(cp._qPath)
         for grob in self._grobs:
             grob._draw(painter)
@@ -909 +906 @@
             point = QPointF(*point)
         elif isinstance(point, Point):
-            point = point._qPoint
+            point = QPointF(point.x, point.y)
         return self._qtransform.map(point)
 
@@ -917 +914 @@
         else:
             raise NodeBoxError, "Can only transform BezierPaths"
-        path._qpath = self._qtransform.map(path._qpath)
+        path._qPath = self._qtransform.map(path._qPath)
         return path