Improved internal equation history logic

4 files changed, 57 insertions, 28 deletions

diff --git a/calculate.py b/calculate.py
index ae0ae32..61b57d4 100644
--- a/calculate.py
+++ b/calculate.py
@@ -171,6 +171,7 @@ class Calculate(activity.Activity):
         self.text_entry = self.layout.text_entry
         self.history = self.layout.history
         self.last_eq = self.layout.last_eq.get_buffer()
+        self.last_eq_sig = None
 
         self.presence = presenceservice.get_instance()
         self.owner = self.presence.get_owner()
@@ -204,18 +205,18 @@ class Calculate(activity.Activity):
     def cleanup_cb(self, arg):
         _logger.debug('Cleaning up...')
 
-    def equation_pressed_cb(self, n):
+    def equation_pressed_cb(self, eqn):
         """Callback for when an equation box is clicked"""
 
-        if len(self.helper_old_eqs) <= n:
-            return True
-        elif isinstance(self.helper_old_eqs[n].result, SVGImage):
+#        if len(self.helper_old_eqs) <= n:
+#            return True
+        if isinstance(eqn.result, SVGImage):
             return True
 
-        if len(self.helper_old_eqs[n].label) > 0:
-            text = self.helper_old_eqs[n].label
+        if len(eqn.label) > 0:
+            text = eqn.label
         else:
-            text = str(self.helper_old_eqs[n].result)
+            text = str(eqn.result)
 
         self.button_pressed(self.TYPE_TEXT, text)
         return True
@@ -230,7 +231,7 @@ class Calculate(activity.Activity):
             eq_start, eq_middle)
 
 # String results should be a little smaller
-        if type(res) == types.StringType:
+        if type(res) == types.StringType or res is None:
             buf.apply_tag(buf.create_tag(font=self.FONT_BIG_NARROW,
                 justification=gtk.JUSTIFY_RIGHT), eq_middle, eq_end)
         else:
@@ -261,24 +262,35 @@ class Calculate(activity.Activity):
             text = eqn.equation
             offset = 0
 
+        if self.last_eq_sig is not None:
+            self.layout.last_eq.disconnect(self.last_eq_sig)
+            self.last_eq_sig = None
+
         range = None
         if eqn.result is not None:
             if isinstance(eqn.result, SVGImage):
                 pass
             else:
                 text += '\n= ' + self.ml.format_number(eqn.result)
+
+            self.last_eq_sig = self.layout.last_eq.connect('button-press-event', \
+                lambda a1, a2, e: self.equation_pressed_cb(e), eqn)
+
         else:
             range = self.parser.get_error_range()
             range = (range[0] + offset, range[1] + offset)
             text += "\n" + self.parser.ps.format_error()
 
+            self.lat_eq_sig = self.layout.last_eq.connect('button-press-event', \
+                lambda a1, a2: True)
+
         self.last_eq.set_text(text)
         self.format_last_eq_buf(self.last_eq, eqn.result, range)
 
     def set_error_equation(self, eqn):
         self.set_last_equation(eqn)
 
-    def insert_equation(self, eq, prepend=True):
+    def add_equation(self, eq, prepend=False):
         """Insert equation in the history list and set variable if assignment"""
 
 #        tmp = self.helper_old_eqs
@@ -304,7 +316,7 @@ class Calculate(activity.Activity):
 
 # Result ok
         if res is not None:
-            self.insert_equation(eqn)
+            self.add_equation(eqn)
             self.parser.set_var('Ans', self.ml.format_number(eqn.result))
             self.helper.send_message("add_eq", str(eqn))
             self.showing_error = False
@@ -347,7 +359,10 @@ class Calculate(activity.Activity):
     def refresh_last_eq(self):
         """Refresh last equation TextView"""
 
-        for e in self.helper_old_eqs:
+        if self.showing_error:
+            return
+
+        for e in reversed(self.helper_old_eqs):
             if e.owner == self.owner_id:
                 self.set_last_equation(e)
                 return
@@ -400,9 +415,9 @@ class Calculate(activity.Activity):
         else:
             last_eq_drawn = False
 
-        i = -1
-        for e in self.helper_old_eqs:
-            i += 1
+        i = len(self.helper_old_eqs)
+        for e in reversed(self.helper_old_eqs):
+            i -= 1
 
 # Actually set by refresh_last_eq(), but needed for the drawing logic
             if not last_eq_drawn and e.owner == self.owner_id:
@@ -425,7 +440,7 @@ class Calculate(activity.Activity):
                 text += str(e.equation) + "\n=" + r
                 w = gtk.TextView()
                 w.set_wrap_mode(gtk.WRAP_WORD)
-                w.connect('button-press-event', lambda w, e, j: self.equation_pressed_cb(j), i)
+                w.connect('button-press-event', lambda w, e, eqn: self.equation_pressed_cb(eqn), e)
                 b = w.get_buffer()
 ##                b.modify_bg(gtk.STATE_ACTIVE | gtk.STATE_NORMAL,
 ##                gtk.gdk.color_parse(e.color.get_fill_color())
@@ -464,7 +479,7 @@ class Calculate(activity.Activity):
             f.write("%s;%d;%d;%d\n" % (self.text_entry.get_text(), pos, sel[0], sel[1]))
 
 # In reverse order
-        for eq in reversed(self.helper_old_eqs):
+        for eq in self.helper_old_eqs:
             f.write(str(eq))
 
         f.close()
@@ -499,7 +514,7 @@ class Calculate(activity.Activity):
             self.helper_old_eqs = []
             for str in f:
                 eq = Equation(str=str)
-                self.insert_equation(eq)
+                self.add_equation(eq)
 
             self.refresh_bar()
 
@@ -731,12 +746,11 @@ class Calculate(activity.Activity):
     def receive_message(self, msg, val):
         if msg == "add_eq":
             eq = Equation(str=str(val))
-            self.insert_equation(eq)
+            self.add_equation(eq)
             self.refresh_bar()
         elif msg == "req_sync":
             data = []
-# In reverse order to get variables right
-            for eq in reversed(self.helper_old_eqs):
+            for eq in self.helper_old_eqs:
                 data.append(str(eq))
             self.helper.send_message("sync", data)
         elif msg == "sync":
@@ -744,7 +758,7 @@ class Calculate(activity.Activity):
             self.helper_old_eqs = []
             for eq_str in val:
                 _logger.info('receive_message: %s', str(eq_str))
-                self.insert_equation(Equation(str=str(eq_str)))
+                self.add_equation(Equation(str=str(eq_str)))
             self.refresh_bar()
 
 def main():
diff --git a/eqnparser.py b/eqnparser.py
index da176fe..363269a 100644
--- a/eqnparser.py
+++ b/eqnparser.py
@@ -109,6 +109,12 @@ class ParserState:
             msg += ": %s" % (self.error_msg)
         return msg
 
+    def copy_error(self, ps):
+        """Copy error state from recursively created ParserState object"""
+        self.error_code = ps.error_code
+        self.error_msg = ps.error_msg
+        self.error_range = (ps.error_range[0] + ps.ofs, ps.error_range[1] + ps.ofs)
+
 class EqnParser:
     OP_INVALID = -1
     OP_PRE = 1
@@ -219,7 +225,7 @@ class EqnParser:
 
         self.register_operator('%', self.OP_DIADIC, 0, lambda x: self.ml.mod(x[0], x[1]))
 
-        self.set_var('help', 'Use help(test) to get help about \'test\'', parse=False)
+        self.set_var('help', 'Use help(test) to get help about \'test\', help(index) for available topics', parse=False)
 
     def register_function(self, name, f, opts):
         self.functions[name] = (f, opts)
@@ -286,7 +292,7 @@ class EqnParser:
 #                return None
 #            self.variables[name].highest_level = level
             if type(self.variables[name]) is types.StringType and self.parse_var[name]:
-                return self.parse(self.variables[name])
+                return self.parse(self.variables[name], reset=False)
             else:
                 return self.variables[name]
         else:
@@ -335,7 +341,7 @@ class EqnParser:
         else:
             pargs = []
             for i in range(len(args)):
-                pargs.append(self.parse(args[i]))
+                pargs.append(self.parse(args[i], reset=False))
                 if pargs[i] is None:
                     _logger.error('Unable to parse argument %d: \'%s\'', i, args[i])
                     self.ps.set_error(ParserState.PARSE_ERROR, msg='Unable to parse argument %d: \'%s\'' % (i, args[i]))
@@ -567,12 +573,22 @@ class EqnParser:
     def get_error_range(self):
         return self.ps.error_range
 
-    def parse(self, eqn):
+    def parse(self, eqn, reset=True):
         """Construct ParserState object and call _parse"""
         _logger.debug('parse(): %s', eqn)
         self.reset_variable_level(0)
+
+        if reset:
+            self.ps = None
+
+        oldps = self.ps
         self.ps = ParserState(eqn)
-        return self._parse(self.ps)
+        ret = self._parse(self.ps)
+        if oldps is not None:
+            oldps.copy_error(self.ps)
+            self.ps = oldps
+
+        return ret
 
     def functions_string(self):
         ret = ""
diff --git a/layout.py b/layout.py
index c9f41ae..909d1a3 100644
--- a/layout.py
+++ b/layout.py
@@ -129,7 +129,6 @@ class CalcLayout:
         self.last_eq = gtk.TextView()
         self.last_eq.set_editable(False)
         self.last_eq.set_wrap_mode(gtk.WRAP_WORD)
-        self.last_eq.connect('button-press-event', lambda a1, a2: self._parent.equation_pressed_cb(0))
         self.grid.attach(self.last_eq, 6, 11, 1, 5)
 
 # Right part: history
diff --git a/mathlib.py b/mathlib.py
index 07d342e..91e57fe 100644
--- a/mathlib.py
+++ b/mathlib.py
@@ -51,7 +51,7 @@ class MathLib:
 
     def set_angle_type(self, type):
         self.angle_scaling = self.d(type)
-        _logger.debug('Angle type set to:%s',self.angle_scaling)
+        _logger.debug('Angle type set to:%s', self.angle_scaling)
 
     def set_constant(self, name, val):
         self.constants[name] = val