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

Timestamp:

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

Author:

stefan

Message:

initial changes

Files:

• nodebox/branches/try-qt-graphics-view/nodebox/gui/qt/__init__.py (modified) (19 diffs)

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()