Changeset 486

Timestamp:

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

Author:

stefan

Message:

initial changes

Location:

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

Files:

• graphics/bezier.py (modified) (1 diff)
• graphics/qgraphics.py (added)
• graphics/qt.py (modified) (37 diffs)
• gui/qt/ValueLadder.py (added)
• gui/qt/__init__.py (modified) (19 diffs)
• gui/qt/dashboard.py (added)
• gui/qt/pytextview.py (added)
• gui/zoombig.png (added)
• gui/zoomsmall.png (added)

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

@@ -147 +147 @@
     if segments == None:
         segments = path.segmentlengths(relative=True)
-        
+
     if len(segments) == 0:
         raise NodeBoxError, "The given path is empty"

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)

nodebox/branches/try-qt-graphics-view/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 *
+from PyQt4.QtCore import *
 from PyQt4.QtSvg import QSvgGenerator
-
-from nodebox.gui.qt.editor import PythonHighlighter, CodeEdit, loadConfig
-
-MAGICVAR = "__magic_var__"
+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
 
 from nodebox import graphics
@@ -32 +33 @@
         self.data.append((self.isErr, data))
 
-class NodeBoxGraphicsView(QWidget):
-
+class GraphicsScene(QGraphicsScene):
     def __init__(self, parent=None):
-        QWidget.__init__(self, parent)
-        self.setMinimumSize(300, 300)
+        QGraphicsScene.__init__(self, parent)
+        self.num = 0
+
+    def addItem(self, item):
+        item.setZValue(self.num)
+        QGraphicsScene.addItem(self, item)
+        self.num += 1
+
+    def removeItem(self, item):
+        QGraphicsScene.removeItem(self, item)
+        self.num -= 1
+
+    def clear(self):
+        try:
+            QGraphicsScene.clear(self)
+        except AttributeError:
+            for item in self.items():
+                QGraphicsScene.removeItem(self, item) 
+        self.num = 0
+        
+    def drawItems(self, painter, items, options, widget):
+        painter.setClipRect(self.sceneRect())
+        QGraphicsScene.drawItems(self, painter, items, options, widget)
+        
+class NodeBoxGraphicsView(QGraphicsView):
+    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, parent=None):
+        QGraphicsView.__init__(self)
+        self.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self._scene = GraphicsScene(self)
+        self.setScene(self._scene)
+        self._scene.setSceneRect(0,0,1000,1000)
+        self._scene.setItemIndexMethod(QGraphicsScene.NoIndex)
         self._canvas = None
         self._image = None
         self._dirty = True
-        
+        self._zoom = 1.0
+        self._dx = 0
+        self._dy = 0
+        self._mouseDown = False
+        
+    def scrollContentsBy(self, dx, dy):
+        self._dx -= dx
+        self._dy -= dy
+        QGraphicsView.scrollContentsBy(self, dx, dy)
+
+    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() + self._dx, pos.y() + self._dy)
+    
     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)
         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)
+        transform = QTransform()
+        transform.scale(self.zoom, self.zoom)
+        self.setTransform( transform)
+    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):
+        w, h = self.canvas.size
+        viewport = self.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
         if redraw:
-            self.repaint()
-            
+            self._updateImage()
+
     def _updateImage(self):
-        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))
         try:
-            self.canvas.draw(p)
+            self._scene.clear()
+            if self._scene.width() != self.canvas.width or self._scene.height() != self.canvas.height:
+                self._scene.setSceneRect(QRectF(0, 0, self.canvas.width, self.canvas.height))
+            self.canvas._scene = self._scene
+            self.canvas.draw()
+            self._scene.update()
         except:
             # A lot of code just to display the error in the output view.
@@ -75 +185 @@
             outputView.setTextColor(QColor(255, 0, 0)) # TODO: Refactor color
             outputView.insertPlainText(data)
-        finally:
-            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.fillRect(0, 0, self.width(), self.height(), QColor(Qt.white))
-        else:
-            if self._dirty:
-                self._updateImage()
-            p.drawPixmap(0, 0, self._image)
         
 class NodeBoxDocument(QMainWindow):
@@ -98 +195 @@
         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 +209 @@
 
     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"))
@@ -134 +231 @@
         self.editMenu.addAction(self.tr("&Redo"), self.codeView, SLOT("redo()"), QKeySequence("Ctrl+Shift+Z"))
         self.editMenu.addSeparator()
+        self.editMenu.addAction(self.tr("&Switch Viewport"), self, SLOT("switchViewport()"), QKeySequence("Ctrl+Shift+P"))
         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)
 
@@ -164 +275 @@
         codeFormat.setFont(codeFont)
         
-        self.graphicsView = NodeBoxGraphicsView()
+        global app
+        self.graphicsView = 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.graphicsView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
+        self.graphicsView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
+        if app._startgl:
+            self.graphicsView.setViewport(QGLWidget(QGLFormat(QGL.SampleBuffers | QGL.AlphaChannel)))
+            self.graphicsView.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
+            self._oldViewport = "qwidget"
+        else:
+            self.graphicsView.setViewport(QWidget())
+            self.graphicsView.setViewportUpdateMode(QGraphicsView.SmartViewportUpdate)
+            self._oldViewport = "qglwidget"            
+        self.graphicsView.setOptimizationFlags(QGraphicsView.DontClipPainter | QGraphicsView.DontSavePainterState)
+        
+        self.codeView = PyTextView()
+        self.codeView._document = self
         self.codeView.setFontFamily(codeFont.defaultFamily())
         self.codeView.setCurrentFont(codeFont)
@@ -176 +297 @@
         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 +307 @@
         self.outputView.setAcceptRichText(False)
         self.outputView.setReadOnly(True)
-        
+        self.outputView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
+
         self.code_errors = QSplitter(Qt.Vertical)
         self.code_errors.addWidget(self.codeView)
         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.graphicsView)
+        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 +365 @@
 
         self.setWindowTitle(self.tr("Untitled"))
+        self.dashboardController = DashboardController(self)
         self.resize(800, 600)
-        
+
+    @pyqtSignature("")
+    def switchViewport(self):
+        self.outputView.setTextColor(QColor(0,0,0))
+        if self._oldViewport == "qwidget":
+            self.outputView.insertPlainText("switch to normal view\n")
+            self.graphicsView.setViewport(QWidget())
+            self.graphicsView.setViewportUpdateMode(QGraphicsView.SmartViewportUpdate)
+            self._oldViewport = "qglwidget"
+        else:
+            self.outputView.insertPlainText("switch to OpenGL view\n")
+            self.graphicsView.setViewport(QGLWidget(QGLFormat(QGL.SampleBuffers | QGL.AlphaChannel)))
+            self.graphicsView.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
+            self._oldViewport = "qwidget"
+
+    @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_()
+
     @pyqtSignature("")
     def doNew(self):
@@ -279 +496 @@
 
     @pyqtSignature("")
+    def doExportAsMovie(self):
+        pass
+
+    @pyqtSignature("")
+    def doPrint(self):
+        pass
+
+    @pyqtSignature("")
     def doRun(self):
         if self.fullScreen is not None: return
@@ -317 +542 @@
     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 +567 @@
             if self.namespace.has_key("setup"):
                 self.fastRun(self.namespace["setup"])
-            window = self.currentView.window()
+#            window = self.currentView.window()
             #window.makeFirstResponder_(self.currentView)
 
@@ -344 +574 @@
             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 +595 @@
             # Build the interface
             self.vars = self.namespace["_ctx"]._vars
-            if len(self.vars) > 0:
+            if newSeed and len(self.vars) > 0:
                 self.buildInterface_()
 
@@ -406 +636 @@
 
         # 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 +794 @@
 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 +827 @@
         self.settings = QSettings()
         loadConfig()
+        overrideConfig(self)
         self.documents = []
         if sys.platform == "win32":
@@ -591 +847 @@
         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]
+        self._startgl = '-gl' in args
+
     def newDocument(self):
         doc = NodeBoxDocument()