Changeset 484 for nodebox/branches/try-qt-painter/nodebox/gui/qt/__init__.py

Timestamp:

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

Author:

stefan

Message:

initial changes

Files:

• nodebox/branches/try-qt-painter/nodebox/gui/qt/__init__.py (modified) (21 diffs)

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

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