From 0dda14673db1ef15406be54923ed5223fb5ab75a Mon Sep 17 00:00:00 2001
From: Walter Bender <walter@sugarlabs.org>
Date: Tue, 25 Jun 2013 19:41:02 +0000
Subject: migrate to turtle-centric model

---
(limited to 'TurtleArt/taturtle.py')

diff --git a/TurtleArt/taturtle.py b/TurtleArt/taturtle.py
index 7db72e6..cbf86c8 100644
--- a/TurtleArt/taturtle.py
+++ b/TurtleArt/taturtle.py
@@ -19,22 +19,30 @@
 #OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 #THE SOFTWARE.
 
-from random import uniform
-from math import sin, cos, pi, sqrt
+import os
+
 import gtk
+import gobject
 import cairo
 
-from taconstants import (TURTLE_LAYER, DEFAULT_TURTLE_COLORS)
-from tasprite_factory import (SVG, svg_str_to_pixbuf)
-from tacanvas import (wrap100, COLOR_TABLE)
+from random import uniform
+from math import sin, cos, pi, sqrt
+
+from taconstants import (TURTLE_LAYER, DEFAULT_TURTLE_COLORS, DEFAULT_TURTLE,
+                         COLORDICT)
+from tasprite_factory import SVG, svg_str_to_pixbuf
+from tacanvas import wrap100, COLOR_TABLE
 from sprites import Sprite
-from tautils import debug_output
+from tautils import (debug_output, data_to_string, round_int, get_path,
+                     image_to_base64)
 
 SHAPES = 36
+DEGTOR = pi / 180.
+RTODEG = 180. / pi
 
 
 def generate_turtle_pixbufs(colors):
-    """ Generate pixbufs for generic turtles """
+    ''' Generate pixbufs for generic turtles '''
     shapes = []
     svg = SVG()
     svg.set_scale(1.0)
@@ -46,106 +54,191 @@ def generate_turtle_pixbufs(colors):
 
 class Turtles:
 
-    def __init__(self, sprite_list):
-        """ Class to hold turtles """
-        self.dict = dict()
-        self.sprite_list = sprite_list
-        self.default_pixbufs = []
-
-    def get_turtle(self, k, append=False, colors=None):
-        """ Find a turtle """
-        if k in self.dict:
-            return self.dict[k]
+    def __init__(self, turtle_window):
+        ''' Class to hold turtles '''
+        self.turtle_window = turtle_window
+        self.sprite_list = turtle_window.sprite_list
+        self.width = turtle_window.width
+        self.height = turtle_window.height
+        self.dict = {}
+        self._default_pixbufs = []
+        self._active_turtle = None
+        self._default_turtle_name = DEFAULT_TURTLE
+
+    def get_turtle(self, turtle_name, append=False, colors=None):
+        ''' Find a turtle '''
+        if turtle_name in self.dict:
+            return self.dict[turtle_name]
         elif not append:
             return None
         else:
             if colors is None:
-                Turtle(self, k)
+                Turtle(self, turtle_name)
             elif isinstance(colors, (list, tuple)):
-                Turtle(self, k, colors)
+                Turtle(self, turtle_name, colors)
             else:
-                Turtle(self, k, colors.split(','))
-            return self.dict[k]
+                Turtle(self, turtle_name, colors.split(','))
+            return self.dict[turtle_name]
 
     def get_turtle_key(self, turtle):
-        """ Find a turtle's name """
-        for k in iter(self.dict):
-            if self.dict[k] == turtle:
-                return k
+        ''' Find a turtle's name '''
+        for turtle_name in iter(self.dict):
+            if self.dict[turtle_name] == turtle:
+                return turtle_name
         return None
 
     def turtle_count(self):
-        """ How many turtles are there? """
+        ''' How many turtles are there? '''
         return(len(self.dict))
 
-    def add_to_dict(self, k, turtle):
-        """ Add a new turtle """
-        self.dict[k] = turtle
+    def add_to_dict(self, turtle_name, turtle):
+        ''' Add a new turtle '''
+        self.dict[turtle_name] = turtle
 
-    def remove_from_dict(self, k):
-        """ Delete a turtle """
-        if k in self.dict:
-            del(self.dict[k])
+    def remove_from_dict(self, turtle_name):
+        ''' Delete a turtle '''
+        if turtle_name in self.dict:
+            del(self.dict[turtle_name])
 
     def show_all(self):
-        """ Make all turtles visible """
-        for k in iter(self.dict):
-            self.dict[k].show()
+        ''' Make all turtles visible '''
+        for turtle_name in iter(self.dict):
+            self.dict[turtle_name].show()
 
     def spr_to_turtle(self, spr):
-        """ Find the turtle that corresponds to sprite spr. """
-        for k in iter(self.dict):
-            if spr == self.dict[k].spr:
-                return self.dict[k]
+        ''' Find the turtle that corresponds to sprite spr. '''
+        for turtle_name in iter(self.dict):
+            if spr == self.dict[turtle_name].spr:
+                return self.dict[turtle_name]
         return None
 
     def get_pixbufs(self):
-        """ Get the pixbufs for the default turtle shapes. """
-        if self.default_pixbufs == []:
-            self.default_pixbufs = generate_turtle_pixbufs(
+        ''' Get the pixbufs for the default turtle shapes. '''
+        if self._default_pixbufs == []:
+            self._default_pixbufs = generate_turtle_pixbufs(
                 ["#008000", "#00A000"])
-        return(self.default_pixbufs)
+        return(self._default_pixbufs)
+
+    def turtle_to_screen_coordinates(self, pos):
+        ''' The origin of turtle coordinates is the center of the screen '''
+        return [self.width / 2.0 + pos[0], self._invert_y_coordinate(pos[1])]
+
+    def screen_to_turtle_coordinates(self, pos):
+        ''' The origin of the screen coordinates is the upper-left corner '''
+        return [pos[0] - self.width / 2.0, self._invert_y_coordinate(pos[1])]
+
+    def _invert_y_coordinate(self, y):
+        ''' Positive y goes up in turtle coordinates, down in sceeen
+        coordinates '''
+        return self.height / 2.0 - y
+
+    def reset_turtles(self):
+        for turtle_name in iter(self.dict):
+            self.set_turtle(turtle_name)
+            if not self._active_turtle.get_remote():
+                self._active_turtle.set_color(0)
+                self._active_turtle.set_shade(50)
+                self._active_turtle.set_gray(100)
+                self._active_turtle.set_pen_size(5)
+                self._active_turtle.reset_shapes()
+                self._active_turtle.set_heading(0.0)
+                self._active_turtle.set_pen_state(False)
+                self._active_turtle.move_turtle((0.0, 0.0))
+                self._active_turtle.set_pen_state(True)
+                self._active_turtle.set_fill(False)
+                self._active_turtle.hide()
+        self.set_turtle(self._default_turtle_name)
+
+    def set_turtle(self, turtle_name, colors=None):
+        ''' Select the current turtle and associated pen status '''
+        if turtle_name not in self.dict:
+            # if it is a new turtle, start it in the center of the screen
+            self._active_turtle = self.get_turtle(turtle_name, True, colors)
+            self._active_turtle.set_heading(0.0, False)
+            self._active_turtle.set_xy((0.0, 0.0), False, pendown=False)
+            self._active_turtle.set_pen_state(True)
+        elif colors is not None:
+            self._active_turtle = self.get_turtle(turtle_name, False)
+            self._active_turtle.set_turtle_colors(colors)
+        else:
+            self._active_turtle = self.get_turtle(turtle_name, False)
+        self._active_turtle.show()
+        self._active_turtle.set_color(share=False)
+        self._active_turtle.set_gray(share=False)
+        self._active_turtle.set_shade(share=False)
+        self._active_turtle.set_pen_size(share=False)
+        self._active_turtle.set_pen_state(share=False)
+
+    def set_default_turtle_name(self, name):
+        self._default_turtle_name = name
+
+    def get_default_turtle_name(self):
+        return self._default_turtle_name
+
+    def set_active_turtle(self, active_turtle):
+        self._active_turtle = active_turtle
+
+    def get_active_turtle(self):
+        return self._active_turtle
 
 
 class Turtle:
 
-    def __init__(self, turtles, key, turtle_colors=None):
-        """ The turtle is not a block, just a sprite with an orientation """
-        self.x = 0.0
-        self.y = 0.0
+    def __init__(self, turtles, turtle_name, turtle_colors=None):
+        ''' The turtle is not a block, just a sprite with an orientation '''
+        self.turtles = turtles
+        self.spr = None
         self.hidden = False
         self.shapes = []
         self.custom_shapes = False
         self.type = 'turtle'
-        self.name = key
+        self.name = turtle_name
+        self.remote = False
+        self.x = 0.0
+        self.y = 0.0
         self.heading = 0.0
+        self.half_width = 0
+        self.half_height = 0
         self.pen_shade = 50
         self.pen_color = 0
         self.pen_gray = 100
         self.pen_size = 5
         self.pen_state = True
+        self.pen_fill = False
+        self.pen_poly_points = []
         self.label_block = None
 
-        self._prep_shapes(key, turtles, turtle_colors)
+        self._prep_shapes(turtle_name, self.turtles, turtle_colors)
 
-        # Choose a random angle from which to attach the turtle label.
+        # Create a sprite for the turtle in interactive mode.
         if turtles.sprite_list is not None:
-            self.spr = Sprite(turtles.sprite_list, 0, 0, self.shapes[0])
+            self.spr = Sprite(self.turtles.sprite_list, 0, 0, self.shapes[0])
+
+            self.half_width = int(self.spr.rect.width / 2.0)
+            self.half_height = int(self.spr.rect.height / 2.0)
+
+            # Choose a random angle from which to attach the turtle
+            # label to be used when sharing.
             angle = uniform(0, pi * 4 / 3.0)  # 240 degrees
-            w = self.shapes[0].get_width()
-            r = w * 0.67
-            # Restrict angle the the sides 30-150; 210-330
+            width = self.shapes[0].get_width()
+            radius = width * 0.67
+            # Restrict the angle to the sides: 30-150; 210-330
             if angle > pi * 2 / 3.0:
                 angle += pi / 2.0  # + 90
-                self.label_xy = [int(r * sin(angle)),
-                                 int(r * cos(angle) + w / 2.0)]
+                self.label_xy = [int(radius * sin(angle)),
+                                 int(radius * cos(angle) + width / 2.0)]
             else:
                 angle += pi / 6.0  # + 30
-                self.label_xy = [int(r * sin(angle) + w / 2.0),
-                                 int(r * cos(angle) + w / 2.0)]
-        else:
-            self.spr = None
-        turtles.add_to_dict(key, self)
+                self.label_xy = [int(radius * sin(angle) + width / 2.0),
+                                 int(radius * cos(angle) + width / 2.0)]
+
+        self.turtles.add_to_dict(turtle_name, self)
+
+    def set_remote(self):
+        self.remote = True
+
+    def get_remote(self):
+        return self.remote
 
     def _prep_shapes(self, name, turtles=None, turtle_colors=None):
         # If the turtle name is an int, we'll use a palette color as the
@@ -175,10 +268,10 @@ class Turtle:
         if turtle_colors is not None:
             self.colors = turtle_colors[:]
             self.shapes = generate_turtle_pixbufs(self.colors)
-            self.set_heading(self.heading)
+            self.set_heading(self.heading, share=False)
 
     def set_shapes(self, shapes, i=0):
-        """ Reskin the turtle """
+        ''' Reskin the turtle '''
         n = len(shapes)
         if n == 1 and i > 0:  # set shape[i]
             if i < len(self.shapes):
@@ -188,7 +281,7 @@ class Turtle:
         else:  # rotate shapes
             if n != 1:
                 debug_output("%d images passed to set_shapes: ignoring" % (n),
-                             self.tw.running_sugar)
+                             self.turtles.turtle_window.running_sugar)
             if self.heading == 0.0:  # rotate the shapes
                 images = []
                 w, h = shapes[0].get_width(), shapes[0].get_height()
@@ -197,11 +290,11 @@ class Turtle:
                     surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, nw, nh)
                     context = cairo.Context(surface)
                     context = gtk.gdk.CairoContext(context)
-                    context.translate(nw / 2., nh / 2.)
+                    context.translate(nw / 2.0, nh / 2.0)
                     context.rotate(i * 10 * pi / 180.)
-                    context.translate(-nw / 2., -nh / 2.)
-                    context.set_source_pixbuf(shapes[0], (nw - w) / 2.,
-                                              (nh - h) / 2.)
+                    context.translate(-nw / 2.0, -nh / 2.0)
+                    context.set_source_pixbuf(shapes[0], (nw - w) / 2.0,
+                                              (nh - h) / 2.0)
                     context.rectangle(0, 0, nw, nh)
                     context.fill()
                     images.append(surface)
@@ -213,14 +306,21 @@ class Turtle:
         self.show()
 
     def reset_shapes(self):
-        """ Reset the shapes to the standard turtle """
+        ''' Reset the shapes to the standard turtle '''
         if self.custom_shapes:
             self.shapes = generate_turtle_pixbufs(self.colors)
             self.custom_shapes = False
 
-    def set_heading(self, heading):
-        """ Set the turtle heading (one shape per 360/SHAPES degrees) """
-        self.heading = heading
+    def set_heading(self, heading, share=True):
+        ''' Set the turtle heading (one shape per 360/SHAPES degrees) '''
+        try:
+            self.heading = heading
+        except (TypeError, ValueError):
+            debug_output('bad value sent to %s' % (__name__),
+                         self.turtles.turtle_window.running_sugar)
+            return
+        self.heading %= 360
+
         i = (int(self.heading + 5) % 360) / (360 / SHAPES)
         if not self.hidden and self.spr is not None:
             try:
@@ -228,28 +328,140 @@ class Turtle:
             except IndexError:
                 self.spr.set_shape(self.shapes[0])
 
-    def set_color(self, color):
-        """ Set the pen color for this turtle. """
-        self.pen_color = color
-
-    def set_gray(self, gray):
-        """ Set the pen gray level for this turtle. """
-        self.pen_gray = gray
-
-    def set_shade(self, shade):
-        """ Set the pen shade for this turtle. """
-        self.pen_shade = shade
-
-    def set_pen_size(self, pen_size):
-        """ Set the pen size for this turtle. """
-        self.pen_size = pen_size
+        if self.turtles.turtle_window.sharing() and share:
+            event = 'r|%s' % (data_to_string([self.turtles.turtle_window.nick,
+                                              round_int(self.heading)]))
+            self.turtles.turtle_window.send_event(event)
+
+    def set_color(self, color=None, share=True):
+        ''' Set the pen color for this turtle. '''
+        # Special case for color blocks
+        if color is not None and color in COLORDICT:
+            self.set_shade(COLORDICT[color][1], share)
+            self.set_gray(COLORDICT[color][2], share)
+            if COLORDICT[color][0] is not None:
+                self.set_color(COLORDICT[color][0], share)
+                color = COLORDICT[color][0]
+            else:
+                color = self.pen_color
 
-    def set_pen_state(self, pen_state):
-        """ Set the pen state (down==True) for this turtle. """
-        self.pen_state = pen_state
+        try:
+            self.pen_color = color
+        except (TypeError, ValueError):
+            debug_output('bad value sent to %s' % (__name__),
+                         self.turtles.turtle_window.running_sugar)
+            return
+
+        self.turtles.turtle_window.canvas.set_fgcolor(shade=self.pen_shade,
+                                                      gray=self.pen_gray,
+                                                      color=self.pen_color)
+
+        if self.turtles.turtle_window.sharing() and share:
+            event = 'c|%s' % (data_to_string([self.turtles.turtle_window.nick,
+                                              round_int(self.pen_color)]))
+            self.turtles.turtle_window.send_event(event)
+
+    def set_gray(self, gray=None, share=True):
+        ''' Set the pen gray level for this turtle. '''
+        if gray is not None:
+            try:
+                self.pen_gray = gray
+            except (TypeError, ValueError):
+                debug_output('bad value sent to %s' % (__name__),
+                             self.turtles.turtle_window.running_sugar)
+                return
+
+        if self.pen_gray < 0:
+            self.pen_gray = 0
+        if self.pen_gray > 100:
+            self.pen_gray = 100
+
+        self.turtles.turtle_window.canvas.set_fgcolor(shade=self.pen_shade,
+                                                      gray=self.pen_gray,
+                                                      color=self.pen_color)
+
+        if self.turtles.turtle_window.sharing() and share:
+            event = 'g|%s' % (data_to_string([self.turtles.turtle_window.nick,
+                                              round_int(self.pen_gray)]))
+            self.turtles.turtle_window.send_event(event)
+
+    def set_shade(self, shade=None, share=True):
+        ''' Set the pen shade for this turtle. '''
+        if shade is not None:
+            try:
+                self.pen_shade = shade
+            except (TypeError, ValueError):
+                debug_output('bad value sent to %s' % (__name__),
+                             self.turtles.turtle_window.running_sugar)
+                return
+
+        self.turtles.turtle_window.canvas.set_fgcolor(shade=self.pen_shade,
+                                                      gray=self.pen_gray,
+                                                      color=self.pen_color)
+
+        if self.turtles.turtle_window.sharing() and share:
+            event = 's|%s' % (data_to_string([self.turtles.turtle_window.nick,
+                                              round_int(self.pen_shade)]))
+            self.turtles.turtle_window.send_event(event)
+
+    def set_pen_size(self, pen_size=None, share=True):
+        ''' Set the pen size for this turtle. '''
+        if pen_size is not None:
+            try:
+                self.pen_size = max(0, pen_size)
+            except (TypeError, ValueError):
+                debug_output('bad value sent to %s' % (__name__),
+                             self.turtles.turtle_window.running_sugar)
+                return
+
+        self.turtles.turtle_window.canvas.set_pen_size(self.pen_size)
+
+        if self.turtles.turtle_window.sharing() and share:
+            event = 'w|%s' % (data_to_string([self.turtles.turtle_window.nick,
+                                              round_int(self.pen_size)]))
+            self.turtles.turtle_window.send_event(event)
+
+    def set_pen_state(self, pen_state=None, share=True):
+        ''' Set the pen state (down==True) for this turtle. '''
+        if pen_state is not None:
+            self.pen_state = pen_state
+
+        if self.turtles.turtle_window.sharing() and share:
+            event = 'p|%s' % (data_to_string([self.turtles.turtle_window.nick,
+                                              self._pen_state]))
+            self.turtles.turtle_window.send_event(event)
+
+    def set_fill(self, state=False):
+        self.pen_fill = state
+        if not self.pen_fill:
+            self.poly_points = []
+
+    def set_poly_points(self, poly_points=None):
+        if poly_points is not None:
+            self.poly_points = poly_points[:]
+
+    def start_fill(self):
+        self.pen_fill = True
+        self.poly_points = []
+
+    def stop_fill(self, share=True):
+        self.pen_fill = False
+        if len(self.poly_points) == 0:
+            return
+
+        self.turtles.turtle_window.canvas.fill_polygon(self.poly_points)
+
+        if self.turtles.turtle_window.sharing() and share:
+            shared_poly_points = []
+            for p in self.poly_points:
+                shared_poly_points.append(
+                    (self.turtles.screen_to_turtle_coordinates(p)))
+                event = 'F|%s' % (data_to_string(
+                        [self.turtles.turtle_window.nick, shared_poly_points]))
+            self.turtles.turtle_window.send_event(event)
+        self.poly_points = []
 
     def hide(self):
-        """ Hide the turtle. """
         if self.spr is not None:
             self.spr.hide()
         if self.label_block is not None:
@@ -257,7 +469,6 @@ class Turtle:
         self.hidden = True
 
     def show(self):
-        """ Show the turtle. """
         if self.spr is not None:
             self.spr.set_layer(TURTLE_LAYER)
             self.hidden = False
@@ -266,44 +477,244 @@ class Turtle:
         if self.label_block is not None:
             self.label_block.spr.set_layer(TURTLE_LAYER + 1)
 
-    def move(self, pos):
-        """ Move the turtle. """
+    def move_turtle(self, pos=None):
+        ''' Move the turtle's position '''
+        if pos is None:
+            pos = self.get_xy()
+
         self.x, self.y = pos[0], pos[1]
-        if not self.hidden and self.spr is not None:
-            self.spr.move((int(pos[0]), int(pos[1])))
-        if self.label_block is not None:
-            self.label_block.spr.move((int(pos[0] + self.label_xy[0]),
-                                       int(pos[1] + self.label_xy[1])))
-        return(self.x, self.y)
+        self.move(pos)
+
+    def move(self, pos):
+        ''' Move the turtle's sprite '''
+        # self.x, self.y = pos[0], pos[1]
+        pos = self.turtles.turtle_to_screen_coordinates(pos)
+
+        # In interactive mode, center the sprite around the turtle position
+        if self.spr is not None:
+            pos[0] -= self.half_width
+            pos[1] -= self.half_height
+
+            if not self.hidden and self.spr is not None:
+                self.spr.move(pos)
+            if self.label_block is not None:
+                self.label_block.spr.move((pos[0] + self.label_xy[0],
+                                           pos[1] + self.label_xy[1]))
+
+    def right(self, degrees, share=True):
+        ''' Rotate turtle clockwise '''
+        try:
+            self.heading += degrees
+        except (TypeError, ValueError):
+            debug_output('bad value sent to %s' % (__name__),
+                         self.turtles.turtle_window.running_sugar)
+            return
+        self.heading %= 360
+
+        if self.turtles.turtle_window.sharing() and share:
+            event = 'r|%s' % (data_to_string([self.turtles.turtle_window.nick,
+                                              round_int(self.heading)]))
+            self.turtles.turtle_window.send_event(event)
+
+    def _draw_line(self, old, new, pendown):
+        if self.pen_state and pendown:
+            self.turtles.turtle_window.canvas.set_source_rgb()
+            pos1 = self.turtles.turtle_to_screen_coordinates(old)
+            pos2 = self.turtles.turtle_to_screen_coordinates(new)
+            self.turtles.turtle_window.canvas.draw_line(pos1[0], pos1[1],
+                                                        pos2[0], pos2[1])
+            if self.pen_fill:
+                if self.poly_points == []:
+                    self.poly_points.append(('move', pos1[0], pos1[1]))
+                self.poly_points.append(('line', pos2[0], pos2[1]))
+
+    def forward(self, distance, share=True):
+        scaled_distance = distance * self.turtles.turtle_window.coord_scale
+
+        old = self.get_xy()
+        try:
+            xcor = old[0] + scaled_distance * sin(self.heading * DEGTOR)
+            ycor = old[1] + scaled_distance * cos(self.heading * DEGTOR)
+        except (TypeError, ValueError):
+            debug_output('bad value sent to %s' % (__name__),
+                         self.turtles.turtle_window.running_sugar)
+            return
+
+        self._draw_line(old, (xcor, ycor), True)
+        self.move_turtle((xcor, ycor))
+
+        if self.turtles.turtle_window.sharing() and share:
+            event = 'f|%s' % (data_to_string([self.turtles.turtle_window.nick,
+                                              int(distance)]))
+            self.turtles.turtle_window.send_event(event)
+
+    def set_xy(self, pos, share=True, pendown=True):
+        old = self.get_xy()
+
+        try:
+            xcor = pos[0] * self.turtles.turtle_window.coord_scale
+            ycor = pos[1] * self.turtles.turtle_window.coord_scale
+        except (TypeError, ValueError):
+            debug_output('bad value sent to %s' % (__name__),
+                         self.turtles.turtle_window.running_sugar)
+            return
+
+        self._draw_line(old, (xcor, ycor), pendown)
+        self.move_turtle((xcor, ycor))
+
+        if self.turtles.turtle_window.sharing() and share:
+            event = 'x|%s' % (data_to_string([self.turtles.turtle_window.nick,
+                                              [round_int(x), round_int(y)]]))
+            self.turtles.turtle_window.send_event(event)
+
+    def arc(self, a, r, share=True):
+        ''' Draw an arc '''
+        if self.pen_state:
+            self.turtles.turtle_window.canvas.set_source_rgb()
+        try:
+            if a < 0:
+                pos = self.larc(-a, r)
+            else:
+                pos = self.rarc(a, r)
+        except (TypeError, ValueError):
+            debug_output('bad value sent to %s' % (__name__),
+                         self.turtles.turtle_window.running_sugar)
+            return
+
+        self.move_turtle(pos)
+
+        if self.turtles.turtle_window.sharing() and share:
+            event = 'a|%s' % (data_to_string([self.turtles.turtle_window.nick,
+                                              [round_int(a), round_int(r)]]))
+            self.turtles.turtle_window.send_event(event)
+
+    def rarc(self, a, r):
+        ''' draw a clockwise arc '''
+        r *= self.turtles.turtle_window.coord_scale
+        if r < 0:
+            r = -r
+            a = -a
+        pos = self.get_xy()
+        cx = pos[0] + r * cos(self.heading * DEGTOR)
+        cy = pos[1] - r * sin(self.heading * DEGTOR)
+        if self.pen_state:
+            npos = self.turtles.turtle_to_screen_coordinates((cx, cy))
+            self.turtles.turtle_window.canvas.rarc(npos[0], npos[1], r, a,
+                                                   self.heading)
+
+            if self.pen_fill:
+                if self.poly_points == []:
+                    self.poly_points.append(('move', npos[0], npos[1]))
+                    self.poly_points.append(('rarc', npos[0], npos[1], r,
+                                             (self.heading - 180) * DEGTOR,
+                                             (self.heading - 180 + a) * DEGTOR))
+
+        self.right(a, False)
+        return [cx - r * cos(self.heading * DEGTOR),
+                cy + r * sin(self.heading * DEGTOR)]
+
+    def larc(self, a, r):
+        ''' draw a counter-clockwise arc '''
+        r *= self.turtles.turtle_window.coord_scale
+        if r < 0:
+            r = -r
+            a = -a
+        pos = self.get_xy()
+        cx = pos[0] - r * cos(self.heading * DEGTOR)
+        cy = pos[1] + r * sin(self.heading * DEGTOR)
+        if self.pen_state:
+            npos = self.turtles.turtle_to_screen_coordinates((cx, cy))
+            self.turtles.turtle_window.canvas.larc(npos[0], npos[1], r, a,
+                                                   self.heading)
+
+            if self.pen_fill:
+                if self.poly_points == []:
+                    self.poly_points.append(('move', npos[0], npos[1]))
+                    self.poly_points.append(('larc', npos[0], npos[1], r,
+                                             (self.heading) * DEGTOR,
+                                             (self.heading - a) * DEGTOR))
+
+        self.right(-a, False)
+        return [cx + r * cos(self.heading * DEGTOR),
+                cy - r * sin(self.heading * DEGTOR)]
+
+    def draw_pixbuf(self, pixbuf, a, b, x, y, w, h, path, share=True):
+        ''' Draw a pixbuf '''
+
+        self.turtles.turtle_window.canvas.draw_pixbuf(
+            pixbuf, a, b, x, y, w, h, self.heading)
+
+        if self.turtles.turtle_window.sharing() and share:
+            if self.turtles.turtle_window.running_sugar:
+                tmp_path = get_path(self.turtles.turtle_window.activity,
+                                    'instance')
+            else:
+                tmp_path = '/tmp'
+            tmp_file = os.path.join(
+                get_path(self.turtles.turtle_window.activity, 'instance'),
+                'tmpfile.png')
+            pixbuf.save(tmp_file, 'png', {'quality': '100'})
+            data = image_to_base64(tmp_file, tmp_path)
+            height = pixbuf.get_height()
+            width = pixbuf.get_width()
+
+            pos = self.screen_to_turtle_coordinates((x, y))
+
+            event = 'P|%s' % (data_to_string([self.turtles.turtle_window.nick,
+                                              [round_int(a), round_int(b),
+                                               round_int(pos[0]),
+                                               round_int(pos[1]),
+                                               round_int(w), round_int(h),
+                                               round_int(width),
+                                               round_int(height),
+                                               data]]))
+            gobject.idle_add(self.turtles.turtle_window.send_event, event)
+
+            os.remove(tmp_file)
+
+    def draw_text(self, label, x, y, size, w, share=True):
+        ''' Draw text '''
+        self.turtles.turtle_window.canvas.draw_text(
+            label, x, y, size, w, self.heading,
+            self.turtles.turtle_window.coord_scale)
+
+        if self.turtles.turtle_window.sharing() and share:
+            event = 'W|%s' % (data_to_string([self.turtles.turtle_window.nick,
+                                              [label, round_int(x),
+                                               round_int(y), round_int(size),
+                                               round_int(w)]]))
+            self.turtles.turtle_window.send_event(event)
 
     def get_name(self):
-        ''' return turtle name (key) '''
         return self.name
 
     def get_xy(self):
-        """ Return the turtle's x, y coordinates. """
-        return(self.x, self.y)
+        return [self.x, self.y]
 
     def get_heading(self):
-        """ Return the turtle's heading. """
-        return(self.heading)
+        return self.heading
 
     def get_color(self):
-        """ Return the turtle's color. """
-        return(self.pen_color)
+        return self.pen_color
 
     def get_gray(self):
-        """ Return the turtle's gray level. """
-        return(self.pen_gray)
+        return self.pen_gray
 
     def get_shade(self):
-        """ Return the turtle's shade. """
-        return(self.pen_shade)
+        return self.pen_shade
 
     def get_pen_size(self):
-        """ Return the turtle's pen size. """
-        return(self.pen_size)
+        return self.pen_size
 
     def get_pen_state(self):
-        """ Return the turtle's pen state. """
-        return(self.pen_state)
+        return self.pen_state
+
+    def get_fill(self):
+        return self.pen_fill
+
+    def get_poly_points(self):
+        return self.poly_points
+
+    def get_pixel(self):
+        pos = self.turtles.turtle_to_screen_coordinates(self.get_xy())
+        return self.turtles.turtle_window.canvas.get_pixel(pos[0], pos[1])
--
cgit v0.9.1