added CI scale and general code cleanup

1 files changed, 185 insertions, 174 deletions

diff --git a/SlideruleActivity.py b/SlideruleActivity.py
index 9b03bbd..b172246 100644
--- a/SlideruleActivity.py
+++ b/SlideruleActivity.py
@@ -16,16 +16,21 @@ pygtk.require('2.0')
 import gtk
 import gobject
 
+
 import sugar
 from sugar.activity import activity
-try: # 0.86+ toolbar widgets
+try:
+    from sugar.graphics.toolbarbox import ToolbarBox
+    _have_toolbox = True
+except ImportError:
+    _have_toolbox = False
+
+if _have_toolbox:
     from sugar.bundle.activitybundle import ActivityBundle
     from sugar.activity.widgets import ActivityToolbarButton
     from sugar.activity.widgets import StopButton
-    from sugar.graphics.toolbarbox import ToolbarBox
     from sugar.graphics.toolbarbox import ToolbarButton
-except ImportError:
-    pass
+
 from sugar.graphics.toolbutton import ToolButton
 from sugar.graphics.menuitem import MenuItem
 from sugar.graphics.icon import Icon
@@ -38,141 +43,126 @@ import os.path
 import logging
 _logger = logging.getLogger("sliderule-activity")
 
-from sprites import *
-import window
-from constants import *
+from window import SlideRule
+from constants import SWIDTH
+
+def _button_factory(icon_name, tooltip, callback, toolbar, cb_arg=None,
+                    accelerator=None):
+    """Factory for making toolbar buttons"""
+    my_button = ToolButton(icon_name)
+    my_button.set_tooltip(tooltip)
+    my_button.props.sensitive = True
+    if accelerator is not None:
+        my_button.props.accelerator = accelerator
+    if cb_arg is not None:
+        my_button.connect('clicked', callback, cb_arg)
+    else:
+        my_button.connect('clicked', callback)
+    if hasattr(toolbar, 'insert'):  # the main toolbar
+        toolbar.insert(my_button, -1)
+    else:  # or a secondary toolbar
+        toolbar.props.page.insert(my_button, -1)
+    my_button.show()
+    return my_button
+
+
+def _label_factory(label, toolbar):
+    """ Factory for adding a label to a toolbar """
+    my_label = gtk.Label(label)
+    my_label.set_line_wrap(True)
+    my_label.show()
+    _toolitem = gtk.ToolItem()
+    _toolitem.add(my_label)
+    toolbar.insert(_toolitem, -1)
+    _toolitem.show()
+    return my_label
+
+
+def _separator_factory(toolbar, visible=True, expand=False):
+    """ Factory for adding a separator to a toolbar """
+    _separator = gtk.SeparatorToolItem()
+    _separator.props.draw = visible
+    _separator.set_expand(expand)
+    toolbar.insert(_separator, -1)
+    _separator.show()
+
 
-#
-# Sugar activity
-#
 class SlideruleActivity(activity.Activity):
+    """ A sliderul activity for Sugar """
 
     def __init__(self, handle):
         super(SlideruleActivity,self).__init__(handle)
 
-        try:
-            # Use 0.86 toolbar design
-            toolbar_box = ToolbarBox()
-
-            # Buttons added to the Activity toolbar
-            activity_button = ActivityToolbarButton(self)
-            toolbar_box.toolbar.insert(activity_button, 0)
-            activity_button.show()
-
-            # C slider
-            self.c_slider = ToolButton( "Con" )
-            self.c_slider.set_tooltip(_('multiply/divide'))
-            self.c_slider.props.sensitive = True
-            self.c_slider.connect('clicked', self._c_slider_cb)
-            toolbar_box.toolbar.insert(self.c_slider, -1)
-            self.c_slider.show()
-
-            # A slider
-            self.a_slider = ToolButton( "Aoff" )
-            self.a_slider.set_tooltip(_('square/square root'))
-            self.a_slider.props.sensitive = True
-            self.a_slider.connect('clicked', self._a_slider_cb)
-            toolbar_box.toolbar.insert(self.a_slider, -1)
-            self.a_slider.show()
-
-            # L slider
-            self.l_slider = ToolButton( "Loff" )
-            self.l_slider.set_tooltip(_('add/subtract'))
-            self.l_slider.props.sensitive = True
-            self.l_slider.connect('clicked', self._l_slider_cb)
-            toolbar_box.toolbar.insert(self.l_slider, -1)
-            self.l_slider.show()
-
-            # Label for showing status
-            self.results_label = gtk.Label("1.0 × 1.0 = 1.0")
-            self.results_label.show()
-            results_toolitem = gtk.ToolItem()
-            results_toolitem.add(self.results_label)
-            toolbar_box.toolbar.insert(results_toolitem,-1)
-
-            separator = gtk.SeparatorToolItem()
-            separator.props.draw = False
-            separator.set_expand(True)
-            separator.show()
-            toolbar_box.toolbar.insert(separator, -1)
-
-            # The ever-present Stop Button
-            stop_button = StopButton(self)
-            stop_button.props.accelerator = '<Ctrl>Q'
-            toolbar_box.toolbar.insert(stop_button, -1)
-            stop_button.show()
-
-            self.set_toolbar_box(toolbar_box)
-            toolbar_box.show()
-
-        except NameError:
-            # Use pre-0.86 toolbar design
-            self.toolbox = activity.ActivityToolbox(self)
-            self.set_toolbox(self.toolbox)
-
-            self.projectToolbar = ProjectToolbar(self)
-            self.toolbox.add_toolbar( _('Project'), self.projectToolbar )
-
-            self.toolbox.show()
+        self._setup_toolbars(_have_toolbox)
 
         # Create a canvas
         canvas = gtk.DrawingArea()
-        canvas.set_size_request(gtk.gdk.screen_width(), \
+        canvas.set_size_request(gtk.gdk.screen_width(),
                                 gtk.gdk.screen_height())
         self.set_canvas(canvas)
         canvas.show()
         self.show_all()
 
         # Initialize the canvas
-        self.tw = window.new_window(canvas, \
-                                    os.path.join(activity.get_bundle_path(), \
-                                                 'images/'), \
-                                    self)
+        self.sr = SlideRule(canvas, os.path.join(activity.get_bundle_path(),
+                                                 'images/'), self)
 
         # Read the slider positions from the Journal
-        try:
-            self.tw.L.spr.move_relative((int(self.metadata['L']),0))
-            self.tw.L2.spr.move_relative((int(self.metadata['L2']),0))
-            self.tw.L2_tab_left.spr.move_relative((int(self.metadata['L2']),0))
-            self.tw.L2_tab_right.spr.move_relative((int(self.metadata['L2'])+\
-                                                   SWIDTH-100,0))
-        except:
-            pass
-        try:
-            self.tw.A.spr.move_relative((int(self.metadata['A']),0))
-            self.tw.C.spr.move_relative((int(self.metadata['C']),0))
-            self.tw.C_tab_left.spr.move_relative((int(self.metadata['C']),0))
-            self.tw.C_tab_right.spr.move_relative((int(self.metadata['C'])+\
-                                                   SWIDTH-100,0))
-            self.tw.D.spr.move_relative((int(self.metadata['D']),0))
-            self.tw.R.spr.move_relative((int(self.metadata['R']),0))
-            self.tw.R_tab_top.spr.move_relative((int(self.metadata['R']),0))
-            self.tw.R_tab_bot.spr.move_relative((int(self.metadata['R']),0))
-            self.tw.slider_on_top = self.metadata['slider']
-            if self.tw.slider_on_top == 'A':
+        if 'L' in self.metadata:
+            self.sr.L.spr.move_relative((int(self.metadata['L']), 0))
+        if 'L2' in self.metadata:
+            self.sr.L2.spr.move_relative((int(self.metadata['L2']), 0))
+            self.sr.L2_tab_left.spr.move_relative((int(self.metadata['L2']), 0))
+            self.sr.L2_tab_right.spr.move_relative((int(self.metadata['L2']) +\
+                                                   SWIDTH - 100, 0))
+        if 'A' in self.metadata:
+            self.sr.A.spr.move_relative((int(self.metadata['A']), 0))
+        if 'C' in self.metadata:
+            self.sr.C.spr.move_relative((int(self.metadata['C']), 0))
+            self.sr.C_tab_left.spr.move_relative((int(self.metadata['C']), 0))
+            self.sr.C_tab_right.spr.move_relative((int(self.metadata['C']) +\
+                                                   SWIDTH - 100, 0))
+        if 'CI' in self.metadata:
+            self.sr.CI.spr.move_relative((int(self.metadata['CI']), 0))
+            self.sr.CI_tab_left.spr.move_relative((int(self.metadata['CI']), 0))
+            self.sr.CI_tab_right.spr.move_relative((int(self.metadata['CI']) +\
+                                                   SWIDTH - 100, 0))
+        if 'D' in self.metadata:
+            self.sr.D.spr.move_relative((int(self.metadata['D']), 0))
+        if 'R' in self.metadata:
+            self.sr.R.spr.move_relative((int(self.metadata['R']), 0))
+            self.sr.R_tab_top.spr.move_relative((int(self.metadata['R']), 0))
+            self.sr.R_tab_bot.spr.move_relative((int(self.metadata['R']), 0))
+        if 'slider' in self.metadata:
+            self.sr.slider_on_top = self.metadata['slider']
+            if self.sr.slider_on_top == 'A':
                 self._show_a()
-            elif self.tw.slider_on_top == 'L':
+            elif self.sr.slider_on_top == 'L':
                 self._show_l()
+            elif self.sr.slider_on_top == 'CI':
+                self._show_ci()
             else:
                 self._show_c()
-            window._update_results_label(self.tw)
-            window._update_slider_labels(self.tw)
-        except:
-            self._show_c()
+            self.sr._update_results_label()
+            self.sr._update_slider_labels()
 
     def _hide_all(self):
         self.a_slider.set_icon("Aoff")
         self.c_slider.set_icon("Coff")
+        self.ci_slider.set_icon("CIoff")
         self.l_slider.set_icon("Loff")
-        self.tw.A.spr.hide()
-        self.tw.C.spr.hide()
-        self.tw.C_tab_left.spr.hide()
-        self.tw.C_tab_right.spr.hide()
-        self.tw.D.spr.hide()
-        self.tw.L.spr.hide()
-        self.tw.L2.spr.hide()
-        self.tw.L2_tab_left.spr.hide()
-        self.tw.L2_tab_right.spr.hide()
+        self.sr.A.spr.hide()
+        self.sr.C.spr.hide()
+        self.sr.CI.spr.hide()
+        self.sr.C_tab_left.spr.hide()
+        self.sr.C_tab_right.spr.hide()
+        self.sr.CI_tab_left.spr.hide()
+        self.sr.CI_tab_right.spr.hide()
+        self.sr.D.spr.hide()
+        self.sr.L.spr.hide()
+        self.sr.L2.spr.hide()
+        self.sr.L2_tab_left.spr.hide()
+        self.sr.L2_tab_right.spr.hide()
 
     def _c_slider_cb(self, button):
         self._show_c()
@@ -181,11 +171,24 @@ class SlideruleActivity(activity.Activity):
     def _show_c(self):
         self._hide_all()
         self.c_slider.set_icon("Con")
-        self.tw.C.draw_slider(1000)
-        self.tw.C_tab_left.draw_slider(1000)
-        self.tw.C_tab_right.draw_slider(1000)
-        self.tw.D.draw_slider(1000)
-        self.tw.slider_on_top = "C"
+        self.sr.C.draw_slider(1000)
+        self.sr.C_tab_left.draw_slider(1000)
+        self.sr.C_tab_right.draw_slider(1000)
+        self.sr.D.draw_slider(1000)
+        self.sr.slider_on_top = "C"
+
+    def _ci_slider_cb(self, button):
+        self._show_ci()
+        return True
+
+    def _show_ci(self):
+        self._hide_all()
+        self.ci_slider.set_icon("CIon")
+        self.sr.CI.draw_slider(1000)
+        self.sr.CI_tab_left.draw_slider(1000)
+        self.sr.CI_tab_right.draw_slider(1000)
+        self.sr.D.draw_slider(1000)
+        self.sr.slider_on_top = "CI"
 
     def _a_slider_cb(self, button):
         self._show_a()
@@ -194,9 +197,9 @@ class SlideruleActivity(activity.Activity):
     def _show_a(self):
         self._hide_all()
         self.a_slider.set_icon("Aon")
-        self.tw.A.draw_slider(1000)
-        self.tw.D.draw_slider(1000)
-        self.tw.slider_on_top = "A"
+        self.sr.A.draw_slider(1000)
+        self.sr.D.draw_slider(1000)
+        self.sr.slider_on_top = "A"
         return True
 
     def _l_slider_cb(self, button):
@@ -206,75 +209,83 @@ class SlideruleActivity(activity.Activity):
     def _show_l(self):
         self._hide_all()
         self.l_slider.set_icon("Lon")
-        self.tw.L.draw_slider(1000)
-        self.tw.L2.draw_slider(1000)
-        self.tw.L2_tab_left.draw_slider(1000)
-        self.tw.L2_tab_right.draw_slider(1000)
-        self.tw.slider_on_top = "L"
+        self.sr.L.draw_slider(1000)
+        self.sr.L2.draw_slider(1000)
+        self.sr.L2_tab_left.draw_slider(1000)
+        self.sr.L2_tab_right.draw_slider(1000)
+        self.sr.slider_on_top = "L"
 
     """
     Write the slider positions to the Journal
     """
     def write_file(self, file_path):
-        _logger.debug("Write slider on top: " + self.tw.slider_on_top)
-        self.metadata['slider'] = self.tw.slider_on_top
-        x,y = self.tw.A.spr.get_xy()
+        _logger.debug("Write slider on top: " + self.sr.slider_on_top)
+        self.metadata['slider'] = self.sr.slider_on_top
+        x, y = self.sr.A.spr.get_xy()
         _logger.debug("Write A offset: " + str(x))
         self.metadata['A'] = str(x)
-        x,y = self.tw.C.spr.get_xy()
+        x, y = self.sr.C.spr.get_xy()
         _logger.debug("Write C offset: " + str(x))
         self.metadata['C'] = str(x)
-        x,y = self.tw.D.spr.get_xy()
+        x, y = self.sr.CI.spr.get_xy()
+        _logger.debug("Write CI offset: " + str(x))
+        self.metadata['CI'] = str(x)
+        x, y = self.sr.D.spr.get_xy()
         _logger.debug("Write D offset: " + str(x))
         self.metadata['D'] = str(x)
-        x,y = self.tw.R.spr.get_xy()
+        x, y = self.sr.R.spr.get_xy()
         _logger.debug("Write r offset: " + str(x))
         self.metadata['R'] = str(x)
-        x,y = self.tw.L.spr.get_xy()
+        x, y = self.sr.L.spr.get_xy()
         _logger.debug("Write L offset: " + str(x))
         self.metadata['L'] = str(x)
-        x,y = self.tw.L2.spr.get_xy()
+        x, y = self.sr.L2.spr.get_xy()
         _logger.debug("Write L2 offset: " + str(x))
         self.metadata['L2'] = str(x)
 
+    def _setup_toolbars(self, have_toolbox):
+        """ Setup the toolbars.. """
+
+        if have_toolbox:
+            toolbox = ToolbarBox()
+
+            # Activity toolbar
+            activity_button = ActivityToolbarButton(self)
+
+            toolbox.toolbar.insert(activity_button, 0)
+            activity_button.show()
+
+            self.set_toolbar_box(toolbox)
+            toolbox.show()
+            toolbar = toolbox.toolbar
+
+        else:
+            # Use pre-0.86 toolbar design
+            project_toolbar = gtk.Toolbar()
+            toolbox = activity.ActivityToolbox(self)
+            self.set_toolbox(toolbox)
+            toolbox.add_toolbar(_('Project'), project_toolbar)
+            toolbox.show()
+            toolbox.set_current_toolbar(1)
+            toolbar = project_toolbar
+
+        # Add the buttons and labels to the toolbars
+        self.c_slider = _button_factory('Con', _('multiply/divide'),
+                                        self._c_slider_cb, toolbar)
+        self.ci_slider = _button_factory('CIoff', _('inverse'),
+                                        self._ci_slider_cb, toolbar)
+        self.a_slider = _button_factory('Aoff', _('square/square root'),
+                                        self._a_slider_cb, toolbar)
+        self.l_slider = _button_factory('Loff', _('add/subtract'),
+                                        self._l_slider_cb, toolbar)
+        _separator_factory(toolbar, True, False)
+        self.results_label = _label_factory(_('1.0 × 1.0 = 1.0'), toolbar)
+
+        if _have_toolbox:
+            _separator_factory(toolbox.toolbar, False, True)
+
+            stop_button = StopButton(self)
+            stop_button.props.accelerator = '<Ctrl>q'
+            toolbox.toolbar.insert(stop_button, -1)
+            stop_button.show()
 
-#
-# Project toolbar for pre-0.86 toolbars
-#
-class ProjectToolbar(gtk.Toolbar):
-
-    def __init__(self, pc):
-        gtk.Toolbar.__init__(self)
-        self.activity = pc
-
-        # C slider
-        self.activity.c_slider = ToolButton( "Con" )
-        self.activity.c_slider.set_tooltip(_('C'))
-        self.activity.c_slider.props.sensitive = True
-        self.activity.c_slider.connect('clicked', self.activity._c_slider_cb)
-        self.insert(self.activity.c_slider, -1)
-        self.activity.c_slider.show()
-
-        # A slider
-        self.activity.a_slider = ToolButton( "Aoff" )
-        self.activity.a_slider.set_tooltip(_('A'))
-        self.activity.a_slider.props.sensitive = True
-        self.activity.a_slider.connect('clicked', self.activity._a_slider_cb)
-        self.insert(self.activity.a_slider, -1)
-        self.activity.a_slider.show()
-
-        # L slider
-        self.activity.l_slider = ToolButton( "Loff" )
-        self.activity.l_slider.set_tooltip(_('L'))
-        self.activity.l_slider.props.sensitive = True
-        self.activity.l_slider.connect('clicked', self.activity._l_slider_cb)
-        self.insert(self.activity.l_slider, -1)
-        self.activity.l_slider.show()
-
-        # Label for showing status
-        self.activity.results_label = gtk.Label("1.0 × 1.0 = 1.0")
-        self.activity.results_label.show()
-        self.activity.results_toolitem = gtk.ToolItem()
-        self.activity.results_toolitem.add(self.activity.results_label)
-        self.insert(self.activity.results_toolitem, -1)
-        self.activity.results_toolitem.show()