Add a custom units toolbar and ruler.v24

3 files changed, 117 insertions, 9 deletions

diff --git a/RulerActivity.py b/RulerActivity.py
index 5396726..32f7c25 100644
--- a/RulerActivity.py
+++ b/RulerActivity.py
@@ -1,5 +1,6 @@
 # Copyright (c) 2007 Mitchell N. Charity
 # Copyright (c) 2009-2011 Walter Bender
+# Copyright (c) 2012-2013 Aneesh Dogra <lionaneesh@gmail.com>
 #
 # This file is part of Ruler.
 #
@@ -180,6 +181,47 @@ class RulerActivity(activity.Activity):
                                     group=self.rulers)
             toolbar_box.toolbar.insert(self.checker, -1)
 
+            # Add custom units toolbar
+
+            # Toolitems
+            self.wrapper = gtk.ToolItem()
+            self.wrapper2 = gtk.ToolItem()
+            self.wrapper3 = gtk.ToolItem()
+
+            self.custom_unit_entry = gtk.Entry()
+            self.txt1 = gtk.Label()
+            self.txt1.set_text(_('1 custom unit equals '))
+            self.txt2 = gtk.Label()
+
+            # TRANS: mm is for Milli Meters
+            self.txt2.set_text(_(' mm.'))
+
+            self.wrapper.add(self.txt1)
+            self.wrapper2.add(self.custom_unit_entry)
+            self.wrapper3.add(self.txt2)
+            self.wrapper.show_all()
+            self.wrapper2.show_all()
+            self.wrapper3.show_all()
+
+            separator = gtk.SeparatorToolItem()
+            separator.props.draw = True
+            separator.set_expand(False)
+            separator.show()
+            toolbar_box.toolbar.insert(separator, -1)
+
+            custom_units_toolbox = ToolbarBox()
+            custom_units_toolbox.toolbar.insert(self.wrapper, -1)
+            custom_units_toolbox.toolbar.insert(self.wrapper2, -1)
+            custom_units_toolbox.toolbar.insert(self.wrapper3, -1)
+            custom_units_toolbox.show()
+
+            self.custom_units_button = ToolbarButton(icon_name='view-source',
+                                                page=custom_units_toolbox)
+            toolbar_box.toolbar.insert(self.custom_units_button, -1)
+            self.custom_unit_entry.connect('changed', self.custom_unit_change_cb)
+            self.custom_units_button.show()
+
+
             if not self.known_dpi:
                 print self.known_dpi
                 separator = gtk.SeparatorToolItem()
@@ -233,6 +275,10 @@ class RulerActivity(activity.Activity):
             if HAS_TOOLARBOX:
                 self.button_dict[self.metadata['ruler']].set_active(True)
             self.callback_dict[self.metadata['ruler']]
+            if 'custom_unit' in self.metadata:
+                self.custom_unit_entry.set_text(str(self.metadata['custom_unit']))
+            else: # set the default
+                self.custom_unit_entry.set_text("25.4")
         else:
             self._rulers_cb()
             if HAS_TOOLARBOX:
@@ -243,14 +289,29 @@ class RulerActivity(activity.Activity):
     #
     def _rulers_cb(self, button=None):
         if self._ready:
+            self.custom_units_button.set_sensitive(True)
             self._current = self._r
             self._canvas.add_a_ruler(self._current)
             _logger.debug('selecting ruler')
             self.metadata['ruler'] = 'ruler'
         return False
 
+    def custom_unit_change_cb(self, widget):
+        try:
+            new = float(widget.get_text())
+            if new > 7: # less than 7 results in overlapping.
+                self._canvas.add_a_ruler(self._r)
+                self._r.custom_unit_in_mm = new
+                self._r.draw_custom_ruler(self._r.custom_unit_in_mm)
+                self.metadata['custom_unit'] = new
+        except ValueError:
+            if widget.get_text() != '':
+                widget.set_text('25.4')
+                self.metadata['custom_unit'] = 25.4
+
     def _grids_cb(self, button=None):
         if self._ready:
+            self.custom_units_button.set_sensitive(False)
             if self._grids_mode == "cm":
                 self._current = self._gcm
                 if hasattr(self, 'grids'):
@@ -268,6 +329,7 @@ class RulerActivity(activity.Activity):
 
     def _angles_cb(self, button=None):
         if self._ready:
+            self.custom_units_button.set_sensitive(False)
             if self._angles_mode == "90":
                 self._current = self._a90
                 if hasattr(self, 'angles'):
@@ -285,6 +347,7 @@ class RulerActivity(activity.Activity):
 
     def _checker_cb(self, button=None):
         if self._ready:
+            self.custom_units_button.set_sensitive(False)
             self._current = self._c
             self._canvas.add_a_ruler(self._current)
             _logger.debug('selecting checker')
diff --git a/activity/activity.info b/activity/activity.info
index 2bedbfd..9dfa386 100644
--- a/activity/activity.info
+++ b/activity/activity.info
@@ -3,7 +3,7 @@ name = Ruler
 bundle_id = com.laptop.Ruler
 exec = sugar-activity RulerActivity.RulerActivity
 icon = activity-ruler
-activity_version = 22
+activity_version = 24
 show_launcher = yes
 license = GPLv3+
-summary = a collection of measuring tools
\ No newline at end of file
+summary = a collection of measuring tools
diff --git a/show_rulers.py b/show_rulers.py
index a4d5857..793d259 100644
--- a/show_rulers.py
+++ b/show_rulers.py
@@ -1,5 +1,6 @@
 # Copyright 2007 Mitchell N. Charity
 # Copyright 2009 Walter Bender
+# Copyright 2012 Aneesh Dogra <lionaneesh@gmail.com>
 #
 # This file is part of Ruler.
 #
@@ -29,9 +30,14 @@ class ScreenOfRulers():
         self.font_bold = font_bold
         self.w = w
         self.h = h
+        self.custom_unit_in_mm = 24.5 # precise upto 2 decimal places
         self.hw = get_hardware()
+        self.offset_of_xo_side_from_screen = 0
+        self.dpi = 0
 
     def draw(self, c, dpi):
+        self.c = c
+        self.dpi = dpi
         set_background_color(c, self.w, self.h)
 
         nw, nh = dimensions_mm(dpi, self.w, self.h)
@@ -42,8 +48,8 @@ class ScreenOfRulers():
         # Only calculate offsets if on an OLPC XO-1, 1.5, 1.75
         # Not applicable to XO 3.0
         if self.hw[0:2] == 'xo' and dpi in [200, 201]:
-            offset_of_xo_side_from_screen = mm(dpi, -38.5)
-            c.move_to(offset_of_xo_side_from_screen,  mm(dpi, 65))
+            self.offset_of_xo_side_from_screen = mm(dpi, -38.5)
+            c.move_to(self.offset_of_xo_side_from_screen,  mm(dpi, 65))
             self.draw_cm_ruler(c, dpi, 180)
             
             c.save()
@@ -57,10 +63,12 @@ class ScreenOfRulers():
             self.draw_cm_ruler(c, dpi, 150)
 
         else:
-            offset_of_xo_side_from_screen = mm(dpi, 0)
-            c.move_to(offset_of_xo_side_from_screen,  mm(dpi, 65))
+            self.offset_of_xo_side_from_screen = mm(dpi, 0)
+            c.move_to(self.offset_of_xo_side_from_screen,  mm(dpi, 65))
             self.draw_cm_ruler(c, dpi, int(nw / 10 * 10))
-            
+            self.draw_custom_ruler(self.custom_unit_in_mm,
+                                   int(nw / 10 * 10))
+
     def draw_ruler_pair(self, c, dpi, y):
         c.move_to(mm(dpi, 10), y)
         self.connect_rulers(c, dpi)
@@ -70,7 +78,7 @@ class ScreenOfRulers():
 
         c.move_to(mm(dpi, 10), y+mm(dpi, 10))
         self.draw_mm_ruler(c, dpi)
-        
+
     def connect_rulers(self, c, dpi):
         c.save()
         c.set_line_cap(cairo.LINE_CAP_SQUARE)
@@ -106,12 +114,49 @@ class ScreenOfRulers():
             n = xm/10
             c.move_to(x, mm(dpi, -4))
             write(c, "%d" % n, self.font_bold, mm(dpi, 2.5), centered=True)
-            
+
         c.move_to(mm(dpi, 1.5), mm(dpi, -4))
         write(c, "cm", self.font_bold, mm(dpi, 2))
 
         c.restore()
 
+    # units_per_mm is precise upto 2 decimal places
+    def draw_custom_ruler(self, units_per_mm, width=130):
+        self.c.set_source_rgb(255, 255, 255)
+        self.c.rectangle(0, mm(self.dpi, 85),
+                    width, mm(self.dpi, 85) + 10)
+        self.c.fill()
+        self.c.set_source_rgb(0, 0, 0)
+
+        self.c.move_to(self.offset_of_xo_side_from_screen,  mm(self.dpi, 85))
+        self.c.save()
+        self.c.set_line_cap(cairo.LINE_CAP_SQUARE)
+        self.c.translate(*self.c.get_current_point())
+
+        self.c.set_line_width(5)
+        self.c.move_to(0, 0)
+        self.c.line_to(mm(self.dpi, width), 0)
+        for x in [mm(self.dpi, xm / 100) for xm in xrange(0, (width+1) * 100,
+                                                     int(units_per_mm * 100))]:
+            self.c.move_to(x, 0)
+            self.c.rel_line_to(0, mm(self.dpi, -3))
+        self.c.stroke()
+        pt_list = [x / int(units_per_mm * 100) for x in \
+                   range(0, (width + 1) * 100, int(units_per_mm * 100))]
+        coord_list = [mm(self.dpi, xm / 100) for xm in range(0, (width + 1) * 100,
+                                                      int(units_per_mm * 100))]
+        for a in range(0, len(coord_list)):
+            xm = pt_list[a]
+            x = coord_list[a]
+            n = xm
+            self.c.move_to(x, mm(self.dpi, -4))
+            write(self.c, "%d" % n, self.font_bold, mm(self.dpi, 2.5), centered=True)
+
+        self.c.move_to(mm(self.dpi, 1.5), mm(self.dpi, -4))
+        write(self.c, "unit", self.font_bold, mm(self.dpi, 2))
+
+        self.c.restore()
+
     def draw_mm_ruler(self, c, dpi, width=130):
         c.save()
         c.set_line_cap(cairo.LINE_CAP_SQUARE)