[Sugar-devel] =?yes?q?=5BPATCH=5D=20Copy=20and=20Paste=20feature=20in=20Abacus=20Activity=20=28=232324=29?=

shanjit at seeta.in shanjit at seeta.in
Sat Oct 2 02:42:13 EDT 2010


From: Shanjit Singh Jajmann <shanjit at dev.seeta.in>

Values can now be copied to the clipboard. Values can also now be pasted from the clipboard to the abacus activity.
---
 AbacusActivity.py |   77 +++++++++++--------
 abacus_window.py  |   62 ++++++---------
 sprites.py        |  222 +++++++++++++++++++++++------------------------------
 3 files changed, 168 insertions(+), 193 deletions(-)

diff --git a/AbacusActivity.py b/AbacusActivity.py
index d14f58a..480e351 100644
--- a/AbacusActivity.py
+++ b/AbacusActivity.py
@@ -38,11 +38,11 @@ import locale
 import logging
 _logger = logging.getLogger("abacus-activity")
 
-from abacus_window import Abacus, Custom, Suanpan, Soroban, Schety,\
+from abacus_window import Abacus,AbacusGeneric , Custom, Suanpan, Soroban, Schety,\
                           Nepohualtzintzin, Binary, Hex, Decimal, Fractions,\
                           Caacupe, Cuisenaire
 
-def _button_factory(icon_name, tooltip, callback, toolbar):
+def _button_factory(icon_name, tooltip, callback, toolbar, accelerator = None):
     """Factory for making toolbar buttons"""
     my_button = ToolButton( icon_name )
     my_button.set_tooltip(tooltip)
@@ -100,7 +100,7 @@ class AbacusActivity(activity.Activity):
 
         _abacus_toolbar = gtk.Toolbar()
         _custom_toolbar = gtk.Toolbar()
-
+        edit_toolbar = gtk.Toolbar()
         if _new_sugar_system:
             # Use 0.86 toolbar design
             toolbox = ToolbarBox()
@@ -127,6 +127,14 @@ class AbacusActivity(activity.Activity):
             toolbox.toolbar.insert(_custom_toolbar_button, -1)
             _custom_toolbar_button.show()
 
+            edit_toolbar_button = ToolbarButton(label=_('Edit'),
+                                                page=edit_toolbar,
+                                                icon_name='toolbar-edit')
+            edit_toolbar_button.show()
+            toolbox.toolbar.insert(edit_toolbar_button, -1)
+            edit_toolbar_button.show()
+ 
+
             _separator_factory(toolbox.toolbar, True, False)
 
             stop_button = StopButton(self)
@@ -136,6 +144,7 @@ class AbacusActivity(activity.Activity):
 
             self.set_toolbox(toolbox)
             _abacus_toolbar_button.set_expanded(True)
+            edit_toolbar_button.set_expanded(True)
             toolbox.show()
 
         else:
@@ -145,7 +154,8 @@ class AbacusActivity(activity.Activity):
 
             toolbox.add_toolbar( _('Project'), _abacus_toolbar )
             toolbox.add_toolbar( _('Custom'), _custom_toolbar )
-
+            toolbox.add_toolbar(_('Edit'), edit_toolbar)
+            
             self._basic_abacus(_abacus_toolbar)
 
             toolbox.set_current_toolbar(1)
@@ -156,18 +166,19 @@ class AbacusActivity(activity.Activity):
             elif hasattr(toolbox, 'props'):
                toolbox.props.visible = False
 
+        self.copyme = ' '
         # Add the buttons and spinners to the toolbars
         self.japanese = _button_factory("soroban-off", _('Soroban'),
                                         self._japanese_cb, _abacus_toolbar)
+        self.russian = _button_factory("schety-off", _('Schety'),
+                                       self._russian_cb, _abacus_toolbar)
         self.mayan = _button_factory("nepohualtzintzin-off",
                                      _('Nepohualtzintzin'),
                                      self._mayan_cb, _abacus_toolbar)
-        self.hex = _button_factory("hexadecimal-off", _('Hexadecimal'),
-                                   self._hex_cb, _abacus_toolbar)
         self.binary = _button_factory("binary-off", _('Binary'),
                                       self._binary_cb, _abacus_toolbar)
-        self.russian = _button_factory("schety-off", _('Schety'),
-                                       self._russian_cb, _abacus_toolbar)
+        self.hex = _button_factory("hex-off", _('Hexadecimal'),self._hex_cb, 
+                                   _abacus_toolbar)
         self.fraction = _button_factory("fraction-off", _('Fraction'),
                                         self._fraction_cb, _abacus_toolbar)
         self.caacupe = _button_factory("caacupe-off", _('Caacupé'),
@@ -195,6 +206,11 @@ class AbacusActivity(activity.Activity):
         self.custom = _button_factory("new-game", _('Custom'),
                                       self._custom_cb, _custom_toolbar)
 
+        copy = _button_factory('edit-copy',_('Copy'), self._copy_cb,
+                          edit_toolbar_button, accelerator='<Ctrl>c')
+        paste = _button_factory('edit-paste', _('Paste'), self._paste_cb,
+                          edit_toolbar_button, accelerator='<Ctrl>v')
+
         self.toolbox.show()
 
         # Create a canvas
@@ -207,7 +223,8 @@ class AbacusActivity(activity.Activity):
 
         # Initialize the canvas
         self.abacus = Abacus(canvas, self)
-
+        #self.abacusgeneric=AbacusGeneric(self)
+        
         # Read the current mode from the Journal
         try:
             self._rods_spin.set_value(int(self.metadata['rods']))
@@ -264,7 +281,7 @@ class AbacusActivity(activity.Activity):
         self.russian.set_icon("schety-off")
         self.mayan.set_icon("nepohualtzintzin-off")
         self.binary.set_icon("binary-off")
-        self.hex.set_icon("hexadecimal-off")
+        self.hex.set_icon("hex-off")
         self.fraction.set_icon("fraction-off")
         self.caacupe.set_icon("caacupe-off")
         self.cuisenaire.set_icon("cuisenaire-off")
@@ -318,7 +335,6 @@ class AbacusActivity(activity.Activity):
 
     def _custom_cb(self, button):
         """ Display the custom abacus; hide the others """
-        value = float(self.abacus.mode.value(count_beads=False))
         if self.abacus.custom is not None:
             self.abacus.custom.hide()
         self.abacus.custom = Custom(self.abacus,
@@ -328,28 +344,20 @@ class AbacusActivity(activity.Activity):
                              self._value_spin.get_value_as_int(),
                              self._base_spin.get_value_as_int())
         self._select_abacus(None, None, self.abacus.custom)
-        self.abacus.mode.set_value_from_number(value)
-        self.abacus.mode.label(self.abacus.generate_label())
 
     def _chinese_cb(self, button):
         """ Display the suanpan; hide the others """
-        value = float(self.abacus.mode.value(count_beads=False))
         if self.abacus.chinese is None:
             self.abacus.chinese = Suanpan(self.abacus)
         self._select_abacus(self.chinese, self.abacus.chinese.name+"-on",
                             self.abacus.chinese)
-        self.abacus.mode.set_value_from_number(value)
-        self.abacus.mode.label(self.abacus.generate_label())
 
     def _japanese_cb(self, button):
         """ Display the soroban; hide the others """
-        value = float(self.abacus.mode.value(count_beads=False))
         if self.abacus.japanese is None:
             self.abacus.japanese = Soroban(self.abacus)
         self._select_abacus(self.japanese, self.abacus.japanese.name+"-on",
                             self.abacus.japanese)
-        self.abacus.mode.set_value_from_number(value)
-        self.abacus.mode.label(self.abacus.generate_label())
 
     def _russian_cb(self, button):
         """ Display the schety; hide the others """
@@ -360,43 +368,31 @@ class AbacusActivity(activity.Activity):
 
     def _mayan_cb(self, button):
         """ Display the nepohualtzintzin; hide the others """
-        value = float(self.abacus.mode.value(count_beads=False))
         if self.abacus.mayan is None:
             self.abacus.mayan = Nepohualtzintzin(self.abacus)
         self._select_abacus(self.mayan, self.abacus.mayan.name+"-on",
                             self.abacus.mayan)
-        self.abacus.mode.set_value_from_number(value)
-        self.abacus.mode.label(self.abacus.generate_label())
 
     def _binary_cb(self, button):
         """ Display the binary; hide the others """
-        value = float(self.abacus.mode.value(count_beads=False))
         if self.abacus.binary is None:
             self.abacus.binary = Binary(self.abacus)
         self._select_abacus(self.binary, self.abacus.binary.name+"-on",
                             self.abacus.binary)
-        self.abacus.mode.set_value_from_number(value)
-        self.abacus.mode.label(self.abacus.generate_label())
 
     def _hex_cb(self, button):
         """ Display the hex; hide the others """
-        value = float(self.abacus.mode.value(count_beads=False))
         if self.abacus.hex is None:
             self.abacus.hex = Hex(self.abacus)
         self._select_abacus(self.hex, self.abacus.hex.name+"-on",
                             self.abacus.hex)
-        self.abacus.mode.set_value_from_number(value)
-        self.abacus.mode.label(self.abacus.generate_label())
 
     def _decimal_cb(self, button):
         """ Display the decimal; hide the others """
-        value = float(self.abacus.mode.value(count_beads=False))
         if self.abacus.decimal is None:
             self.abacus.decimal = Decimal(self.abacus)
         self._select_abacus(self.decimal, self.abacus.decimal.name+"-on",
                             self.abacus.decimal)
-        self.abacus.mode.set_value_from_number(value)
-        self.abacus.mode.label(self.abacus.generate_label())
 
     def _fraction_cb(self, button):
         """ Display the fraction; hide the others """
@@ -434,3 +430,22 @@ class AbacusActivity(activity.Activity):
         except:
             pass
 
+    def _copy_cb(self, arg = None):
+        """ Copy a number to the clipboard from the active slide. """
+        clipBoard = gtk.Clipboard()
+        if self.abacus.generate_label() is not None:
+            copyme = self.abacus.generate_label()#last.labels
+        if copyme is not None:
+            clipBoard.set_text(str(copyme))
+        return
+
+    def _paste_cb(self, arg = None):
+        """ Paste a number from the clipboard to the active silde. """
+        clipBoard = gtk.Clipboard()
+        text = clipBoard.wait_for_text()
+        if text is not None:
+            self.abacus.set_value_from_number(text)
+        return
+        
+
+
diff --git a/abacus_window.py b/abacus_window.py
index 9e27f0e..a1c60fb 100644
--- a/abacus_window.py
+++ b/abacus_window.py
@@ -435,7 +435,16 @@ class Abacus():
     def _destroy_cb(self, win, event):
         """ Callback to handle quit """
         gtk.main_quit()
-
+        
+    def set_value_from_number(self, text):
+        """ Set abacus to value in string """
+        number = float(text)
+        for r in range(self.mode.num_rods):
+            number -= self.mode.set_rod(r,number)
+            if number == 0:
+                break
+        self.mode.label(self.generate_label())
+            
     def generate_label(self, sum_only=False):
         """ The complexity below is to make the label as simple as possible """
         sum = ""
@@ -678,24 +687,7 @@ class AbacusGeneric():
         for r in range(self.num_rods):
             self.set_rod_value(r, v[r])
         return
-
-    def max_value(self):
-        """ Maximum value possible on abacus """
-        max = 0
-        for bead in self.beads:
-            max += bead.value
-        return max
-
-    def set_value_from_number(self, number):
-        """ Set abacus to value in string """
-        print "setting %s to %f" % (self.name, number)
-        self.reset_abacus()
-        if number <= self.max_value():
-            for r in range(self.num_rods):
-                number -= self.set_rod(r, number)
-                if number == 0:
-                    break
-
+         
     def set_rod(self, rod, number):
         bead = rod * (self.top_beads + self.bot_beads)
         bead_value = self.beads[bead + self.top_beads].value
@@ -757,24 +749,22 @@ class AbacusGeneric():
 
     def value(self, count_beads=False):
         """ Return a string representing the value of each rod. """
+        string = ''
+        v = []
+        for r in range(self.num_rods+1): # +1 for overflow
+            v.append(0)
 
-        if count_beads:
-            # Save the value associated with each rod as a 2-byte integer.
-            string = ''
-            v = []
-            for r in range(self.num_rods+1): # +1 for overflow
-                v.append(0)
-
-            # Tally the values on each rod.
-            for i, bead in enumerate(self.beads):
-                r = i/(self.top_beads+self.bot_beads)
-                j = i % (self.top_beads+self.bot_beads)
-                if bead.get_state() == 1:
-                    if j < self.top_beads:
-                        v[r+1] += self.top_factor
-                    else:
-                        v[r+1] += 1
+        # Tally the values on each rod.
+        for i, bead in enumerate(self.beads):
+            r = i/(self.top_beads+self.bot_beads)
+            j = i % (self.top_beads+self.bot_beads)
+            if bead.get_state() == 1:
+                if j < self.top_beads:
+                    v[r+1] += self.top_factor
+                else:
+                    v[r+1] += 1
 
+        if count_beads:
             # Save the value associated with each rod as a 2-byte integer.
             for j in v[1:]:
                 string += "%2d" % (j)
@@ -783,7 +773,7 @@ class AbacusGeneric():
             for bead in self.beads:
                 sum += bead.get_value()
             string = str(sum)
-            print self.name, string
+
         return(string)
 
     def label(self, string):
diff --git a/sprites.py b/sprites.py
index 2364335..8896d36 100644
--- a/sprites.py
+++ b/sprites.py
@@ -34,7 +34,7 @@ class Sprite manages individual sprites within the collection.
 
 Example usage:
         # Import the classes into your program.
-        from sprites import Sprites Sprite
+        from sprites import Sprites, Sprite
 
         # Create a new sprite collection for a gtk Drawing Area.
         my_drawing_area = gtk.DrawingArea()
@@ -75,14 +75,15 @@ def svg_str_to_pixbuf(svg_string):
 import pygtk
 pygtk.require('2.0')
 import gtk
+import gobject
 import pango
 
+#
+# A class for the list of sprites and everything they share in common
+#
 
 class Sprites:
-    """ A class for the list of sprites and everything they share in common """
-
     def __init__(self, canvas, area=None, gc=None):
-        """ Initialize an empty array of sprites """
         self.canvas = canvas
         if area == None:
             self.area = self.canvas.window
@@ -94,61 +95,51 @@ class Sprites:
         self.list = []
 
     def get_sprite(self, i):
-        """ Return a sprint from the array """
         if i < 0 or i > len(self.list)-1:
             return(None)
         else:
             return(self.list[i])
 
     def length_of_list(self):
-        """ How many sprites are there? """
         return(len(self.list))
 
     def append_to_list(self, spr):
-        """ Append a new sprite to the end of the list. """
         self.list.append(spr)
 
     def insert_in_list(self, spr, i):
-        """ Insert a sprite at position i. """
         if i < 0:
             self.list.insert(0, spr)
-        elif i > len(self.list) - 1:
+        elif i > len(self.list)-1:
             self.list.append(spr)
         else:
             self.list.insert(i, spr)
 
     def remove_from_list(self, spr):
-        """ Remove a sprite from the list. """
         if spr in self.list:
             self.list.remove(spr)
 
     def find_sprite(self, pos):
-        """ Search based on (x, y) position. Return the 'top/first' one. """
         list = self.list[:]
         list.reverse()
         for spr in list:
-            if spr.hit(pos):
-                return spr
+            if spr.hit(pos): return spr
         return None
 
     def redraw_sprites(self, area=None):
         """ Redraw the sprites that intersect area. """
         for spr in self.list:
-            if area == None:
-                spr.draw()
-            else:
-                intersection = spr.rect.intersect(area)
-                if intersection.width > 0 or intersection.height > 0:
-                    spr.draw()
+            spr.draw()
 
 
+#
+# A class for the individual sprites
+#
 class Sprite:
-    """ A class for the individual sprites """
-
     def __init__(self, sprites, x, y, image):
-        """ Initialize an individual sprite """
         self._sprites = sprites
+        self._x = int(x)
         self.rect = gtk.gdk.Rectangle(int(x), int(y), 0, 0)
+        self._y = int(y)
         self._scale = [12]
         self._rescale = [True]
         self._horiz_align = ["center"]
@@ -157,71 +148,65 @@ class Sprite:
         self._bold = False
         self._italic = False
         self._color = None
-        self._margins = [0, 0, 0, 0]
+        self._width = 0
+        self._height = 0
+        self._margins = [0,0,0,0]
         self.layer = 100
         self.labels = []
         self.images = []
-        self._dx = []  # image offsets
+        self._dx = [] # image offsets
         self._dy = []
         self.set_image(image)
         self._sprites.append_to_list(self)
 
     def set_image(self, image, i=0, dx=0, dy=0):
-        """ Add an image to the sprite. """
-        while len(self.images) < i + 1:
-            self.images.append(None)
-            self._dx.append(0)
-            self._dy.append(0)
+        while len(self.images) < i+1:
+           self.images.append(None)
+           self._dx.append(0)
+           self._dy.append(0)
         self.images[i] = image
         self._dx[i] = dx
         self._dy[i] = dy
-        if isinstance(self.images[i], gtk.gdk.Pixbuf):
-            w = self.images[i].get_width()
-            h = self.images[i].get_height()
+        if isinstance(image, gtk.gdk.Pixbuf):
+            _w = image.get_width()
+            _h = image.get_height()
         else:
-            w, h = self.images[i].get_size()
-        if i == 0:  # Always reset width and height when base image changes.
-            self.rect.width = w + dx
-            self.rect.height = h + dy
+            _w, _h = image.get_size()
+        if i == 0: # Always reset width and height when base image changes.
+            self._width = _w + dx
+            self._height = _h + dy
         else:
-            if w + dx > self.rect.width:
-                self.rect.width = w + dx
-            if h + dy > self.rect.height:
-                self.rect.height = h + dy
+            if _w + dx > self._width:
+                self._width = _w + dx
+            if _h + dy > self._height:
+                self._height = _h + dy
 
     def move(self, pos):
-        """ Move to new (x, y) position """
         self.inval()
-        self.rect.x, self.rect.y = int(pos[0]), int(pos[1])
+        self._x,self._y = int(pos[0]),int(pos[1])
         self.inval()
 
     def move_relative(self, pos):
-        """ Move to new (x+dx, y+dy) position """
         self.inval()
-        self.rect.x += int(pos[0])
-        self.rect.y += int(pos[1])
+        self._x += int(pos[0])
+        self._y += int(pos[1])
         self.inval()
 
     def get_xy(self):
-        """ Return current (x, y) position """
-        return (self.rect.x, self.rect.y)
+        return (self._x, self._y)
 
     def get_dimensions(self):
-        """ Return current size """
-        return (self.rect.width, self.rect.height)
+        return (self._width, self._height)
 
     def get_layer(self):
-        """ Return current layer """
         return self.layer
 
     def set_shape(self, image, i=0):
-        """ Set the current image associated with the sprite """
         self.inval()
         self.set_image(image, i)
         self.inval()
 
     def set_layer(self, layer):
-        """ Set the layer for a sprite """
         self._sprites.remove_from_list(self)
         self.layer = layer
         for i in range(self._sprites.length_of_list()):
@@ -233,43 +218,37 @@ class Sprite:
         self.inval()
 
     def set_label(self, new_label, i=0):
-        """ Set the label drawn on the sprite """
         self._extend_labels_array(i)
         if type(new_label) is str or type(new_label) is unicode:
             # pango doesn't like nulls
-            self.labels[i] = new_label.replace("\0", " ")
+            self.labels[i] = new_label.replace("\0"," ")
         else:
             self.labels[i] = str(new_label)
         self.inval()
 
     def set_margins(self, l=0, t=0, r=0, b=0):
-        """ Set the margins for drawing the label """
-        self._margins = [l, t, r, b]
+        self._margins = [l,t,r,b]
 
     def _extend_labels_array(self, i):
-        """ Append to the labels attribute list """
         if self._fd is None:
-            self.set_font('Sans')
+           self.set_font('Sans')
         if self._color is None:
-            self._color = self._sprites.cm.alloc_color('black')
-        while len(self.labels) < i + 1:
-            self.labels.append(" ")
-            self._scale.append(self._scale[0])
-            self._rescale.append(self._rescale[0])
-            self._horiz_align.append(self._horiz_align[0])
-            self._vert_align.append(self._vert_align[0])
+           self._color = self._sprites.cm.alloc_color('black')
+        while len(self.labels) < i+1:
+           self.labels.append(" ")
+           self._scale.append(self._scale[0])
+           self._rescale.append(self._rescale[0])
+           self._horiz_align.append(self._horiz_align[0])
+           self._vert_align.append(self._vert_align[0])
 
     def set_font(self, font):
-        """ Set the font for a label """
         self._fd = pango.FontDescription(font)
 
     def set_label_color(self, rgb):
-        """ Set the font color for a label """
         self._color = self._sprites.cm.alloc_color(rgb)
 
     def set_label_attributes(self, scale, rescale=True, horiz_align="center",
                              vert_align="middle", i=0):
-        """ Set the various label attributes """
         self._extend_labels_array(i)
         self._scale[i] = scale
         self._rescale[i] = rescale
@@ -277,124 +256,115 @@ class Sprite:
         self._vert_align[i] = vert_align
 
     def hide(self):
-        """ Hide a sprite """
         self.inval()
         self._sprites.remove_from_list(self)
 
     def inval(self):
-        """ Force a region redraw by gtk """
-        self._sprites.area.invalidate_rect(self.rect, False)
+        self._sprites.area.invalidate_rect(
+            gtk.gdk.Rectangle(self._x,self._y,self._width,self._height), False)
 
     def draw(self):
-        """ Draw the sprite (and label) """
-        for i, img in enumerate(self.images):
+        for i,img in enumerate(self.images):
             if isinstance(img, gtk.gdk.Pixbuf):
-                self._sprites.area.draw_pixbuf(self._sprites.gc, img, 0, 0,
-                                               self.rect.x + self._dx[i],
-                                               self.rect.y + self._dy[i])
+                self._sprites.area.draw_pixbuf(
+                    self._sprites.gc, img, 0, 0, self._x+self._dx[i],
+                                                 self._y+self._dy[i])
             elif img is not None:
-                self._sprites.area.draw_drawable(self._sprites.gc, img, 0, 0,
-                                                 self.rect.x + self._dx[i],
-                                                 self.rect.y + self._dy[i],
-                                                 -1, -1)
+                self._sprites.area.draw_drawable(
+                    self._sprites.gc, img, 0, 0, self._x+self._dx[i],
+                                                 self._y+self._dy[i], -1, -1)
         if len(self.labels) > 0:
             self.draw_label()
 
     def hit(self, pos):
-        """ Is (x, y) on top of the sprite? """
         x, y = pos
-        if x < self.rect.x:
+        if x < self._x:
             return False
-        if x > self.rect.x + self.rect.width:
+        if x > self._x+self._width:
             return False
-        if y < self.rect.y:
+        if y < self._y:
             return False
-        if y > self.rect.y + self.rect.height:
+        if y > self._y+self._height:
             return False
         return True
 
     def draw_label(self):
-        """ Draw the label based on its attributes """
-        my_width = self.rect.width - self._margins[0] - self._margins[2]
+        my_width = self._width-self._margins[0]-self._margins[2]
         if my_width < 0:
             my_width = 0
-        my_height = self.rect.height - self._margins[1] - self._margins[3]
+        my_height = self._height-self._margins[1]-self._margins[3]
         for i in range(len(self.labels)):
             pl = self._sprites.canvas.create_pango_layout(str(self.labels[i]))
-            self._fd.set_size(int(self._scale[i] * pango.SCALE))
+            self._fd.set_size(int(self._scale[i]*pango.SCALE))
             pl.set_font_description(self._fd)
-            w = pl.get_size()[0] / pango.SCALE
+            w = pl.get_size()[0]/pango.SCALE
             if w > my_width:
-                if self._rescale[i]:
+                if self._rescale[i] is True:
                     self._fd.set_size(
-                            int(self._scale[i] * pango.SCALE * my_width / w))
+                                    int(self._scale[i]*pango.SCALE*my_width/w))
                     pl.set_font_description(self._fd)
-                    w = pl.get_size()[0] / pango.SCALE
+                    w = pl.get_size()[0]/pango.SCALE
                 else:
-                    j = len(self.labels[i]) - 1
+                    j = len(self.labels[i])-1
                     while(w > my_width and j > 0):
                         pl = self._sprites.canvas.create_pango_layout(
-                              "…" + self.labels[i][len(self.labels[i]) - j:])
-                        self._fd.set_size(int(self._scale[i] * pango.SCALE))
+                                 "…"+self.labels[i][len(self.labels[i])-j:])
+                        self._fd.set_size(int(self._scale[i]*pango.SCALE))
                         pl.set_font_description(self._fd)
-                        w = pl.get_size()[0] / pango.SCALE
+                        w = pl.get_size()[0]/pango.SCALE        
                         j -= 1
             if self._horiz_align[i] == "center":
-                x = int(self.rect.x + self._margins[0] + (my_width - w) / 2)
+                x = int(self._x+self._margins[0]+(my_width-w)/2)
             elif self._horiz_align[i] == 'left':
-                x = int(self.rect.x + self._margins[0])
+                x = int(self._x+self._margins[0])
             else: # right
-                x = int(self.rect.x + self.rect.width - w - self._margins[2])
-            h = pl.get_size()[1] / pango.SCALE
+                x = int(self._x+self._width-w-self._margins[2])
+            h = pl.get_size()[1]/pango.SCALE
             if self._vert_align[i] == "middle":
-                y = int(self.rect.y + self._margins[1] + (my_height - h) / 2)
+                y = int(self._y+self._margins[1]+(my_height-h)/2)
             elif self._vert_align[i] == "top":
-                y = int(self.rect.y + self._margins[1])
+                y = int(self._y+self._margins[1])
             else: # bottom
-                y = int(self.rect.y + self.rect.height - h - self._margins[3])
+                y = int(self._y+self._height-h-self._margins[3])
             self._sprites.gc.set_foreground(self._color)
             self._sprites.area.draw_layout(self._sprites.gc, x, y, pl)
 
     def label_width(self):
-        """ Calculate the width of a label """
         max = 0
         for i in range(len(self.labels)):
             pl = self._sprites.canvas.create_pango_layout(self.labels[i])
-            self._fd.set_size(int(self._scale[i] * pango.SCALE))
+            self._fd.set_size(int(self._scale[i]*pango.SCALE))
             pl.set_font_description(self._fd)
-            w = pl.get_size()[0] / pango.SCALE
+            w = pl.get_size()[0]/pango.SCALE
             if w > max:
                 max = w
         return max
 
     def label_safe_width(self):
-        """ Return maximum width for a label """
-        return self.rect.width - self._margins[0] - self._margins[2]
-
+        return self._width-self._margins[0]-self._margins[2]
+    
     def label_safe_height(self):
-        """ Return maximum height for a label """
-        return self.rect.height - self._margins[1] - self._margins[3]
-
+        return self._height-self._margins[1]-self._margins[3]
+    
     def label_left_top(self):
-        """ Return the upper-left corner of the label safe zone """
-        return(self._margins[0], self._margins[1])
+        return (self._margins[0], self._margins[1])
 
     def get_pixel(self, pos, i=0):
-        """ Return the pixl at (x, y) """
         x, y = pos
-        x = x - self.rect.x
-        y = y - self.rect.y
-        if y > self.images[i].get_height() - 1:
-            return(-1, -1, -1, -1)
+        x = x-self._x
+        y = y-self._y
+        if y > self.images[i].get_height()-1:
+            return (-1,-1,-1,-1)
         try:
             array = self.images[i].get_pixels()
             if array is not None:
-                offset = (y * self.images[i].get_width() + x) * 4
-                r, g, b, a = ord(array[offset]), ord(array[offset + 1]),\
-                             ord(array[offset + 2]), ord(array[offset + 3])
-                return(r, g, b, a)
+                offset = (y*self.images[i].get_width()+x)*4
+                r,g,b,a = ord(array[offset]), ord(array[offset+1]),\
+                          ord(array[offset+2]), ord(array[offset+3])
+                return (r,g,b,a)
             else:
-                return(-1, -1, -1, -1)
+                return (-1,-1,-1,-1)
         except IndexError:
             print "Index Error: %d %d" % (len(array), offset)
-            return(-1, -1, -1, -1)
+            return (-1,-1,-1,-1)
+
-- 
1.7.2.2



More information about the Sugar-devel mailing list