Update from skeleton

[ejpi] / src / qhistory.py

diff --git a/src/qhistory.py b/src/qhistory.py
index b5ed27b..1dea45d 100644 (file)
--- a/src/qhistory.py
+++ b/src/qhistory.py
@@ -5,11 +5,15 @@ http://www.grigoriev.ru/svgmath/ (MathML->SVG in Python)
 http://helm.cs.unibo.it/mml-widget/ (MathML widget in C++)
 """
 
+from __future__ import with_statement
+
 import logging
 
-from PyQt4 import QtGui
-from PyQt4 import QtCore
+import util.qt_compat as qt_compat
+QtCore = qt_compat.QtCore
+QtGui = qt_compat.import_module("QtGui")
 
+from util import qui_utils
 import util.misc as misc_utils
 import history
 import operation
@@ -27,7 +31,7 @@ class QCalcHistory(history.AbstractHistory):
        def __init__(self, errorReporter):
                super(QCalcHistory, self).__init__()
                self._prettyRenderer = operation.render_number()
-               self._errorReporter = errorReporter
+               self._errorLog = errorReporter
 
                self._historyStore = QtGui.QStandardItemModel()
                self._historyStore.setHorizontalHeaderLabels(["", "Equation", "Result"])
@@ -36,11 +40,12 @@ class QCalcHistory(history.AbstractHistory):
                self._historyView = QtGui.QTreeView()
                self._historyView.setModel(self._historyStore)
                self._historyView.setUniformRowHeights(True)
+               self._historyView.setRootIsDecorated(False)
                self._historyView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
                self._historyView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
                self._historyView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
                self._historyView.setHeaderHidden(True)
-               self._historyView.activated.connect(self._on_delete_row)
+               self._historyView.activated.connect(self._on_row_activated)
 
                viewHeader = self._historyView.header()
                viewHeader.setSortIndicatorShown(True)
@@ -53,24 +58,26 @@ class QCalcHistory(history.AbstractHistory):
 
                self._rowCount = 0
                self._programmaticUpdate = False
+               self._closeIcon = qui_utils.get_theme_icon(("window-close", "general_close", "gtk-close"))
 
        @property
        def toplevel(self):
                return self._historyView
 
-       @property
-       def errorReporter(self):
-               return self._errorReporter
-
        def push(self, node):
                simpleNode = node.simplify()
 
-               icon = QtGui.QStandardItem(QtGui.QIcon.fromTheme("gtk-close"), "")
+               closeIcon = self._closeIcon
+               icon = QtGui.QStandardItem(closeIcon, "")
                icon.setEditable(False)
                icon.setCheckable(False)
                equation = QtGui.QStandardItem(operation.render_operation(self._prettyRenderer, node))
                equation.setData(node)
                equation.setCheckable(False)
+               eqFont = equation.font()
+               eqFont.setPointSize(max(eqFont.pointSize() - 3, 5))
+               equation.setFont(eqFont)
+
                result = QtGui.QStandardItem(operation.render_operation(self._prettyRenderer, simpleNode))
                result.setData(simpleNode)
                result.setEditable(False)
@@ -80,7 +87,7 @@ class QCalcHistory(history.AbstractHistory):
                self._historyStore.appendRow(row)
 
                index = result.index()
-               self._historyView.scrollTo(index)
+               self._historyView.scrollToBottom()
                self._rowCount += 1
 
        def pop(self):
@@ -89,7 +96,7 @@ class QCalcHistory(history.AbstractHistory):
 
                icon, equation, result = self._historyStore.takeRow(self._rowCount - 1)
                self._rowCount -= 1
-               return equation.data().toPyObject()
+               return equation.data()
 
        def peek(self):
                if len(self) == 0:
@@ -99,46 +106,54 @@ class QCalcHistory(history.AbstractHistory):
                row = (icon, equation, result)
                self._historyStore.appendRow(row)
 
-               return equation.data().toPyObject()
+               return equation.data()
 
        def clear(self):
                self._historyStore.clear()
                self._rowCount = 0
 
+       def scroll_to_bottom(self):
+               self._historyView.scrollToBottom()
+
        @misc_utils.log_exception(_moduleLogger)
-       def _on_delete_row(self, index):
-               if index.column() == self._CLOSE_COLUMN:
-                       self._historyStore.removeRow(index.row(), index.parent())
-               elif index.column() == self._RESULT_COLUMN:
-                       self._duplicate_row(index)
-               else:
-                       raise NotImplementedError("Unsupported column to activate %s" % index.column())
+       def _on_row_activated(self, index):
+               with qui_utils.notify_error(self._errorLog):
+                       if index.column() == self._CLOSE_COLUMN:
+                               self._historyStore.removeRow(index.row(), index.parent())
+                               self._rowCount -= 1
+                       elif index.column() == self._EQ_COLUMN:
+                               self._duplicate_row(index)
+                       elif index.column() == self._RESULT_COLUMN:
+                               self._duplicate_row(index)
+                       else:
+                               raise NotImplementedError("Unsupported column to activate %s" % index.column())
 
        @misc_utils.log_exception(_moduleLogger)
        def _on_item_changed(self, item):
-               if self._programmaticUpdate:
-                       _moduleLogger.info("Blocking updating %r recursively" % item)
-                       return
-               self._programmaticUpdate = True
-               try:
-                       if item.column() in [self._EQ_COLUMN, self._RESULT_COLUMN]:
-                               self._update_input(item)
-                       else:
-                               raise NotImplementedError("Unsupported column to edit %s" % item.column())
-               except StandardError, e:
-                       self.errorReporter.push_exception()
-               finally:
-                       self._programmaticUpdate = False
+               with qui_utils.notify_error(self._errorLog):
+                       if self._programmaticUpdate:
+                               _moduleLogger.info("Blocking updating %r recursively" % item)
+                               return
+                       self._programmaticUpdate = True
+                       try:
+                               if item.column() in [self._EQ_COLUMN, self._RESULT_COLUMN]:
+                                       self._update_input(item)
+                               else:
+                                       raise NotImplementedError("Unsupported column to edit %s" % item.column())
+                       except StandardError, e:
+                               self._errorReporter.push_exception()
+                       finally:
+                               self._programmaticUpdate = False
 
        def _duplicate_row(self, index):
                item = self._historyStore.item(index.row(), self._EQ_COLUMN)
-               self.push(item.data().toPyObject())
+               self.push(item.data())
 
        def _parse_value(self, value):
                raise NotImplementedError("What?")
 
        def _update_input(self, item):
-               node = item.data().toPyObject()
+               node = item.data()
                try:
                        eqNode = self._parse_value(str(item.text()))
                        newText = operation.render_operation(self._prettyRenderer, eqNode)
@@ -165,4 +180,4 @@ class QCalcHistory(history.AbstractHistory):
                        item = self._historyStore.item(i, self._EQ_COLUMN)
                        if item is None:
                                continue
-                       yield item.data().toPyObject()
+                       yield item.data()