Merge branch 'lp448319' of ../mainline

Conflicts:
	addons/readfile.py
	tests/probetests.py
	tests/run-tests.py
	tutorius/TProbe.py
	tutorius/constraints.py
	tutorius/core.py
	tutorius/engine.py
	tutorius/properties.py
	tutorius/service.py

11 files changed, 933 insertions, 0 deletions

diff --git a/addons/EmbeddedInterpreter.py b/addons/EmbeddedInterpreter.py
new file mode 100644
index 0000000..8c3522e
--- /dev/null
+++ b/addons/EmbeddedInterpreter.py
@@ -0,0 +1,30 @@
+from sugar.tutorius.actions import Action
+from sugar.tutorius.editor_interpreter import EditorInterpreter
+from sugar.tutorius.services import ObjectStore
+
+class EmbeddedInterpreter(Action):
+    def __init__(self):
+        Action.__init__(self)
+        self.activity = None
+        self._dialog = None
+
+    def do(self):
+        os = ObjectStore()
+        if os.activity:
+            self.activity = os.activity
+
+            self._dialog = EditorInterpreter(self.activity)
+            self._dialog.show()
+
+
+    def undo(self):
+        if self._dialog:
+            self._dialog.destroy()
+
+__action__ = {
+    "name" : "EmbeddedInterpreter",
+    "display_name" : "Embedded Interpreter",
+    "icon" : "message-bubble",
+    "class" : EmbeddedInterpreter,
+    "mandatory_props" : []
+}
diff --git a/addons/WidgetIdentifier.py b/addons/WidgetIdentifier.py
new file mode 100644
index 0000000..3c559b5
--- /dev/null
+++ b/addons/WidgetIdentifier.py
@@ -0,0 +1,35 @@
+from sugar.tutorius.actions import Action
+from sugar.tutorius.editor import WidgetIdentifier as WIPrimitive
+from sugar.tutorius.services import ObjectStore
+
+class WidgetIdentifier(Action):
+    def __init__(self):
+        Action.__init__(self)
+        self.activity = None
+        self._dialog = None
+
+    def do(self):
+        os = ObjectStore()
+        if os.activity:
+            self.activity = os.activity
+
+            self._dialog = WIPrimitive(self.activity)
+            self._dialog.show()
+
+
+    def undo(self):
+        if self._dialog:
+            # TODO elavoie 2009-07-19 
+            # We should disconnect the handlers, however there seems to be an error
+            # saying that the size of the dictionary changed during the iteration
+            # We should investigate this
+            #self._dialog._disconnect_handlers()
+            self._dialog.destroy()
+
+__action__ = {
+    "name" : "WidgetIdentifier",
+    "display_name" : "Widget Identifier",
+    "icon" : "message-bubble",
+    "class" : WidgetIdentifier,
+    "mandatory_props" : []
+}
diff --git a/addons/eventgenerator.py b/addons/eventgenerator.py
new file mode 100644
index 0000000..a91ccf4
--- /dev/null
+++ b/addons/eventgenerator.py
@@ -0,0 +1,60 @@
+# Copyright (C) 2009, Tutorius.org
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+from sugar.tutorius.actions import *
+from sugar.tutorius.gtkutils import find_widget
+
+class EventGenerator(Action):
+    source = TUAMProperty("")
+    type = TStringProperty("clicked")
+
+    def __init__(self, source=None, type="clicked"):
+        Action.__init__(self)
+
+        if source != None:
+            self.source = source
+
+        if type != "clicked":
+            self.type = type
+    
+    def do(self):
+        self._activity = ObjectStore().activity
+
+        # TODO elavoie 2009-07-25 We should eventually use the UAM mecanism
+        widget = find_widget(self._activity, self.source)
+
+        
+        # TODO elavoie 2009-07-25 We assume a gtk activity, it might
+        # get messier with other widget systems
+
+        # Call the signal on the widget
+        # We use introspection here to obtain the 
+        # method that will send the corresponding
+        # signal on the gtk object
+        getattr(widget, self.type)()
+
+        # That's all!!!
+
+    def undo(self):
+        pass
+
+__action__ = {
+    "name" : "EventGenerator",
+    "display_name" : "Event Generator",
+    "icon" : "message-bubble",
+    "class" : EventGenerator,
+    "mandatory_props" : ["source", "type"]
+}
+
diff --git a/tests/inject.py b/tests/inject.py
new file mode 100644
index 0000000..d69d6ff
--- /dev/null
+++ b/tests/inject.py
@@ -0,0 +1,57 @@
+#Test event injection
+
+import gtk
+import gobject
+import time
+import types
+
+class ClickMaster():
+    def __init__(self):
+        self.event = None
+
+    def connect(self, button):
+        self.id = button.connect("pressed",self.capture_event)
+        self.id2 = button.connect("released",self.capture_event2)
+        self.id3 = button.connect("clicked",self.capture_event3)
+        self.button = button
+
+    def capture_event(self, *args):
+        print "Capture Event"
+        print args
+        self.eventPress = args[-1]
+        return False
+
+    def capture_event2(self, *args):
+        print "Capture Release"
+        print args
+        self.eventReleased = args[-1]
+        return False
+
+    def capture_event3(self, *args):
+        print "Capture Clicked"
+        print args
+        self.eventClicked = args[-1]
+        return False
+
+    def inject_event(self):
+        print "Injecting"
+        print self.event
+        #self.event.put()
+        self.button.emit("button_press_event", self.event)
+
+def print_Event(event):
+    for att in dir(event):
+        if not isinstance(att, types.MethodType):
+            print att, getattr(event, att)
+
+if __name__=='__main__':
+    w = gtk.Window()
+    b = gtk.CheckButton("Auto toggle!")
+    c=ClickMaster()
+    w.add(b)
+    b.show()
+    c.connect(b)
+
+    w.show()
+
+    gtk.main()
diff --git a/tests/translatortests.py b/tests/translatortests.py
new file mode 100644
index 0000000..0f053b9
--- /dev/null
+++ b/tests/translatortests.py
@@ -0,0 +1,91 @@
+# Copyright (C) 2009, Tutorius.org
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+import unittest
+import os
+
+from sugar.tutorius.translator import *
+from sugar.tutorius.properties import *
+
+##############################################################################
+## Helper classes
+class ResourceAction(TPropContainer):
+    resource = TResourceProperty()
+
+    def __init__(self):
+        TPropContainer.__init__(self)
+
+class NestedResource(TPropContainer):
+    nested = TAddonProperty()
+
+    def __init__(self):
+        TPropContainer.__init__(self)
+        self.nested = ResourceAction()
+
+class ListResources(TPropContainer):
+    nested_list = TAddonListProperty()
+
+    def __init__(self):
+        TPropContainer.__init__(self)
+        self.nested_list = [ResourceAction(), ResourceAction()]
+
+##
+##############################################################################
+
+class ResourceTranslatorTests(unittest.TestCase):
+    temp_path = "/tmp/tutorius"
+    file_name = "temp.txt"
+    
+    def setUp(self):
+        try:
+            os.mkdir(self.temp_path)
+        except:
+            pass
+        new_file = file(os.path.join(self.temp_path, self.file_name), "w")
+
+        # Use a dummy prob manager - we shouldn't be using it
+        self.prob_man = object()
+
+        self.translator = ResourceTranslator(self.prob_man, '0101010101', testing=True)
+
+        pass
+
+    def tearDown(self):
+        os.unlink(os.path.join(self.temp_path, self.file_name))
+        pass
+
+    def test_translate(self):
+        # Create an action with a resource property
+        res_action = ResourceAction()
+
+        self.translator.translate(res_action)
+
+        assert getattr(res_action, "resource").type == "file", "Resource was not converted to file"
+
+    def test_recursive_translate(self):
+        nested_action = NestedResource()
+
+        self.translator.translate(nested_action)
+
+        assert getattr(getattr(nested_action, "nested"), "resource").type == "file", "Nested resource was not converted properly"
+
+    def test_list_translate(self):
+        list_action = ListResources()
+
+        self.translator.translate(list_action)
+
+        for container in list_action.nested_list:
+            assert getattr(container, "resource").type == "file", "Element of list was not converted properly"
diff --git a/tutorius/actions.py b/tutorius/actions.py
index bb15459..d5a8641 100644
--- a/tutorius/actions.py
+++ b/tutorius/actions.py
@@ -81,6 +81,7 @@ class DragWrapper(object):
         """Callback for end of drag (stolen focus)."""
         self._dragging = False
 
+
     def set_draggable(self, value):
         """Setter for the draggable property"""
         if bool(value) ^ bool(self._drag_on):
diff --git a/tutorius/core.py b/tutorius/core.py
index bfbe07b..80e1b4f 100644
--- a/tutorius/core.py
+++ b/tutorius/core.py
@@ -616,3 +616,25 @@ class FiniteStateMachine(State):
         # If we made it here, then all the states in this FSM could be matched to an
         # identical state in the other FSM.
         return True        
+        if len(self._states) != len(otherFSM._states):
+            return False
+        
+        # For each state, try to find a corresponding state in the other FSM
+        for state_name in self._states.keys():
+            state = self._states[state_name]
+            other_state = None
+            try:
+                # Attempt to use this key in the other FSM. If it's not present
+                # the dictionary will throw an exception and we'll know we have
+                # at least one different state in the other FSM
+                other_state = otherFSM._states[state_name]
+            except:
+                return False
+            # If two states with the same name exist, then we want to make sure
+            # they are also identical
+            if not state == other_state:
+                return False
+
+        # If we made it here, then all the states in this FSM could be matched to an
+        # identical state in the other FSM.
+        return True        
diff --git a/tutorius/editor_interpreter.py b/tutorius/editor_interpreter.py
new file mode 100644
index 0000000..d559266
--- /dev/null
+++ b/tutorius/editor_interpreter.py
@@ -0,0 +1,105 @@
+# Copyright (C) 2009, Tutorius.org
+# Greatly influenced by sugar/activity/namingalert.py
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+""" Tutorial Editor Interpreter  Module
+"""
+
+import gtk
+import pango
+from sugar.tutorius.ipython_view import *
+
+from gettext import gettext as _
+
+class EditorInterpreter(gtk.Window):
+    """
+    Interpreter that will be shown to the user
+    """
+    __gtype_name__ = 'TutoriusEditorInterpreter'
+
+    def __init__(self, activity=None):
+        gtk.Window.__init__(self)
+        
+        self._activity = activity
+
+	    # Set basic properties of window
+        self.set_decorated(False)
+        self.set_resizable(False)
+        self.set_modal(False)
+
+        # Connect to realize signal from ?
+        self.connect('realize', self.__realize_cb)
+
+        # Use an expander widget to allow minimizing
+        self._expander = gtk.Expander(_("Editor Interpreter"))
+        self._expander.set_expanded(True)
+        self.add(self._expander)
+        self._expander.connect("notify::expanded", self.__expander_cb)
+
+       
+        # Use the IPython widget to embed
+        self.interpreter = IPythonView()
+        self.interpreter.set_wrap_mode(gtk.WRAP_CHAR)
+
+        # Expose the activity object in the interpreter
+        self.interpreter.updateNamespace({'activity':self._activity})
+
+        # Use a scroll window to permit scrolling of the interpreter prompt 
+        swd = gtk.ScrolledWindow()
+        swd.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        swd.add(self.interpreter)
+        self.interpreter.show()
+
+        # Notify GTK that expander is ready
+        self._expander.add(swd)
+        self._expander.show()
+
+        # Notify GTK that the scrolling window is ready
+        swd.show()
+
+    def __expander_cb(self, *args):
+        """Callback for the window expander toggling"""
+        if self._expander.get_expanded():
+            self.__move_expanded()
+        else:
+            self.__move_collapsed()
+
+    def __move_expanded(self):
+        """Move the window to it's expanded position"""
+        swidth = gtk.gdk.screen_width()
+        sheight = gtk.gdk.screen_height()
+        # leave room for the scrollbar at the right
+        width = swidth - 20
+        height = 200
+
+        self.set_size_request(width, height)
+        # Put at the bottom of the screen
+        self.move(0, sheight-height)
+
+    def __move_collapsed(self):
+        """Move the window to it's collapsed position"""
+        width = 150
+        height = 40
+        swidth = gtk.gdk.screen_width()
+        sheight = gtk.gdk.screen_height()
+
+        self.set_size_request(width, height)
+        self.move(((swidth-width)/2)-150, sheight-height)
+
+    def __realize_cb(self, widget):
+        """Callback for realize"""
+        self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
+        self.window.set_accept_focus(True)
+        self.__move_expanded()
diff --git a/tutorius/events.py b/tutorius/events.py
new file mode 100644
index 0000000..bf0a8b9
--- /dev/null
+++ b/tutorius/events.py
@@ -0,0 +1,36 @@
+from sugar.tutorius.properties import *
+
+class Event(TPropContainer):
+    source = TUAMProperty()
+    type = TStringProperty("clicked")
+
+    def __init__(self):
+        TPropContainer.__init__(self)
+
+
+    # Providing the hash methods necessary to use events as key
+    # in a dictionary, if new properties are added we should
+    # take them into account here
+    def __hash__(self):
+        return hash(str(self.source) + str(self.type))
+
+    def __eq__(self, e2):
+        return self.source == e2.source and self.type == e2.type
+        
+
+    # Adding methods for pickling and unpickling an object with
+    # properties
+    def __getstate__(self):
+       return self._props.copy()
+
+    def __setstate__(self, dict):
+       self._props.update(dict)
+
+
+# Nothing more needs to be added, the additional 
+# information is in the object type
+class ClickedEvent(Event):
+    def __init__(self):
+        Event.__init__(self)
+        self.type = "clicked"
+
diff --git a/tutorius/ipython_view.py b/tutorius/ipython_view.py
new file mode 100644
index 0000000..c4294d0
--- /dev/null
+++ b/tutorius/ipython_view.py
@@ -0,0 +1,301 @@
+"""
+Backend to the console plugin.
+
+@author: Eitan Isaacson
+@organization: IBM Corporation
+@copyright: Copyright (c) 2007 IBM Corporation
+@license: BSD
+
+All rights reserved. This program and the accompanying materials are made 
+available under the terms of the BSD which accompanies this distribution, and 
+is available at U{http://www.opensource.org/licenses/bsd-license.php}
+"""
+# this file is a modified version of source code from the Accerciser project
+# http://live.gnome.org/accerciser
+
+import gtk
+import re
+import sys
+import os
+import pango
+from StringIO import StringIO
+
+try:
+  import IPython
+except Exception,e:
+  raise "Error importing IPython (%s)" % str(e)
+
+ansi_colors =  {'0;30': 'Black',
+                '0;31': 'Red',
+                '0;32': 'Green',
+                '0;33': 'Brown',
+                '0;34': 'Blue',
+                '0;35': 'Purple',
+                '0;36': 'Cyan',
+                '0;37': 'LightGray',
+                '1;30': 'DarkGray',
+                '1;31': 'DarkRed',
+                '1;32': 'SeaGreen',
+                '1;33': 'Yellow',
+                '1;34': 'LightBlue',
+                '1;35': 'MediumPurple',
+                '1;36': 'LightCyan',
+                '1;37': 'White'}
+
+class IterableIPShell:
+  def __init__(self,argv=None,user_ns=None,user_global_ns=None,
+               cin=None, cout=None,cerr=None, input_func=None):
+    if input_func:
+      IPython.iplib.raw_input_original = input_func
+    if cin:
+      IPython.Shell.Term.cin = cin
+    if cout:
+      IPython.Shell.Term.cout = cout
+    if cerr:
+      IPython.Shell.Term.cerr = cerr
+
+    if argv is None:
+      argv=[]
+
+    # This is to get rid of the blockage that occurs during 
+    # IPython.Shell.InteractiveShell.user_setup()
+    IPython.iplib.raw_input = lambda x: None
+
+    self.term = IPython.genutils.IOTerm(cin=cin, cout=cout, cerr=cerr)
+    os.environ['TERM'] = 'dumb'
+    excepthook = sys.excepthook
+    self.IP = IPython.Shell.make_IPython(argv,user_ns=user_ns,
+                                         user_global_ns=user_global_ns,
+                                         embedded=True,
+                                         shell_class=IPython.Shell.InteractiveShell)
+    self.IP.system = lambda cmd: self.shell(self.IP.var_expand(cmd),
+                                            header='IPython system call: ',
+                                            verbose=self.IP.rc.system_verbose)
+    sys.excepthook = excepthook
+    self.iter_more = 0
+    self.history_level = 0
+    self.complete_sep =  re.compile('[\s\{\}\[\]\(\)]')
+
+  def execute(self):
+    self.history_level = 0
+    orig_stdout = sys.stdout
+    sys.stdout = IPython.Shell.Term.cout
+    try:
+      line = self.IP.raw_input(None, self.iter_more)
+      if self.IP.autoindent:
+        self.IP.readline_startup_hook(None)
+    except KeyboardInterrupt:
+      self.IP.write('\nKeyboardInterrupt\n')
+      self.IP.resetbuffer()
+      # keep cache in sync with the prompt counter:
+      self.IP.outputcache.prompt_count -= 1
+
+      if self.IP.autoindent:
+        self.IP.indent_current_nsp = 0
+      self.iter_more = 0
+    except:
+      self.IP.showtraceback()
+    else:
+      self.iter_more = self.IP.push(line)
+      if (self.IP.SyntaxTB.last_syntax_error and
+          self.IP.rc.autoedit_syntax):
+        self.IP.edit_syntax_error()
+    if self.iter_more:
+      self.prompt = str(self.IP.outputcache.prompt2).strip()
+      if self.IP.autoindent:
+        self.IP.readline_startup_hook(self.IP.pre_readline)
+    else:
+      self.prompt = str(self.IP.outputcache.prompt1).strip()
+    sys.stdout = orig_stdout
+
+  def historyBack(self):
+    self.history_level -= 1
+    return self._getHistory()
+
+  def historyForward(self):
+    self.history_level += 1
+    return self._getHistory()
+
+  def _getHistory(self):
+    try:
+      rv = self.IP.user_ns['In'][self.history_level].strip('\n')
+    except IndexError:
+      self.history_level = 0
+      rv = ''
+    return rv
+
+  def updateNamespace(self, ns_dict):
+    self.IP.user_ns.update(ns_dict)
+
+  def complete(self, line):
+    split_line = self.complete_sep.split(line)
+    possibilities = self.IP.complete(split_line[-1])
+    if possibilities:
+      common_prefix = reduce(self._commonPrefix, possibilities)
+      completed = line[:-len(split_line[-1])]+common_prefix
+    else:
+      completed = line
+    return completed, possibilities
+
+  def _commonPrefix(self, str1, str2):
+    for i in range(len(str1)):
+      if not str2.startswith(str1[:i+1]):
+        return str1[:i]
+    return str1
+
+  def shell(self, cmd,verbose=0,debug=0,header=''):
+    stat = 0
+    if verbose or debug: print header+cmd
+    # flush stdout so we don't mangle python's buffering
+    if not debug:
+      input, output = os.popen4(cmd)
+      print output.read()
+      output.close()
+      input.close()
+
+class ConsoleView(gtk.TextView):
+  def __init__(self):
+    gtk.TextView.__init__(self)
+    self.modify_font(pango.FontDescription('Mono'))
+    self.set_cursor_visible(True)
+    self.text_buffer = self.get_buffer()
+    self.mark = self.text_buffer.create_mark('scroll_mark',
+                                             self.text_buffer.get_end_iter(),
+                                             False)
+    for code in ansi_colors:
+      self.text_buffer.create_tag(code,
+                                  foreground=ansi_colors[code],
+                                  weight=700)
+    self.text_buffer.create_tag('0')
+    self.text_buffer.create_tag('notouch', editable=False)
+    self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
+    self.line_start = \
+                self.text_buffer.create_mark('line_start',
+                        self.text_buffer.get_end_iter(), True
+                )
+    self.connect('key-press-event', self._onKeypress)
+    self.last_cursor_pos = 0
+
+  def write(self, text, editable=False):
+    segments = self.color_pat.split(text)
+    segment = segments.pop(0)
+    start_mark = self.text_buffer.create_mark(None,
+                                              self.text_buffer.get_end_iter(),
+                                              True)
+    self.text_buffer.insert(self.text_buffer.get_end_iter(), segment)
+
+    if segments:
+      ansi_tags = self.color_pat.findall(text)
+      for tag in ansi_tags:
+        i = segments.index(tag)
+        self.text_buffer.insert_with_tags_by_name(self.text_buffer.get_end_iter(),
+                                             segments[i+1], tag)
+        segments.pop(i)
+    if not editable:
+      self.text_buffer.apply_tag_by_name('notouch',
+                                         self.text_buffer.get_iter_at_mark(start_mark),
+                                         self.text_buffer.get_end_iter())
+    self.text_buffer.delete_mark(start_mark)
+    self.scroll_mark_onscreen(self.mark)
+
+  def showPrompt(self, prompt):
+    self.write(prompt)
+    self.text_buffer.move_mark(self.line_start,self.text_buffer.get_end_iter())
+
+  def changeLine(self, text):
+    iter = self.text_buffer.get_iter_at_mark(self.line_start)
+    iter.forward_to_line_end()
+    self.text_buffer.delete(self.text_buffer.get_iter_at_mark(self.line_start), iter)
+    self.write(text, True)
+
+  def getCurrentLine(self):
+    rv = self.text_buffer.get_slice(self.text_buffer.get_iter_at_mark(self.line_start),
+                                    self.text_buffer.get_end_iter(), False)
+    return rv
+
+  def showReturned(self, text):
+    iter = self.text_buffer.get_iter_at_mark(self.line_start)
+    iter.forward_to_line_end()
+    self.text_buffer.apply_tag_by_name('notouch',
+                                       self.text_buffer.get_iter_at_mark(self.line_start),
+                                       iter)
+    self.write('\n'+text)
+    if text:
+      self.write('\n')
+    self.showPrompt(self.prompt)
+    self.text_buffer.move_mark(self.line_start,self.text_buffer.get_end_iter())
+    self.text_buffer.place_cursor(self.text_buffer.get_end_iter())
+
+  def _onKeypress(self, obj, event):
+    if not event.string:
+      return
+    insert_mark = self.text_buffer.get_insert()
+    insert_iter = self.text_buffer.get_iter_at_mark(insert_mark)
+    selection_mark = self.text_buffer.get_selection_bound()
+    selection_iter = self.text_buffer.get_iter_at_mark(selection_mark)
+    start_iter = self.text_buffer.get_iter_at_mark(self.line_start)
+    if start_iter.compare(insert_iter) <= 0 and \
+          start_iter.compare(selection_iter) <= 0:
+      return
+    elif start_iter.compare(insert_iter) > 0 and \
+          start_iter.compare(selection_iter) > 0:
+      self.text_buffer.place_cursor(start_iter)
+    elif insert_iter.compare(selection_iter) < 0:
+      self.text_buffer.move_mark(insert_mark, start_iter)
+    elif insert_iter.compare(selection_iter) > 0:
+      self.text_buffer.move_mark(selection_mark, start_iter)
+
+
+class IPythonView(ConsoleView, IterableIPShell):
+  def __init__(self):
+    ConsoleView.__init__(self)
+    self.cout = StringIO()
+    IterableIPShell.__init__(self, cout=self.cout,cerr=self.cout,
+                             input_func=self.raw_input)
+    self.connect('key_press_event', self.keyPress)
+    self.execute()
+    self.cout.truncate(0)
+    self.showPrompt(self.prompt)
+    self.interrupt = False
+
+  def raw_input(self, prompt=''):
+    if self.interrupt:
+      self.interrupt = False
+      raise KeyboardInterrupt
+    return self.getCurrentLine()
+
+  def keyPress(self, widget, event):
+    if event.state & gtk.gdk.CONTROL_MASK and event.keyval == 99:
+      self.interrupt = True
+      self._processLine()
+      return True
+    elif event.keyval == gtk.keysyms.Return:
+      self._processLine()
+      return True
+    elif event.keyval == gtk.keysyms.Up:
+      self.changeLine(self.historyBack())
+      return True
+    elif event.keyval == gtk.keysyms.Down:
+      self.changeLine(self.historyForward())
+      return True
+    elif event.keyval == gtk.keysyms.Tab:
+      if not self.getCurrentLine().strip():
+        return False
+      completed, possibilities = self.complete(self.getCurrentLine())
+      if len(possibilities) > 1:
+        slice = self.getCurrentLine()
+        self.write('\n')
+        for symbol in possibilities:
+          self.write(symbol+'\n')
+        self.showPrompt(self.prompt)
+      self.changeLine(completed or slice)
+      return True
+
+  def _processLine(self):
+    self.history_pos = 0
+    self.execute()
+    rv = self.cout.getvalue()
+    if rv: rv = rv.strip('\n')
+    self.showReturned(rv)
+    self.cout.truncate(0)
+
diff --git a/tutorius/translator.py b/tutorius/translator.py
new file mode 100644
index 0000000..9925346
--- /dev/null
+++ b/tutorius/translator.py
@@ -0,0 +1,195 @@
+# Copyright (C) 2009, Tutorius.org
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+import os
+import logging
+import copy
+
+logger = logging.getLogger("ResourceTranslator")
+
+from sugar.tutorius.properties import *
+# TODO : Uncomment this line upon integration with the Vault
+##from sugar.tutorius.vault import * 
+
+class ResourceTranslator(object):
+    """
+    Handles the conversion of resource properties into file
+    properties before action execution. This class works as a decorator
+    to the ProbeManager class, as it is meant to be a transparent layer
+    before sending the action to execution.
+
+    An architectural note : every different type of translation should have its
+    own method (translate_resource, etc...), and this function must be called
+    from the translate method, under the type test. The translation_* method
+    must take in the input property and give the output property that should
+    replace it. 
+    """
+
+    def __init__(self, probe_manager, tutorial_id, testing=False):
+        """
+        Creates a new ResourceTranslator for the given tutorial. This
+        translator is tasked with replacing resource properties of the
+        incoming action into actually usable file properties pointing
+        to the correct resource file. This is done by querying the vault
+        for all the resources and creating a new file property from the
+        returned path.
+        
+        @param probe_manager The probe manager to decorate
+        @param tutorial_id The ID of the current tutorial
+
+        @param testing Triggers the usage of a fake vault for testing purposes
+        """
+        self._probe_manager = probe_manager
+        self._tutorial_id = tutorial_id
+
+        self._testing = testing
+
+    def translate_resource(self, res_prop):
+        """
+        Replace the TResourceProperty in the container by their
+        runtime-defined file equivalent. Since the resources are stored
+        in a relative manner in the vault and that only the Vault knows
+        which is the current folder for the current tutorial, it needs
+        to transform the resource identifier into the absolute path for
+        the process to be able to use it properly.
+
+        @param res_prop The resource property to be translated
+        @return The TFileProperty corresponding to this resource, containing
+                an absolute path to the resource
+        """
+        # We need to replace the resource by a file representation
+        filepath = ""
+        # TODO : Refactor when the Vault will be available
+        if not self._testing:
+            filepath = Vault.get_resource_path(self._tutorial_id, \
+                                               prop_object.value)
+        else:
+            filepath = "/tmp/tutorius/temp.txt"
+        # Create the new file representation
+        file_prop = TFileProperty(filepath)
+
+        return file_prop
+
+    def translate(self, prop_container):
+        """
+        Applies the required translation to be able to send the container to an
+        executing endpoint (like a Probe). For each type of property that
+        requires it, there is translation function that will take care of
+        mapping the property to its executable form.
+
+        This function does not return anything, but its post-condition is
+        that all the properties of the input container have been replaced
+        by their corresponding executable versions.
+
+        An example of translation is taking a resource (a relative path to
+        a file under the tutorial folder) and transforming it into a file
+        (a full absolute path) to be able to load it when the activity receives
+        the action.
+
+        @param prop_container The property container in which we want to
+                        replace all the resources for file properties and
+                        to recursively do so for addon and addonlist
+                        properties.
+        """
+        for propname in prop_container.get_properties():
+            prop_value = getattr(prop_container, propname)
+            prop_type = getattr(type(prop_container), propname).type
+
+            # If the property is a resource, then we need to query the
+            # vault to create its correspondent
+            if prop_type == "resource":
+                # Apply the translation
+                file_prop = self.translate_resource(prop_value)
+                # Set the property with the new value
+                setattr(prop_container, propname, file_prop)
+
+            # If the property is an addon, then its value IS a
+            # container too - we need to translate it
+            elif prop_type == "addon":
+                # Translate the sub properties
+                self.translate(prop_value)
+
+            # If the property is an addon list, then we need to translate all
+            # the elements of the list
+            elif prop_type == "addonlist":
+                # Now, for each sub-container in the list, we will apply the
+                # translation processing. This is done by popping the head of
+                # the list, translating it and inserting it back at the end.
+                for index in range(0, len(prop_value)):
+                    # Pop the head of the list
+                    container = prop_value[0]
+                    del prop_value[0]
+                    # Translate the sub-container
+                    self.translate(container)
+
+                    # Put the value back in the list
+                    prop_value.append(container)
+                # Change the list contained in the addonlist property, since
+                # we got a copy of the list when requesting it
+                setattr(prop_container, propname, prop_value)
+                
+    ### ProbeManager interface for decorator ###
+
+    ## Unchanged functions ##
+    def setCurrentActivity(self, activity_id):
+        self._probe_manager.setCurrentActivity(activity_id)
+
+    def getCurrentActivity(self):
+        return self._probe_manager.getCurrentActivity()
+
+    currentActivity = property(fget=getCurrentActivity, fset=setCurrentActivity)
+    def attach(self, activity_id):
+        self._probe_manager.attach(activity_id)
+
+    def detach(self, activity_id):
+        self._probe_manager.detach(activity_id)
+
+    def subscribe(self, event, callback):
+        return self._probe_manager.subscribe(event, callback)
+
+    def unsubscribe(self, event, callback):
+        return self._probe_manager.unsubscribe(event, callback)
+
+    def unsubscribe_all(self):
+        return self._probe_manager.unsubscribe_all()
+    
+    ## Decorated functions ##
+    def install(self, action):
+        # Make a new copy of the action that we want to install,
+        # because translate() changes the action and we
+        # don't want to modify the caller's action representation
+        new_action = copy.deepcopy(action)
+        # Execute the replacement
+        self.translate(new_action)
+
+        # Send the new action to the probe manager
+        return self._probe_manager.install(new_action)
+
+    def update(self, action):
+        new_action = copy.deepcopy(action)
+        self.translate(new_action)
+
+        return self._probe_manager.update(new_action)
+
+    def uninstall(self, action):
+        new_action = copy.deepcopy(action)
+        self.translate(new_action)
+
+        return self._probe_manager.uninstall(new_action)
+
+    def uninstall_all(self):
+        return self._probe_manager.uninstall_all()
+