Merge lp:~tswast/cairoplot/trunk into lp:cairoplot

[Tim Swast]

This is largely an architectural change. It seems to make some sense to me that the various ways of creating a Cairo canvas should be separate from the Plots which use those canvases. This is inspired by the Lua port of Cairo plot.

Also, this adds the ability to easily embed Cairo Plot inside a GTK application. This opens the door to being able to do interactive plots.

Finally, Bug #426559 (PDF output broken) is fixed by these changes. The PDF handler correctly creates a PDF Cairo surface.

I've run the tests included, and it seems to be 100% compatible.

[lp:~tswast/cairoplot/trunk]

43. By Tim Swast on 2010-03-19

Removed trailing white-space.

44. By Tim Swast on 2010-03-19

Improved plot labels, so we don't get a 20 char long representation for what is effectively 0.

45. By Tim Swast on 2010-03-20

Removed trailing white-space.

46. By Tim Swast on 2010-03-20

Hacked together "fix" for infinite loop caused by xmin==xmax.

47. By Tim Swast on 2010-03-22

Fixed bug with plotting multiple equations in FunctionPlot.

48. By Tim Swast on 2010-03-25

Added checks to allow plotting functions with axes outside valid bounds of equation.

49. By Tim Swast on 2010-03-26

Fixed nan check for python 2.5.

50. By Tim Swast on 2010-04-06

Added OverflowError detection to make plotting more robust.

Unmerged revisions

50. By Tim Swast on 2010-04-06

Added OverflowError detection to make plotting more robust.

49. By Tim Swast on 2010-03-26

Fixed nan check for python 2.5.

48. By Tim Swast on 2010-03-25

Added checks to allow plotting functions with axes outside valid bounds of equation.

47. By Tim Swast on 2010-03-22

Fixed bug with plotting multiple equations in FunctionPlot.

46. By Tim Swast on 2010-03-20

Hacked together "fix" for infinite loop caused by xmin==xmax.

45. By Tim Swast on 2010-03-20

Removed trailing white-space.

44. By Tim Swast on 2010-03-19

Improved plot labels, so we don't get a 20 char long representation for what is effectively 0.

43. By Tim Swast on 2010-03-19

Removed trailing white-space.

42. By Tim Swast on 2010-02-28

Added Handler for created plots in as a GTK widget.

41. By Tim Swast on 2010-02-28

Created "Handlers" for different file formats to move surface creation code out of Plot objects (inspired by LuaPlot).

=== added directory 'trunk/cairoplot'
=== renamed file 'trunk/cairoplot.py' => 'trunk/cairoplot/__init__.py'
--- trunk/cairoplot.py	2009-07-09 21:57:24 +0000
+++ trunk/cairoplot/__init__.py	2010-04-07 05:06:25 +0000
@@ -36,6 +36,8 @@
 import random
 from series import Series, Group, Data
 
+import cairoplot.handlers
+
 HORZ = 0
 VERT = 1
 NORM = 2
@@ -56,7 +58,7 @@
 def colors_from_theme( theme, series_length, mode = 'solid' ):
     colors = []
     if theme not in THEMES.keys() :
-        raise Exception, "Theme not defined" 
+        raise Exception, "Theme not defined"
     color_steps = THEMES[theme]
     n_colors = len(color_steps)
     if series_length <= n_colors:
@@ -79,14 +81,14 @@
                           (next_color[2] - color[2])/(iterations[index] + 1),
                           (next_color[3] - color[3])/(iterations[index] + 1))
             for i in range( iterations[index] ):
-                colors.append((color[0] + color_step[0]*(i+1), 
-                               color[1] + color_step[1]*(i+1), 
+                colors.append((color[0] + color_step[0]*(i+1),
+                               color[1] + color_step[1]*(i+1),
                                color[2] + color_step[2]*(i+1),
                                color[3] + color_step[3]*(i+1),
                                mode))
         colors.append(color_steps[-1] + tuple([mode]))
     return colors
-        
+
 
 def other_direction(direction):
     "explicit is better than implicit"
@@ -98,7 +100,7 @@
 #Class definition
 
 class Plot(object):
-    def __init__(self, 
+    def __init__(self,
                  surface=None,
                  data=None,
                  width=640,
@@ -113,7 +115,7 @@
         self.dimensions = {}
         self.dimensions[HORZ] = width
         self.dimensions[VERT] = height
-        self.context = cairo.Context(self.surface)
+        self.context = None
         self.labels={}
         self.labels[HORZ] = x_labels
         self.labels[VERT] = y_labels
@@ -126,50 +128,52 @@
         self.line_width = 0.5
         self.label_color = (0.0, 0.0, 0.0)
         self.grid_color = (0.8, 0.8, 0.8)
-    
+
     def create_surface(self, surface, width=None, height=None):
         self.filename = None
         if isinstance(surface, cairo.Surface):
-            self.surface = surface
-            return
-        if not type(surface) in (str, unicode): 
+            self.handler = cairoplot.handlers.VectorHandler(surface, width,
+                    height)
+            return
+        if isinstance(surface, cairoplot.handlers.Handler):
+            self.handler = surface
+            return
+        if not type(surface) in (str, unicode):
             raise TypeError("Surface should be either a Cairo surface or a filename, not %s" % surface)
+
+        # choose handler based on file extension (svg is default)
         sufix = surface.rsplit(".")[-1].lower()
-        self.filename = surface
+        filename = surface
+        handlerclass = cairoplot.handlers.SVGHandler
         if sufix == "png":
-            self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+            handlerclass = cairoplot.handlers.PNGHandler
         elif sufix == "ps":
-            self.surface = cairo.PSSurface(surface, width, height)
+            handlerclass = cairoplot.handlers.PSHandler
         elif sufix == "pdf":
-            self.surface = cairo.PSSurface(surface, width, height)
-        else:
-            if sufix != "svg":
-                self.filename += ".svg"
-            self.surface = cairo.SVGSurface(self.filename, width, height)
+            handlerclass = cairoplot.handlers.PDFHandler
+        elif sufix != "svg":
+            filename += ".svg"
+        self.handler = handlerclass(filename, width, height)
 
     def commit(self):
         try:
-            self.context.show_page()
-            if self.filename and self.filename.endswith(".png"):
-                self.surface.write_to_png(self.filename)
-            else:
-                self.surface.finish()
+            self.handler.commit(self)
         except cairo.Error:
             pass
-        
+
     def load_series (self, data, x_labels=None, y_labels=None, series_colors=None):
         self.series_labels = []
         self.series = None
-        
+
         #The pretty way
         #if not isinstance(data, Series):
         #    # Not an instance of Series
         #    self.series = Series(data)
         #else:
         #    self.series = data
-        #    
+        #
         #self.series_labels = self.series.get_names()
-        
+
         #TODO: Remove on next version
         # The ugly way, keeping retrocompatibility...
         if callable(data) or type(data) is list and callable(data[0]): # Lambda or List of lambdas
@@ -181,18 +185,18 @@
         else: # Anything else
             self.series = Series(data)
             self.series_labels = self.series.get_names()
-            
+
         #TODO: allow user passed series_widths
         self.series_widths = [1.0 for group in self.series]
 
         #TODO: Remove on next version
         self.process_colors( series_colors )
-        
+
     def process_colors( self, series_colors, length = None, mode = 'solid' ):
         #series_colors might be None, a theme, a string of colors names or a list of color tuples
         if length is None :
             length = len( self.series.to_list() )
-            
+
         #no colors passed
         if not series_colors:
             #Randomize colors
@@ -202,13 +206,13 @@
             if not hasattr( series_colors, "__iter__" ):
                 theme = series_colors
                 self.series_colors = colors_from_theme( theme.lower(), length )
-                
+
             #Theme pattern and mode
             elif not hasattr(series_colors, '__delitem__') and not hasattr( series_colors[0], "__iter__" ):
                 theme = series_colors[0]
                 mode = series_colors[1]
                 self.series_colors = colors_from_theme( theme.lower(), length, mode )
-                    
+
             #List
             else:
                 self.series_colors = series_colors
@@ -229,12 +233,6 @@
                         else:
                             self.series_colors[index] += tuple([mode])
 
-    def get_width(self):
-        return self.surface.get_width()
-    
-    def get_height(self):
-        return self.surface.get_height()
-
     def set_background(self, background):
         if background is None:
             self.background = (0.0,0.0,0.0,0.0)
@@ -250,7 +248,7 @@
                     self.background.add_color_stop_rgba(float(index)/(len(colors)-1),*COLORS[color])
         else:
             raise TypeError ("Background should be either cairo.LinearGradient or a 3/4-tuple, not %s" % type(background))
-        
+
     def render_background(self):
         if isinstance(self.background, cairo.LinearGradient):
             self.context.set_source(self.background)
@@ -258,7 +256,7 @@
             self.context.set_source_rgba(*self.background)
         self.context.rectangle(0,0, self.dimensions[HORZ], self.dimensions[VERT])
         self.context.fill()
-        
+
     def render_bounding_box(self):
         self.context.set_source_rgba(*self.line_color)
         self.context.set_line_width(self.line_width)
@@ -268,10 +266,13 @@
         self.context.stroke()
 
     def render(self):
-        pass
+        """All plots must prepare their context before rendering."""
+        self.handler.prepare(self)
+
+
 
 class ScatterPlot( Plot ):
-    def __init__(self, 
+    def __init__(self,
                  surface=None,
                  data=None,
                  errorx=None,
@@ -279,7 +280,7 @@
                  width=640,
                  height=480,
                  background=None,
-                 border=0, 
+                 border=0,
                  axis = False,
                  dash = False,
                  discrete = False,
@@ -295,7 +296,7 @@
                  y_title  = None,
                  series_colors = None,
                  circle_colors = None ):
-        
+
         self.bounds = {}
         self.bounds[HORZ] = x_bounds
         self.bounds[VERT] = y_bounds
@@ -312,9 +313,9 @@
         self.variable_radius = False
         self.x_label_angle = math.pi / 2.5
         self.circle_colors = circle_colors
-        
+
         Plot.__init__(self, surface, data, width, height, background, border, x_labels, y_labels, series_colors)
-        
+
         self.dash = None
         if dash:
             if hasattr(dash, "keys"):
@@ -323,9 +324,9 @@
                 self.dash = dash
             else:
                 self.dash = [dash]
-                
+
         self.load_errors(errorx, errory)
-    
+
     def convert_list_to_tuple(self, data):
         #Data must be converted from lists of coordinates to a single
         # list of tuples
@@ -333,22 +334,22 @@
         if len(data) == 3:
             self.variable_radius = True
         return out_data
-    
+
     def load_series(self, data, x_labels = None, y_labels = None, series_colors=None):
         #TODO: In cairoplot 2.0 keep only the Series instances
 
         # Convert Data and Group to Series
         if isinstance(data, Data) or isinstance(data, Group):
             data = Series(data)
-            
+
         # Series
         if  isinstance(data, Series):
             for group in data:
                 for item in group:
                     if len(item) is 3:
                         self.variable_radius = True
-            
-        #Dictionary with lists  
+
+        #Dictionary with lists
         if hasattr(data, "keys") :
             if hasattr( data.values()[0][0], "__delitem__" ) :
                 for key in data.keys() :
@@ -357,7 +358,7 @@
                     self.variable_radius = True
         #List
         elif hasattr(data[0], "__delitem__") :
-            #List of lists 
+            #List of lists
             if hasattr(data[0][0], "__delitem__") :
                 for index,value in enumerate(data) :
                     data[index] = self.convert_list_to_tuple(value)
@@ -374,7 +375,7 @@
         Plot.load_series(self, data, x_labels, y_labels, series_colors)
         self.calc_boundaries()
         self.calc_labels()
-    
+
     def load_errors(self, errorx, errory):
         self.errors = None
         if errorx == None and errory == None:
@@ -394,7 +395,7 @@
         #simetric errors
         elif errory:
             self.errors[VERT] = [errory]
-    
+
     def calc_labels(self):
         if not self.labels[HORZ]:
             amplitude = self.bounds[HORZ][1] - self.bounds[HORZ][0]
@@ -418,18 +419,18 @@
         #HORZ = 0, VERT = 1, NORM = 2
         min_data_value = [0,0,0]
         max_data_value = [0,0,0]
-        
+
         for group in self.series:
             if type(group[0].content) in (int, float, long):
                 group = [Data((index, item.content)) for index,item in enumerate(group)]
-            
+
             for point in group:
                 for index, item in enumerate(point.content):
                     if item > max_data_value[index]:
                         max_data_value[index] = item
                     elif item < min_data_value[index]:
                         min_data_value[index] = item
-        
+
         if not self.bounds[HORZ]:
             self.bounds[HORZ] = (min_data_value[HORZ], max_data_value[HORZ])
         if not self.bounds[VERT]:
@@ -443,9 +444,9 @@
 
         self.plot_height = self.dimensions[VERT] - 2 * self.borders[VERT]
         self.plot_width = self.dimensions[HORZ] - 2* self.borders[HORZ]
-        
+
         self.plot_top = self.dimensions[VERT] - self.borders[VERT]
-                
+
     def calc_steps(self):
         #Calculates all the x, y, z and color steps
         series_amplitude = [self.bounds[index][1] - self.bounds[index][0] for index in range(3)]
@@ -454,7 +455,7 @@
             self.horizontal_step = float (self.plot_width) / series_amplitude[HORZ]
         else:
             self.horizontal_step = 0.00
-            
+
         if series_amplitude[VERT]:
             self.vertical_step = float (self.plot_height) / series_amplitude[VERT]
         else:
@@ -468,11 +469,13 @@
         else:
             self.z_step = 0.00
             self.circle_color_step = ( 0.0, 0.0, 0.0, 0.0 )
-    
+
     def get_circle_color(self, value):
         return tuple( [self.circle_colors[0][i] + value*self.circle_color_step[i] for i in range(4)] )
-    
+
     def render(self):
+        Plot.render(self)
+
         self.calc_all_extents()
         self.calc_steps()
         self.render_background()
@@ -487,7 +490,7 @@
             self.render_errors()
         if self.series_legend and self.series_labels:
             self.render_legend()
-            
+
     def render_axis(self):
         #Draws both the axis lines and their titles
         cr = self.context
@@ -513,15 +516,15 @@
             cr.rotate( math.pi/2 )
             cr.show_text( self.titles[VERT] )
             cr.rotate( -math.pi/2 )
-        
+
     def render_grid(self):
         cr = self.context
         horizontal_step = float( self.plot_height ) / ( len( self.labels[VERT] ) - 1 )
         vertical_step = float( self.plot_width ) / ( len( self.labels[HORZ] ) - 1 )
-        
+
         x = self.borders[HORZ] + vertical_step
         y = self.plot_top - horizontal_step
-        
+
         for label in self.labels[HORZ][:-1]:
             cr.set_source_rgba(*self.grid_color)
             cr.move_to(x, self.dimensions[VERT] - self.borders[VERT])
@@ -534,12 +537,12 @@
             cr.line_to(self.dimensions[HORZ] - self.borders[HORZ], y)
             cr.stroke()
             y -= horizontal_step
-    
+
     def render_labels(self):
         self.context.set_font_size(self.font_size * 0.8)
         self.render_horz_labels()
         self.render_vert_labels()
-    
+
     def render_horz_labels(self):
         cr = self.context
         step = float( self.plot_width ) / ( len( self.labels[HORZ] ) - 1 )
@@ -552,7 +555,7 @@
             cr.show_text(item)
             cr.rotate(-self.x_label_angle)
             x += step
-    
+
     def render_vert_labels(self):
         cr = self.context
         step = ( self.plot_height ) / ( len( self.labels[VERT] ) - 1 )
@@ -573,10 +576,10 @@
         tallest_word = max(self.series_labels, key = lambda item: self.context.text_extents(item)[3])
         max_width = self.context.text_extents(widest_word)[2]
         max_height = self.context.text_extents(tallest_word)[3] * 1.1
-        
+
         color_box_height = max_height / 2
         color_box_width = color_box_height * 2
-        
+
         #Draw a bounding box
         bounding_box_width = max_width + color_box_width + 15
         bounding_box_height = (len(self.series_labels)+0.5) * max_height
@@ -584,7 +587,7 @@
         cr.rectangle(self.dimensions[HORZ] - self.borders[HORZ] - bounding_box_width, self.borders[VERT],
                             bounding_box_width, bounding_box_height)
         cr.fill()
-        
+
         cr.set_source_rgba(*self.line_color)
         cr.set_line_width(self.line_width)
         cr.rectangle(self.dimensions[HORZ] - self.borders[HORZ] - bounding_box_width, self.borders[VERT],
@@ -594,17 +597,17 @@
         for idx,key in enumerate(self.series_labels):
             #Draw color box
             cr.set_source_rgba(*self.series_colors[idx][:4])
-            cr.rectangle(self.dimensions[HORZ] - self.borders[HORZ] - max_width - color_box_width - 10, 
+            cr.rectangle(self.dimensions[HORZ] - self.borders[HORZ] - max_width - color_box_width - 10,
                                 self.borders[VERT] + color_box_height + (idx*max_height) ,
                                 color_box_width, color_box_height)
             cr.fill()
-            
+
             cr.set_source_rgba(0, 0, 0)
-            cr.rectangle(self.dimensions[HORZ] - self.borders[HORZ] - max_width - color_box_width - 10, 
+            cr.rectangle(self.dimensions[HORZ] - self.borders[HORZ] - max_width - color_box_width - 10,
                                 self.borders[VERT] + color_box_height + (idx*max_height),
                                 color_box_width, color_box_height)
             cr.stroke()
-            
+
             #Draw series labels
             cr.set_source_rgba(0, 0, 0)
             cr.move_to(self.dimensions[HORZ] - self.borders[HORZ] - max_width - 5, self.borders[VERT] + ((idx+1)*max_height))
@@ -650,9 +653,11 @@
                     cr.line_to(x - radius, y1)
                     cr.line_to(x + radius, y1)
                     cr.stroke()
-                
-                
+
+
     def render_plot(self):
+        """Draws the actual plot lines."""
+
         cr = self.context
         if self.discrete:
             cr.rectangle(self.borders[HORZ], self.borders[VERT], self.plot_width, self.plot_height)
@@ -664,54 +669,63 @@
                 cr.set_source_rgba(*self.series_colors[number][:4])
                 for data in group :
                     if self.variable_radius:
-                        radius = data.content[2]*self.z_step
+                        radius = data.content[2] * self.z_step
                         if self.circle_colors:
-                            cr.set_source_rgba( *self.get_circle_color( data.content[2]) )
-                    x = x0 + self.horizontal_step*data.content[0]
-                    y = y0 + self.vertical_step*data.content[1]
+                            cr.set_source_rgba( *self.get_circle_color( data.content[2]))
+                    x = x0 + self.horizontal_step * data.content[0]
+                    y = y0 + self.vertical_step * data.content[1]
                     cr.arc(x, self.dimensions[VERT] - y, radius, 0, 2*math.pi)
                     cr.fill()
         else:
             cr.rectangle(self.borders[HORZ], self.borders[VERT], self.plot_width, self.plot_height)
             cr.clip()
-            x0 = self.borders[HORZ] - self.bounds[HORZ][0]*self.horizontal_step
-            y0 = self.borders[VERT] - self.bounds[VERT][0]*self.vertical_step
+            x0 = self.borders[HORZ] - self.bounds[HORZ][0] * self.horizontal_step
+            y0 = self.borders[VERT] - self.bounds[VERT][0] * self.vertical_step
+
             radius = self.dots
             for number, group in  enumerate (self.series):
                 last_data = None
                 cr.set_source_rgba(*self.series_colors[number][:4])
                 for data in group :
-                    x = x0 + self.horizontal_step*data.content[0]
-                    y = y0 + self.vertical_step*data.content[1]
+                    x = x0 + self.horizontal_step * data.content[0]
+                    y = y0 + self.vertical_step * data.content[1]
+
+                    # only draw a line for valid points
+                    if y != y: # math.isnan only in 2.6+
+                        last_data = None
+                        continue
+
                     if self.dots:
                         if self.variable_radius:
                             radius = data.content[2]*self.z_step
                         cr.arc(x, self.dimensions[VERT] - y, radius, 0, 2*math.pi)
                         cr.fill()
-                    if last_data :
-                        old_x = x0 + self.horizontal_step*last_data.content[0]
-                        old_y = y0 + self.vertical_step*last_data.content[1]
+                    if last_data:
+                        old_x = x0 + self.horizontal_step * last_data.content[0]
+                        old_y = y0 + self.vertical_step * last_data.content[1]
                         cr.move_to( old_x, self.dimensions[VERT] - old_y )
                         cr.line_to( x, self.dimensions[VERT] - y)
                         cr.set_line_width(self.series_widths[number])
 
-                        # Display line as dash line 
+                        # Display line as dash line
                         if self.dash and self.dash[number]:
                             s = self.series_widths[number]
                             cr.set_dash([s*3, s*3], 0)
-    
+
                         cr.stroke()
                         cr.set_dash([])
                     last_data = data
 
+
+
 class DotLinePlot(ScatterPlot):
-    def __init__(self, 
+    def __init__(self,
                  surface=None,
                  data=None,
                  width=640,
                  height=480,
                  background=None,
-                 border=0, 
+                 border=0,
                  axis = False,
                  dash = False,
                  dots = 0,
@@ -724,8 +738,8 @@
                  x_title  = None,
                  y_title  = None,
                  series_colors = None):
-        
-        ScatterPlot.__init__(self, surface, data, None, None, width, height, background, border, 
+
+        ScatterPlot.__init__(self, surface, data, None, None, width, height, background, border,
                              axis, dash, False, dots, grid, series_legend, x_labels, y_labels,
                              x_bounds, y_bounds, None, x_title, y_title, series_colors, None )
 
@@ -740,13 +754,13 @@
         self.calc_labels()
 
 class FunctionPlot(ScatterPlot):
-    def __init__(self, 
+    def __init__(self,
                  surface=None,
                  data=None,
                  width=640,
                  height=480,
                  background=None,
-                 border=0, 
+                 border=0,
                  axis = False,
                  discrete = False,
                  dots = 0,
@@ -758,96 +772,126 @@
                  y_bounds = None,
                  x_title  = None,
                  y_title  = None,
-                 series_colors = None, 
+                 series_colors = None,
                  step = 1):
 
         self.function = data
+
+        # step should not be zero
         self.step = step
+        if self.step <= 0:
+            self.step = 1
+
         self.discrete = discrete
-        
+
         data, x_bounds = self.load_series_from_function( self.function, x_bounds )
 
-        ScatterPlot.__init__(self, surface, data, None, None, width, height, background, border, 
+        ScatterPlot.__init__(self, surface, data, None, None, width, height, background, border,
                              axis, False, discrete, dots, grid, series_legend, x_labels, y_labels,
                              x_bounds, y_bounds, None, x_title, y_title, series_colors, None )
-    
+
     def load_series(self, data, x_labels = None, y_labels = None, series_colors=None):
         Plot.load_series(self, data, x_labels, y_labels, series_colors)
-        
-        if len(self.series[0][0]) is 1:          
+
+        if len(self.series[0][0]) is 1:
             for group_id, group in enumerate(self.series) :
                 for index,data in enumerate(group):
                     group[index].content = (self.bounds[HORZ][0] + self.step*index, data.content)
-                
+
         self.calc_boundaries()
         self.calc_labels()
-    
-    def load_series_from_function( self, function, x_bounds ):
-        #TODO: Add the possibility for the user to define multiple functions with different discretization parameters
-        
-        #This function converts a function, a list of functions or a dictionary
-        #of functions into its corresponding array of data
+
+    def load_series_from_function(self, function, x_bounds):
+        """Converts a function (or functions) into array of data.
+
+        Multiple functions can be defined by a list of functions or
+        a dictionary of functions into its corresponding array of data.
+        """
+        # TODO: Add the possibility for the user to define multiple functions with different discretization parameters
+
         series = Series()
-        
+
         if isinstance(function, Group) or isinstance(function, Data):
             function = Series(function)
-        
-        # If is instance of Series
+
+        # is already a Series
+        # overwrite any bounds passed by the function
         if isinstance(function, Series):
-            # Overwrite any bounds passed by the function
             x_bounds = (function.range[0],function.range[-1])
-        
-        #if no bounds are provided
+
+        # no bounds are provided
         if x_bounds == None:
             x_bounds = (0,10)
-            
-                
-        #TODO: Finish the dict translation
+
+        # convert a single function into a "group"
+        def convert_function(singlefunction, group):
+            """Converts function into usable data.
+
+            Math bounds errors correspond to nan values."""
+
+            def trygetpoint(inx):
+                """Attempt to evaluate point, returns nan on errors"""
+                try:
+                    return singlefunction(inx)
+                except (ValueError, ZeroDivisionError, OverflowError):
+                    return float("nan")
+
+            i = x_bounds[0]
+            while i <= x_bounds[1]:
+                group.add_data(trygetpoint(i))
+                i += self.step
+
+        # TODO: Finish the dict translation
         if hasattr(function, "keys"): #dictionary:
             for key in function.keys():
                 group = Group(name=key)
-                #data[ key ] = []
-                i = x_bounds[0]
-                while i <= x_bounds[1] :
-                    group.add_data(function[ key ](i))
-                    #data[ key ].append( function[ key ](i) )
-                    i += self.step
+                convert_function(function[key], group)
                 series.add_group(group)
-                    
+
         elif hasattr(function, "__delitem__"): #list of functions
-            for index,f in enumerate( function ) :
+            for f in function:
                 group = Group()
-                #data.append( [] )
-                i = x_bounds[0]
-                while i <= x_bounds[1] :
-                    group.add_data(f(i))
-                    #data[ index ].append( f(i) )
-                    i += self.step
+                convert_function(f, group)
                 series.add_group(group)
-                
+
         elif isinstance(function, Series): # instance of Series
             series = function
-            
-        else: #function
+
+        else: # function
             group = Group()
-            i = x_bounds[0]
-            while i <= x_bounds[1] :
-                group.add_data(function(i))
-                i += self.step
+            convert_function(function, group)
             series.add_group(group)
-            
-            
+
         return series, x_bounds
 
+
     def calc_labels(self):
+        """Create labels from bounds"""
+
+        boundrange = float(self.bounds[HORZ][1] - self.bounds[HORZ][0])
+
+        # based on range, change number of decimals displayed
+        digits = 0
+        if 0 < boundrange < 10:
+            digits = -math.floor(math.log10(boundrange))
+            digits += 1
+        labelformat = "%%.%df" % digits
+
+        # make 10 labels (must be > 0)
+        boundstep = boundrange / 10
+        if boundstep <= 0:
+            boundstep = 1
+
+        # create string for each label
         if not self.labels[HORZ]:
             self.labels[HORZ] = []
             i = self.bounds[HORZ][0]
             while i<=self.bounds[HORZ][1]:
-                self.labels[HORZ].append(str(i))
-                i += float(self.bounds[HORZ][1] - self.bounds[HORZ][0])/10
+                self.labels[HORZ].append(labelformat % i)
+                i += boundstep
         ScatterPlot.calc_labels(self)
 
+
     def render_plot(self):
         if not self.discrete:
             ScatterPlot.render_plot(self)
@@ -861,6 +905,7 @@
                 for data in group:
                     x = x0 + self.horizontal_step * data.content[0]
                     y = y0 + self.vertical_step   * data.content[1]
+
                     cr.move_to(x, self.dimensions[VERT] - y)
                     cr.line_to(x, self.plot_top)
                     cr.set_line_width(self.series_widths[number])
@@ -872,7 +917,7 @@
                         cr.fill()
 
 class BarPlot(Plot):
-    def __init__(self, 
+    def __init__(self,
                  surface = None,
                  data = None,
                  width = 640,
@@ -890,7 +935,7 @@
                  y_bounds = None,
                  series_colors = None,
                  main_dir = None):
-        
+
         self.bounds = {}
         self.bounds[HORZ] = x_bounds
         self.bounds[VERT] = y_bounds
@@ -911,22 +956,22 @@
     def load_series(self, data, x_labels = None, y_labels = None, series_colors = None):
         Plot.load_series(self, data, x_labels, y_labels, series_colors)
         self.calc_boundaries()
-        
+
     def process_colors(self, series_colors):
         #Data for a BarPlot might be a List or a List of Lists.
         #On the first case, colors must be generated for all bars,
         #On the second, colors must be generated for each of the inner lists.
-        
+
         #TODO: Didn't get it...
         #if hasattr(self.data[0], '__getitem__'):
         #    length = max(len(series) for series in self.data)
         #else:
         #    length = len( self.data )
-        
+
         length = max(len(group) for group in self.series)
-        
+
         Plot.process_colors( self, series_colors, length, 'linear')
-    
+
     def calc_boundaries(self):
         if not self.bounds[self.main_dir]:
             if self.stack:
@@ -936,7 +981,7 @@
             self.bounds[self.main_dir] = (0, max_data_value)
         if not self.bounds[other_direction(self.main_dir)]:
             self.bounds[other_direction(self.main_dir)] = (0, len(self.series))
-    
+
     def calc_extents(self, direction):
         self.max_value[direction] = 0
         if self.labels[direction]:
@@ -979,8 +1024,10 @@
         series_length = len(self.series)
         self.steps[other_dir] = float(self.plot_dimensions[other_dir])/(series_length + 0.1*(series_length + 1))
         self.space = 0.1*self.steps[other_dir]
-        
+
     def render(self):
+        Plot.render(self)
+
         self.calc_all_extents()
         self.calc_steps()
         self.render_background()
@@ -995,7 +1042,7 @@
         self.render_plot()
         if self.series_labels:
             self.render_legend()
-    
+
     def draw_3d_rectangle_front(self, x0, y0, x1, y1, shift):
         self.context.rectangle(x0-shift, y0+shift, x1-x0, y1-y0)
 
@@ -1014,7 +1061,7 @@
         self.context.line_to(x1-shift, y0+shift)
         self.context.line_to(x0-shift, y0+shift)
         self.context.close_path()
-                
+
     def draw_round_rectangle(self, x0, y0, x1, y1):
         self.context.arc(x0+5, y0+5, 5, -math.pi, -math.pi/2)
         self.context.line_to(x1-5, y0)
@@ -1027,15 +1074,15 @@
         self.context.close_path()
 
     def render_ground(self):
-        self.draw_3d_rectangle_front(self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT], 
-                                     self.dimensions[HORZ] - self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT] + 5, 10)
-        self.context.fill()
-
-        self.draw_3d_rectangle_side (self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT], 
-                                     self.dimensions[HORZ] - self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT] + 5, 10)
-        self.context.fill()
-
-        self.draw_3d_rectangle_top  (self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT], 
+        self.draw_3d_rectangle_front(self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT],
+                                     self.dimensions[HORZ] - self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT] + 5, 10)
+        self.context.fill()
+
+        self.draw_3d_rectangle_side (self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT],
+                                     self.dimensions[HORZ] - self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT] + 5, 10)
+        self.context.fill()
+
+        self.draw_3d_rectangle_top  (self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT],
                                      self.dimensions[HORZ] - self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT] + 5, 10)
         self.context.fill()
 
@@ -1045,7 +1092,7 @@
             self.render_horz_labels()
         if self.labels[VERT]:
             self.render_vert_labels()
-            
+
     def render_legend(self):
         cr = self.context
         cr.set_font_size(self.font_size)
@@ -1055,10 +1102,10 @@
         tallest_word = max(self.series_labels, key = lambda item: self.context.text_extents(item)[3])
         max_width = self.context.text_extents(widest_word)[2]
         max_height = self.context.text_extents(tallest_word)[3] * 1.1 + 5
-        
+
         color_box_height = max_height / 2
         color_box_width = color_box_height * 2
-        
+
         #Draw a bounding box
         bounding_box_width = max_width + color_box_width + 15
         bounding_box_height = (len(self.series_labels)+0.5) * max_height
@@ -1066,7 +1113,7 @@
         cr.rectangle(self.dimensions[HORZ] - self.border - bounding_box_width, self.border,
                             bounding_box_width, bounding_box_height)
         cr.fill()
-        
+
         cr.set_source_rgba(*self.line_color)
         cr.set_line_width(self.line_width)
         cr.rectangle(self.dimensions[HORZ] - self.border - bounding_box_width, self.border,
@@ -1076,17 +1123,17 @@
         for idx,key in enumerate(self.series_labels):
             #Draw color box
             cr.set_source_rgba(*self.series_colors[idx][:4])
-            cr.rectangle(self.dimensions[HORZ] - self.border - max_width - color_box_width - 10, 
+            cr.rectangle(self.dimensions[HORZ] - self.border - max_width - color_box_width - 10,
                                 self.border + color_box_height + (idx*max_height) ,
                                 color_box_width, color_box_height)
             cr.fill()
-            
+
             cr.set_source_rgba(0, 0, 0)
-            cr.rectangle(self.dimensions[HORZ] - self.border - max_width - color_box_width - 10, 
+            cr.rectangle(self.dimensions[HORZ] - self.border - max_width - color_box_width - 10,
                                 self.border + color_box_height + (idx*max_height),
                                 color_box_width, color_box_height)
             cr.stroke()
-            
+
             #Draw series labels
             cr.set_source_rgba(0, 0, 0)
             cr.move_to(self.dimensions[HORZ] - self.border - max_width - 5, self.border + ((idx+1)*max_height))
@@ -1094,7 +1141,7 @@
 
 
 class HorizontalBarPlot(BarPlot):
-    def __init__(self, 
+    def __init__(self,
                  surface = None,
                  data = None,
                  width = 640,
@@ -1113,7 +1160,7 @@
                  y_bounds = None,
                  series_colors = None):
 
-        BarPlot.__init__(self, surface, data, width, height, background, border, 
+        BarPlot.__init__(self, surface, data, width, height, background, border,
                          display_values, grid, rounded_corners, stack, three_dimension,
                          x_labels, y_labels, x_bounds, y_bounds, series_colors, HORZ)
         self.series_labels = series_labels
@@ -1131,7 +1178,7 @@
         self.context.line_to(x1, y1)
         self.context.line_to(x0+5, y1)
         self.context.close_path()
-    
+
     def draw_rectangle_top(self, x0, y0, x1, y1):
         self.context.arc(x1-5, y0+5, 5, -math.pi/2, 0)
         self.context.line_to(x1, y1-5)
@@ -1140,7 +1187,7 @@
         self.context.line_to(x0, y0)
         self.context.line_to(x1, y0)
         self.context.close_path()
-        
+
     def draw_rectangle(self, index, length, x0, y0, x1, y1):
         if length == 1:
             BarPlot.draw_rectangle(self, x0, y0, x1, y1)
@@ -1264,9 +1311,9 @@
                         self.context.rectangle(x0, y0, data.content*self.steps[HORZ], inner_step)
                         self.context.fill()
                     y0 += inner_step
-    
+
 class VerticalBarPlot(BarPlot):
-    def __init__(self, 
+    def __init__(self,
                  surface = None,
                  data = None,
                  width = 640,
@@ -1285,7 +1332,7 @@
                  y_bounds = None,
                  series_colors = None):
 
-        BarPlot.__init__(self, surface, data, width, height, background, border, 
+        BarPlot.__init__(self, surface, data, width, height, background, border,
                          display_values, grid, rounded_corners, stack, three_dimension,
                          x_labels, y_labels, x_bounds, y_bounds, series_colors, VERT)
         self.series_labels = series_labels
@@ -1304,7 +1351,7 @@
         self.context.line_to(x1, y0)
         self.context.line_to(x1, y1)
         self.context.close_path()
-        
+
     def draw_rectangle_top(self, x0, y0, x1, y1):
         self.context.arc(x0+5, y0+5, 5, -math.pi, -math.pi/2)
         self.context.line_to(x1-5, y0)
@@ -1313,7 +1360,7 @@
         self.context.line_to(x0, y1)
         self.context.line_to(x0, y0)
         self.context.close_path()
-        
+
     def draw_rectangle(self, index, length, x0, y0, x1, y1):
         if length == 1:
             BarPlot.draw_rectangle(self, x0, y0, x1, y1)
@@ -1339,17 +1386,17 @@
             self.context.line_to(self.dimensions[HORZ] - self.border, y)
             self.context.stroke()
             y += vertical_step
-            
+
     def render_ground(self):
-        self.draw_3d_rectangle_front(self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT], 
-                                     self.dimensions[HORZ] - self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT] + 5, 10)
-        self.context.fill()
-
-        self.draw_3d_rectangle_side (self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT], 
-                                     self.dimensions[HORZ] - self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT] + 5, 10)
-        self.context.fill()
-
-        self.draw_3d_rectangle_top  (self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT], 
+        self.draw_3d_rectangle_front(self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT],
+                                     self.dimensions[HORZ] - self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT] + 5, 10)
+        self.context.fill()
+
+        self.draw_3d_rectangle_side (self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT],
+                                     self.dimensions[HORZ] - self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT] + 5, 10)
+        self.context.fill()
+
+        self.draw_3d_rectangle_top  (self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT],
                                      self.dimensions[HORZ] - self.borders[HORZ], self.dimensions[VERT] - self.borders[VERT] + 5, 10)
         self.context.fill()
 
@@ -1367,7 +1414,7 @@
                 self.context.show_text(item)
                 next_x = x + width/2
             x += step + self.space
-            
+
     def render_vert_labels(self):
         self.context.set_source_rgba(*self.label_color)
         y = self.borders[VERT] + self.value_label
@@ -1449,11 +1496,11 @@
                     else:
                         self.context.rectangle(x0, self.plot_top - data.content*self.steps[VERT], inner_step, data.content*self.steps[VERT])
                         self.context.fill()
-                    
+
                     x0 += inner_step
-    
+
 class StreamChart(VerticalBarPlot):
-    def __init__(self, 
+    def __init__(self,
                  surface = None,
                  data = None,
                  width = 640,
@@ -1467,12 +1514,12 @@
                  y_bounds = None,
                  series_colors = None):
 
-        VerticalBarPlot.__init__(self, surface, data, width, height, background, border, 
+        VerticalBarPlot.__init__(self, surface, data, width, height, background, border,
                                  False, grid, False, True, False,
                                  None, x_labels, None, x_bounds, y_bounds, series_colors)
-    
+
     def calc_steps(self):
-        other_dir = other_direction(self.main_dir)    
+        other_dir = other_direction(self.main_dir)
         self.series_amplitude = self.bounds[self.main_dir][1] - self.bounds[self.main_dir][0]
         if self.series_amplitude:
             self.steps[self.main_dir] = float(self.plot_dimensions[self.main_dir])/self.series_amplitude
@@ -1480,14 +1527,14 @@
             self.steps[self.main_dir] = 0.00
         series_length = len(self.data)
         self.steps[other_dir] = float(self.plot_dimensions[other_dir])/series_length
-    
+
     def render_legend(self):
         pass
-    
+
     def ground(self, index):
         sum_values = sum(self.data[index])
         return -0.5*sum_values
-    
+
     def calc_angles(self):
         middle = self.plot_top - self.plot_dimensions[VERT]/2.0
         self.angles = [tuple([0.0 for x in range(len(self.data)+1)])]
@@ -1503,11 +1550,11 @@
                 x2 = self.borders[HORZ] + (0.5 + x_index + 1)*self.steps[HORZ]
                 y0 = middle - self.ground(x_index-1)*self.steps[VERT] - self.data[x_index-1][data_index]*self.steps[VERT]
                 y2 = middle - self.ground(x_index+1)*self.steps[VERT] - self.data[x_index+1][data_index]*self.steps[VERT]
-                
+
                 for i in range(0,data_index):
                     y0 -= self.data[x_index-1][i]*self.steps[VERT]
                     y2 -= self.data[x_index+1][i]*self.steps[VERT]
-                
+
                 if data_index == len(self.data[0])-1 and False:
                     self.context.set_source_rgba(0.0,0.0,0.0,0.3)
                     self.context.move_to(x0,y0)
@@ -1518,28 +1565,28 @@
                 t.append(math.atan(float(y0-y2)/(x0-x2)))
             self.angles.append(tuple(t))
         self.angles.append(tuple([0.0 for x in range(len(self.data)+1)]))
-    
+
     def render_plot(self):
         self.calc_angles()
         middle = self.plot_top - self.plot_dimensions[VERT]/2.0
         p = 0.4*self.steps[HORZ]
         for data_index in range(len(self.data[0])-1,-1,-1):
             self.context.set_source_rgba(*self.series_colors[data_index][:4])
-            
+
             #draw the upper line
             for x_index in range(len(self.data)-1) :
                 x1 = self.borders[HORZ] + (0.5 + x_index)*self.steps[HORZ]
                 y1 = middle - self.ground(x_index)*self.steps[VERT] - self.data[x_index][data_index]*self.steps[VERT]
                 x2 = self.borders[HORZ] + (0.5 + x_index + 1)*self.steps[HORZ]
                 y2 = middle - self.ground(x_index + 1)*self.steps[VERT] - self.data[x_index + 1][data_index]*self.steps[VERT]
-                
+
                 for i in range(0,data_index):
                     y1 -= self.data[x_index][i]*self.steps[VERT]
                     y2 -= self.data[x_index+1][i]*self.steps[VERT]
-                
+
                 if x_index == 0:
                     self.context.move_to(x1,y1)
-                
+
                 ang1 = self.angles[x_index][data_index+1]
                 ang2 = self.angles[x_index+1][data_index+1] + math.pi
                 self.context.curve_to(x1+p*math.cos(ang1),y1+p*math.sin(ang1),
@@ -1551,14 +1598,14 @@
                 y1 = middle - self.ground(x_index)*self.steps[VERT]
                 x2 = self.borders[HORZ] + (0.5 + x_index - 1)*self.steps[HORZ]
                 y2 = middle - self.ground(x_index - 1)*self.steps[VERT]
-                
+
                 for i in range(0,data_index):
                     y1 -= self.data[x_index][i]*self.steps[VERT]
                     y2 -= self.data[x_index-1][i]*self.steps[VERT]
-                
+
                 if x_index == len(self.data)-1:
                     self.context.line_to(x1,y1+2)
-                
+
                 #revert angles by pi degrees to take the turn back
                 ang1 = self.angles[x_index][data_index] + math.pi
                 ang2 = self.angles[x_index-1][data_index]
@@ -1568,7 +1615,7 @@
 
             self.context.close_path()
             self.context.fill()
-            
+
             if False:
                 self.context.move_to(self.borders[HORZ] + 0.5*self.steps[HORZ], middle)
                 for x_index in range(len(self.data)-1) :
@@ -1576,11 +1623,11 @@
                     y1 = middle - self.ground(x_index)*self.steps[VERT] - self.data[x_index][data_index]*self.steps[VERT]
                     x2 = self.borders[HORZ] + (0.5 + x_index + 1)*self.steps[HORZ]
                     y2 = middle - self.ground(x_index + 1)*self.steps[VERT] - self.data[x_index + 1][data_index]*self.steps[VERT]
-                    
+
                     for i in range(0,data_index):
                         y1 -= self.data[x_index][i]*self.steps[VERT]
                         y2 -= self.data[x_index+1][i]*self.steps[VERT]
-                    
+
                     ang1 = self.angles[x_index][data_index+1]
                     ang2 = self.angles[x_index+1][data_index+1] + math.pi
                     self.context.set_source_rgba(1.0,0.0,0.0)
@@ -1589,9 +1636,9 @@
                     self.context.set_source_rgba(0.0,0.0,0.0)
                     self.context.arc(x2+p*math.cos(ang2),y2+p*math.sin(ang2),2,0,2*math.pi)
                     self.context.fill()
-                    '''self.context.set_source_rgba(0.0,0.0,0.0,0.3)
+                    """self.context.set_source_rgba(0.0,0.0,0.0,0.3)
                     self.context.arc(x2,y2,2,0,2*math.pi)
-                    self.context.fill()'''
+                    self.context.fill()"""
                     self.context.move_to(x1,y1)
                     self.context.line_to(x1+p*math.cos(ang1),y1+p*math.sin(ang1))
                     self.context.stroke()
@@ -1604,11 +1651,11 @@
                     y1 = middle - self.ground(x_index)*self.steps[VERT]
                     x2 = self.borders[HORZ] + (0.5 + x_index - 1)*self.steps[HORZ]
                     y2 = middle - self.ground(x_index - 1)*self.steps[VERT]
-                    
+
                     for i in range(0,data_index):
                         y1 -= self.data[x_index][i]*self.steps[VERT]
                         y2 -= self.data[x_index-1][i]*self.steps[VERT]
-                    
+
                     #revert angles by pi degrees to take the turn back
                     ang1 = self.angles[x_index][data_index] + math.pi
                     ang2 = self.angles[x_index-1][data_index]
@@ -1618,9 +1665,9 @@
                     self.context.set_source_rgba(0.0,0.0,1.0)
                     self.context.arc(x2+p*math.cos(ang2),y2+p*math.sin(ang2),2,0,2*math.pi)
                     self.context.fill()
-                    '''self.context.set_source_rgba(0.0,0.0,0.0,0.3)
+                    """self.context.set_source_rgba(0.0,0.0,0.0,0.3)
                     self.context.arc(x2,y2,2,0,2*math.pi)
-                    self.context.fill()'''
+                    self.context.fill()"""
                     self.context.move_to(x1,y1)
                     self.context.line_to(x1+p*math.cos(ang1),y1+p*math.sin(ang1))
                     self.context.stroke()
@@ -1628,18 +1675,18 @@
                     self.context.line_to(x2+p*math.cos(ang2),y2+p*math.sin(ang2))
                     self.context.stroke()
             #break
-            
+
             #self.context.arc(self.dimensions[HORZ]/2, self.dimensions[VERT]/2,50,0,3*math.pi/2)
             #self.context.fill()
-            
+
 
 class PiePlot(Plot):
     #TODO: Check the old cairoplot, graphs aren't matching
     def __init__ (self,
-            surface = None, 
-            data = None, 
-            width = 640, 
-            height = 480, 
+            surface = None,
+            data = None,
+            width = 640,
+            height = 480,
             background = "white light_gray",
             gradient = False,
             shadow = False,
@@ -1651,7 +1698,7 @@
         self.radius = min(self.dimensions[HORZ]/3,self.dimensions[VERT]/3)
         self.gradient = gradient
         self.shadow = shadow
-    
+
     def sort_function(x,y):
         return x.content - y.content
 
@@ -1668,6 +1715,8 @@
         self.context.close_path()
 
     def render(self):
+        Plot.render(self)
+
         self.render_background()
         self.render_bounding_box()
         if self.shadow:
@@ -1690,7 +1739,7 @@
         for number,key in enumerate(self.series_labels):
             # self.data[number] should be just a number
             data = sum(self.series[number].to_list())
-            
+
             next_angle = angle + 2.0*math.pi*data/self.total
             cr.set_source_rgba(*self.series_colors[number][:4])
             w = cr.text_extents(key)[2]
@@ -1732,9 +1781,9 @@
 
 class DonutPlot(PiePlot):
     def __init__ (self,
-            surface = None, 
-            data = None, 
-            width = 640, 
+            surface = None,
+            data = None,
+            width = 640,
             height = 480,
             background = "white light_gray",
             gradient = False,
@@ -1743,12 +1792,12 @@
             inner_radius=-1):
 
         Plot.__init__( self, surface, data, width, height, background, series_colors = colors )
-        
+
         self.center = ( self.dimensions[HORZ]/2, self.dimensions[VERT]/2 )
         self.total = sum( self.series.to_list() )
         self.radius = min( self.dimensions[HORZ]/3,self.dimensions[VERT]/3 )
         self.inner_radius = inner_radius*self.radius
-        
+
         if inner_radius == -1:
             self.inner_radius = self.radius/3
 
@@ -1762,7 +1811,7 @@
         self.context.line_to(self.center[0] + (self.inner_radius)*math.cos(next_angle), self.center[1] + (self.inner_radius)*math.sin(next_angle))
         self.context.arc_negative(self.center[0], self.center[1], self.inner_radius, next_angle, angle)
         self.context.close_path()
-    
+
     def render_shadow(self):
         horizontal_shift = 3
         vertical_shift = 3
@@ -1791,7 +1840,7 @@
     def calc_boundaries(self):
         self.bounds[HORZ] = (0,len(self.series))
         end_pos = max(self.series.to_list())
-        
+
         #for group in self.series:
         #    if hasattr(item, "__delitem__"):
         #        for sub_item in item:
@@ -1820,6 +1869,8 @@
         self.vertical_step = self.borders[VERT]
 
     def render(self):
+        Plot.render(self)
+
         self.calc_horz_extents()
         self.calc_vert_extents()
         self.calc_steps()
@@ -1835,7 +1886,7 @@
         cr.rectangle(0,0,self.dimensions[HORZ], self.dimensions[VERT])
         cr.fill()
         for number,group in enumerate(self.series):
-            linear = cairo.LinearGradient(self.dimensions[HORZ]/2, self.borders[VERT] + number*self.vertical_step, 
+            linear = cairo.LinearGradient(self.dimensions[HORZ]/2, self.borders[VERT] + number*self.vertical_step,
                                           self.dimensions[HORZ]/2, self.borders[VERT] + (number+1)*self.vertical_step)
             linear.add_color_stop_rgba(0,1.0,1.0,1.0,1.0)
             linear.add_color_stop_rgba(1.0,0.9,0.9,0.9,1.0)
@@ -1871,7 +1922,7 @@
                 w,h = cr.text_extents(label)[2], cr.text_extents(label)[3]
                 cr.move_to(40,self.borders[VERT] + number*self.vertical_step + self.vertical_step/2 + h/2)
                 cr.show_text(label)
-            
+
     def render_vert_labels(self):
         cr = self.context
         labels = self.labels[VERT]
@@ -1890,7 +1941,7 @@
         self.context.set_source(gradient)
         self.context.rectangle(x0,y0,w,h)
         self.context.fill()
-    
+
     def draw_circular_shadow(self, x, y, radius, ang_start, ang_end, mult, shadow):
         gradient = cairo.RadialGradient(x, y, 0, x, y, 2*radius)
         gradient.add_color_stop_rgba(0, 0, 0, 0, shadow)
@@ -1950,10 +2001,10 @@
     def render_plot(self):
         for index,group in enumerate(self.series):
             for data in group:
-                self.render_rectangle(self.borders[HORZ] + data.content[0]*self.horizontal_step, 
+                self.render_rectangle(self.borders[HORZ] + data.content[0]*self.horizontal_step,
                                       self.borders[VERT] + index*self.vertical_step + self.vertical_step/4.0,
-                                      self.borders[HORZ] + data.content[1]*self.horizontal_step, 
-                                      self.borders[VERT] + index*self.vertical_step + 3.0*self.vertical_step/4.0, 
+                                      self.borders[HORZ] + data.content[1]*self.horizontal_step,
+                                      self.borders[VERT] + index*self.vertical_step + 3.0*self.vertical_step/4.0,
                                       self.series_colors[index])
 
 # Function definition
@@ -1968,7 +2019,7 @@
                  border = 0,
                  axis = False,
                  dash = False,
-                 discrete = False, 
+                 discrete = False,
                  dots = False,
                  grid = False,
                  series_legend = False,
@@ -1981,22 +2032,22 @@
                  y_title  = None,
                  series_colors = None,
                  circle_colors = None):
-    
-    '''
+
+    """
         - Function to plot scatter data.
-        
+
         - Parameters
-        
+
         data - The values to be ploted might be passed in a two basic:
                list of points:       [(0,0), (0,1), (0,2)] or [(0,0,1), (0,1,4), (0,2,1)]
                lists of coordinates: [ [0,0,0] , [0,1,2] ] or [ [0,0,0] , [0,1,2] , [1,4,1] ]
-               Notice that these kinds of that can be grouped in order to form more complex data 
+               Notice that these kinds of that can be grouped in order to form more complex data
                using lists of lists or dictionaries;
         series_colors - Define color values for each of the series
         circle_colors - Define a lower and an upper bound for the circle colors for variable radius
                         (3 dimensions) series
-    '''
-    
+    """
+
     plot = ScatterPlot( name, data, errorx, errory, width, height, background, border,
                         axis, dash, discrete, dots, grid, series_legend, x_labels, y_labels,
                         x_bounds, y_bounds, z_bounds, x_title, y_title, series_colors, circle_colors )
@@ -2021,9 +2072,9 @@
                   x_title  = None,
                   y_title  = None,
                   series_colors = None):
-    '''
+    """
         - Function to plot graphics using dots and lines.
-        
+
         dot_line_plot (name, data, width, height, background = "white light_gray", border = 0, axis = False, grid = False, x_labels = None, y_labels = None, x_bounds = None, y_bounds = None)
 
         - Parameters
@@ -2031,7 +2082,7 @@
         name - Name of the desired output file, no need to input the .svg as it will be added at runtim;
         data - The list, list of lists or dictionary holding the data to be plotted;
         width, height - Dimensions of the output image;
-        background - A 3 element tuple representing the rgb color expected for the background or a new cairo linear gradient. 
+        background - A 3 element tuple representing the rgb color expected for the background or a new cairo linear gradient.
                      If left None, a gray to white gradient will be generated;
         border - Distance in pixels of a square border into which the graphics will be drawn;
         axis - Whether or not the axis are to be drawn;
@@ -2048,12 +2099,12 @@
 
         data = [0, 1, 3, 8, 9, 0, 10, 10, 2, 1]
         CairoPlot.dot_line_plot('teste', data, 400, 300)
-        
+
         data = { "john" : [10, 10, 10, 10, 30], "mary" : [0, 0, 3, 5, 15], "philip" : [13, 32, 11, 25, 2] }
         x_labels = ["jan/2008", "feb/2008", "mar/2008", "apr/2008", "may/2008" ]
-        CairoPlot.dot_line_plot( 'test', data, 400, 300, axis = True, grid = True, 
+        CairoPlot.dot_line_plot( 'test', data, 400, 300, axis = True, grid = True,
                                   series_legend = True, x_labels = x_labels )
-    '''
+    """
     plot = DotLinePlot( name, data, width, height, background, border,
                         axis, dash, dots, grid, series_legend, x_labels, y_labels,
                         x_bounds, y_bounds, x_title, y_title, series_colors )
@@ -2080,17 +2131,17 @@
                   series_colors = None,
                   step = 1):
 
-    '''
+    """
         - Function to plot functions.
-        
+
         function_plot(name, data, width, height, background = "white light_gray", border = 0, axis = True, grid = False, dots = False, x_labels = None, y_labels = None, x_bounds = None, y_bounds = None, step = 1, discrete = False)
 
         - Parameters
-        
+
         name - Name of the desired output file, no need to input the .svg as it will be added at runtim;
         data - The list, list of lists or dictionary holding the data to be plotted;
         width, height - Dimensions of the output image;
-        background - A 3 element tuple representing the rgb color expected for the background or a new cairo linear gradient. 
+        background - A 3 element tuple representing the rgb color expected for the background or a new cairo linear gradient.
                      If left None, a gray to white gradient will be generated;
         border - Distance in pixels of a square border into which the graphics will be drawn;
         axis - Whether or not the axis are to be drawn;
@@ -2100,13 +2151,13 @@
         x_bounds, y_bounds - tuples containing the lower and upper value bounds for the data to be plotted;
         step - the horizontal distance from one point to the other. The smaller, the smoother the curve will be;
         discrete - whether or not the function should be plotted in discrete format.
-       
+
         - Example of use
 
         data = lambda x : x**2
         CairoPlot.function_plot('function4', data, 400, 300, grid = True, x_bounds=(-10,10), step = 0.1)
-    '''
-    
+    """
+
     plot = FunctionPlot( name, data, width, height, background, border,
                          axis, discrete, dots, grid, series_legend, x_labels, y_labels,
                          x_bounds, y_bounds, x_title, y_title, series_colors, step )
@@ -2115,27 +2166,27 @@
 
 def pie_plot( name, data, width, height, background = "white light_gray", gradient = False, shadow = False, colors = None ):
 
-    '''
+    """
         - Function to plot pie graphics.
-        
+
         pie_plot(name, data, width, height, background = "white light_gray", gradient = False, colors = None)
 
         - Parameters
-        
+
         name - Name of the desired output file, no need to input the .svg as it will be added at runtim;
         data - The list, list of lists or dictionary holding the data to be plotted;
         width, height - Dimensions of the output image;
-        background - A 3 element tuple representing the rgb color expected for the background or a new cairo linear gradient. 
+        background - A 3 element tuple representing the rgb color expected for the background or a new cairo linear gradient.
                      If left None, a gray to white gradient will be generated;
         gradient - Whether or not the pie color will be painted with a gradient;
         shadow - Whether or not there will be a shadow behind the pie;
         colors - List of slices colors.
 
         - Example of use
-        
+
         teste_data = {"john" : 123, "mary" : 489, "philip" : 890 , "suzy" : 235}
         CairoPlot.pie_plot("pie_teste", teste_data, 500, 500)
-    '''
+    """
 
     plot = PiePlot( name, data, width, height, background, gradient, shadow, colors )
     plot.render()
@@ -2143,17 +2194,17 @@
 
 def donut_plot(name, data, width, height, background = "white light_gray", gradient = False, shadow = False, colors = None, inner_radius = -1):
 
-    '''
+    """
         - Function to plot donut graphics.
-        
+
         donut_plot(name, data, width, height, background = "white light_gray", gradient = False, inner_radius = -1)
 
         - Parameters
-        
+
         name - Name of the desired output file, no need to input the .svg as it will be added at runtim;
         data - The list, list of lists or dictionary holding the data to be plotted;
         width, height - Dimensions of the output image;
-        background - A 3 element tuple representing the rgb color expected for the background or a new cairo linear gradient. 
+        background - A 3 element tuple representing the rgb color expected for the background or a new cairo linear gradient.
                      If left None, a gray to white gradient will be generated;
         shadow - Whether or not there will be a shadow behind the donut;
         gradient - Whether or not the donut color will be painted with a gradient;
@@ -2161,10 +2212,10 @@
         inner_radius - The radius of the donut's inner circle.
 
         - Example of use
-        
+
         teste_data = {"john" : 123, "mary" : 489, "philip" : 890 , "suzy" : 235}
         CairoPlot.donut_plot("donut_teste", teste_data, 500, 500)
-    '''
+    """
 
     plot = DonutPlot(name, data, width, height, background, gradient, shadow, colors, inner_radius)
     plot.render()
@@ -2172,13 +2223,13 @@
 
 def gantt_chart(name, pieces, width, height, x_labels, y_labels, colors):
 
-    '''
+    """
         - Function to generate Gantt Charts.
-        
+
         gantt_chart(name, pieces, width, height, x_labels, y_labels, colors):
 
         - Parameters
-        
+
         name - Name of the desired output file, no need to input the .svg as it will be added at runtim;
         pieces - A list defining the spaces to be drawn. The user must pass, for each line, the index of its start and the index of its end. If a line must have two or more spaces, they must be passed inside a list;
         width, height - Dimensions of the output image;
@@ -2193,42 +2244,42 @@
         y_labels = [ '0001', '0002', '0003', '0004', '0005', '0006', '0007', '0008', '0009', '0010' ]
         colors = [ (1.0, 0.0, 0.0), (1.0, 0.7, 0.0), (1.0, 1.0, 0.0), (0.0, 1.0, 0.0) ]
         CairoPlot.gantt_chart('gantt_teste', pieces, 600, 300, x_labels, y_labels, colors)
-    '''
+    """
 
     plot = GanttChart(name, pieces, width, height, x_labels, y_labels, colors)
     plot.render()
     plot.commit()
 
-def vertical_bar_plot(name, 
-                      data, 
-                      width, 
-                      height, 
-                      background = "white light_gray", 
-                      border = 0, 
+def vertical_bar_plot(name,
+                      data,
+                      width,
+                      height,
+                      background = "white light_gray",
+                      border = 0,
                       display_values = False,
                       grid = False,
                       rounded_corners = False,
                       stack = False,
                       three_dimension = False,
                       series_labels = None,
-                      x_labels = None, 
-                      y_labels = None, 
-                      x_bounds = None, 
+                      x_labels = None,
+                      y_labels = None,
+                      x_bounds = None,
                       y_bounds = None,
                       colors = None):
     #TODO: Fix docstring for vertical_bar_plot
-    '''
+    """
         - Function to generate vertical Bar Plot Charts.
 
-        bar_plot(name, data, width, height, background, border, grid, rounded_corners, three_dimension, 
+        bar_plot(name, data, width, height, background, border, grid, rounded_corners, three_dimension,
                  x_labels, y_labels, x_bounds, y_bounds, colors):
 
         - Parameters
-        
+
         name - Name of the desired output file, no need to input the .svg as it will be added at runtime;
         data - The list, list of lists or dictionary holding the data to be plotted;
         width, height - Dimensions of the output image;
-        background - A 3 element tuple representing the rgb color expected for the background or a new cairo linear gradient. 
+        background - A 3 element tuple representing the rgb color expected for the background or a new cairo linear gradient.
                      If left None, a gray to white gradient will be generated;
         border - Distance in pixels of a square border into which the graphics will be drawn;
         grid - Whether or not the gris is to be drawn;
@@ -2242,19 +2293,19 @@
 
         data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
         CairoPlot.vertical_bar_plot ('bar2', data, 400, 300, border = 20, grid = True, rounded_corners = False)
-    '''
-    
-    plot = VerticalBarPlot(name, data, width, height, background, border, 
-                           display_values, grid, rounded_corners, stack, three_dimension, 
+    """
+
+    plot = VerticalBarPlot(name, data, width, height, background, border,
+                           display_values, grid, rounded_corners, stack, three_dimension,
                            series_labels, x_labels, y_labels, x_bounds, y_bounds, colors)
     plot.render()
     plot.commit()
 
-def horizontal_bar_plot(name, 
-                       data, 
-                       width, 
-                       height, 
-                       background = "white light_gray", 
+def horizontal_bar_plot(name,
+                       data,
+                       width,
+                       height,
+                       background = "white light_gray",
                        border = 0,
                        display_values = False,
                        grid = False,
@@ -2262,25 +2313,25 @@
                        stack = False,
                        three_dimension = False,
                        series_labels = None,
-                       x_labels = None, 
-                       y_labels = None, 
-                       x_bounds = None, 
+                       x_labels = None,
+                       y_labels = None,
+                       x_bounds = None,
                        y_bounds = None,
                        colors = None):
 
     #TODO: Fix docstring for horizontal_bar_plot
-    '''
+    """
         - Function to generate Horizontal Bar Plot Charts.
 
-        bar_plot(name, data, width, height, background, border, grid, rounded_corners, three_dimension, 
+        bar_plot(name, data, width, height, background, border, grid, rounded_corners, three_dimension,
                  x_labels, y_labels, x_bounds, y_bounds, colors):
 
         - Parameters
-        
+
         name - Name of the desired output file, no need to input the .svg as it will be added at runtime;
         data - The list, list of lists or dictionary holding the data to be plotted;
         width, height - Dimensions of the output image;
-        background - A 3 element tuple representing the rgb color expected for the background or a new cairo linear gradient. 
+        background - A 3 element tuple representing the rgb color expected for the background or a new cairo linear gradient.
                      If left None, a gray to white gradient will be generated;
         border - Distance in pixels of a square border into which the graphics will be drawn;
         grid - Whether or not the gris is to be drawn;
@@ -2294,29 +2345,29 @@
 
         data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
         CairoPlot.bar_plot ('bar2', data, 400, 300, border = 20, grid = True, rounded_corners = False)
-    '''
-    
-    plot = HorizontalBarPlot(name, data, width, height, background, border, 
-                             display_values, grid, rounded_corners, stack, three_dimension, 
+    """
+
+    plot = HorizontalBarPlot(name, data, width, height, background, border,
+                             display_values, grid, rounded_corners, stack, three_dimension,
                              series_labels, x_labels, y_labels, x_bounds, y_bounds, colors)
     plot.render()
     plot.commit()
 
-def stream_chart(name, 
-                 data, 
-                 width, 
-                 height, 
-                 background = "white light_gray", 
+def stream_chart(name,
+                 data,
+                 width,
+                 height,
+                 background = "white light_gray",
                  border = 0,
                  grid = False,
                  series_legend = None,
-                 x_labels = None, 
-                 x_bounds = None, 
+                 x_labels = None,
+                 x_bounds = None,
                  y_bounds = None,
                  colors = None):
 
     #TODO: Fix docstring for horizontal_bar_plot
-    plot = StreamChart(name, data, width, height, background, border, 
+    plot = StreamChart(name, data, width, height, background, border,
                        grid, series_legend, x_labels, x_bounds, y_bounds, colors)
     plot.render()
     plot.commit()

=== added directory 'trunk/cairoplot/handlers'
=== added file 'trunk/cairoplot/handlers/__init__.py'
--- trunk/cairoplot/handlers/__init__.py	1970-01-01 00:00:00 +0000
+++ trunk/cairoplot/handlers/__init__.py	2010-04-07 05:06:25 +0000
@@ -0,0 +1,10 @@
+__all__ = ["handler", "png", "pdf", "ps", "svg", "vector"]
+
+# default handlers
+from .handler import Handler
+from .png import PNGHandler
+from .pdf import PDFHandler
+from .ps import PSHandler
+from .svg import SVGHandler
+from .vector import VectorHandler
+

=== added file 'trunk/cairoplot/handlers/fixedsize.py'
--- trunk/cairoplot/handlers/fixedsize.py	1970-01-01 00:00:00 +0000
+++ trunk/cairoplot/handlers/fixedsize.py	2010-04-07 05:06:25 +0000
@@ -0,0 +1,30 @@
+
+import cairo
+import cairoplot
+from .handler import Handler as _Handler
+
+class FixedSizeHandler(_Handler):
+    """Base class for handlers with a fixed size."""
+
+    def __init__(self, width, height):
+        """Create with fixed width and height."""
+        self.dimensions = {}
+        self.dimensions[cairoplot.HORZ] = width
+        self.dimensions[cairoplot.VERT] = height
+
+        # sub-classes must create a surface
+        self.surface = None
+
+    def prepare(self, plot):
+        """Prepare plot to render by setting its dimensions."""
+        _Handler.prepare(self, plot)
+        plot.dimensions = self.dimensions
+        plot.context = cairo.Context(self.surface)
+
+    def commit(self, plot):
+        """Commit the plot (to a file)."""
+        _Handler.commit(self, plot)
+
+        # since pngs are different from other fixed size handlers,
+        # sub-classes are in charge of actual file writing
+

=== added file 'trunk/cairoplot/handlers/gtk.py'
--- trunk/cairoplot/handlers/gtk.py	1970-01-01 00:00:00 +0000
+++ trunk/cairoplot/handlers/gtk.py	2010-04-07 05:06:25 +0000
@@ -0,0 +1,39 @@
+from __future__ import absolute_import
+
+import gtk
+import cairo
+import cairoplot
+from .handler import Handler as _Handler
+
+class GTKHandler(_Handler, gtk.DrawingArea):
+    """Handler to create plots that output to vector files."""
+
+    def __init__(self, *args, **kwargs):
+        """Create Handler for arbitrary surfaces."""
+        _Handler.__init__(self)
+        gtk.DrawingArea.__init__(self)
+       
+        # users of this class must set plot manually
+        self.plot = None
+        self.context = None
+
+        # connect events for resizing/redrawing
+        self.connect("expose_event", self.on_expose_event)
+
+    def on_expose_event(self, widget, data):
+        """Redraws plot if need be."""
+        
+        self.context = widget.window.cairo_create()
+        if (self.plot is not None):
+            self.plot.render()
+
+    def prepare(self, plot):
+        """Update plot's size and context with custom widget."""
+        _Handler.prepare(self, plot)
+        self.plot = plot
+        plot.context = self.context
+
+        allocation = self.get_allocation()
+        plot.dimensions[cairoplot.HORZ] = allocation.width
+        plot.dimensions[cairoplot.VERT] = allocation.height
+

=== added file 'trunk/cairoplot/handlers/handler.py'
--- trunk/cairoplot/handlers/handler.py	1970-01-01 00:00:00 +0000
+++ trunk/cairoplot/handlers/handler.py	2010-04-07 05:06:25 +0000
@@ -0,0 +1,11 @@
+
+class Handler(object):
+    """Base class for all handlers."""
+
+    def prepare(self, plot):
+        pass
+
+    def commit(self, plot):
+        """All handlers need to finalize the cairo context."""
+        plot.context.show_page()
+

=== added file 'trunk/cairoplot/handlers/pdf.py'
--- trunk/cairoplot/handlers/pdf.py	1970-01-01 00:00:00 +0000
+++ trunk/cairoplot/handlers/pdf.py	2010-04-07 05:06:25 +0000
@@ -0,0 +1,12 @@
+
+import cairo
+from .vector import VectorHandler as _VectorHandler
+
+class PDFHandler(_VectorHandler):
+    """Handler to create plots that output to pdf files."""
+
+    def __init__(self, filename, width, height):
+        """Creates a surface to be used by Cairo."""
+        _VectorHandler.__init__(self, None, width, height)
+        self.surface = cairo.PDFSurface(filename, width, height)
+

=== added file 'trunk/cairoplot/handlers/png.py'
--- trunk/cairoplot/handlers/png.py	1970-01-01 00:00:00 +0000
+++ trunk/cairoplot/handlers/png.py	2010-04-07 05:06:25 +0000
@@ -0,0 +1,19 @@
+
+import cairo
+
+from .fixedsize import FixedSizeHandler as _FixedSizeHandler
+
+class PNGHandler(_FixedSizeHandler):
+    """Handler to create plots that output to png files."""
+
+    def __init__(self, filename, width, height):
+        """Creates a surface to be used by Cairo."""
+        _FixedSizeHandler.__init__(self, width, height)
+        self.filename = filename
+        self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+
+    def commit(self, plot):
+        """Writes plot to file."""
+        _FixedSizeHandler.commit(self, plot)
+        self.surface.write_to_png(self.filename)
+

=== added file 'trunk/cairoplot/handlers/ps.py'
--- trunk/cairoplot/handlers/ps.py	1970-01-01 00:00:00 +0000
+++ trunk/cairoplot/handlers/ps.py	2010-04-07 05:06:25 +0000
@@ -0,0 +1,12 @@
+
+import cairo
+from .vector import VectorHandler as _VectorHandler
+
+class PSHandler(_VectorHandler):
+    """Handler to create plots that output to PostScript files."""
+
+    def __init__(self, filename, width, height):
+        """Creates a surface to be used by Cairo."""
+        _VectorHandler.__init__(self, None, width, height)
+        self.surface = cairo.PSSurface(filename, width, height)
+

=== added file 'trunk/cairoplot/handlers/svg.py'
--- trunk/cairoplot/handlers/svg.py	1970-01-01 00:00:00 +0000
+++ trunk/cairoplot/handlers/svg.py	2010-04-07 05:06:25 +0000
@@ -0,0 +1,12 @@
+
+import cairo
+from .vector import VectorHandler as _VectorHandler
+
+class SVGHandler(_VectorHandler):
+    """Handler to create plots that output to svg files."""
+
+    def __init__(self, filename, width, height):
+        """Creates a surface to be used by Cairo."""
+        _VectorHandler.__init__(self, None, width, height)
+        self.surface = cairo.SVGSurface(filename, width, height)
+

=== added file 'trunk/cairoplot/handlers/vector.py'
--- trunk/cairoplot/handlers/vector.py	1970-01-01 00:00:00 +0000
+++ trunk/cairoplot/handlers/vector.py	2010-04-07 05:06:25 +0000
@@ -0,0 +1,17 @@
+
+import cairo
+from .fixedsize import FixedSizeHandler as _FixedSizeHandler
+
+class VectorHandler(_FixedSizeHandler):
+    """Handler to create plots that output to vector files."""
+
+    def __init__(self, surface, *args, **kwargs):
+        """Create Handler for arbitrary surfaces."""
+        _FixedSizeHandler.__init__(self, *args, **kwargs)
+        self.surface = surface
+
+    def commit(self, plot):
+        """Writes plot to file."""
+        _FixedSizeHandler.commit(self, plot)
+        self.surface.finish()
+

=== renamed file 'trunk/series.py' => 'trunk/cairoplot/series.py'
--- trunk/series.py	2009-07-09 22:02:04 +0000
+++ trunk/cairoplot/series.py	2010-04-07 05:06:25 +0000
@@ -36,23 +36,23 @@
 DEFAULT_COLOR_LIST = None
 
 class Data(object):
-    '''
+    """
         Class that models the main data structure.
         It can hold:
          - a number type (int, float or long)
          - a tuple, witch represents a point and can have 2 or 3 items (x,y,z)
          - if a list is passed it will be converted to a tuple.
-         
+
         obs: In case a tuple is passed it will convert to tuple
-    '''
+    """
     def __init__(self, data=None, name=None, parent=None):
-        '''
+        """
             Starts main atributes from the Data class
             @name    - Name for each point;
             @content - The real data, can be an int, float, long or tuple, which
                        represents a point (x,y) or (x,y,z);
             @parent  - A pointer that give the data access to it's parent.
-            
+
             Usage:
             >>> d = Data(name='empty'); print d
             empty: ()
@@ -64,23 +64,23 @@
             point c: (2, 3)
             >>> d = Data(12, 'simple value'); print d
             simple value: 12
-        '''
+        """
         # Initial values
         self.__content = None
         self.__name = None
-        
+
         # Setting passed values
         self.parent = parent
         self.name = name
         self.content = data
-        
+
     # Name property
     @apply
     def name():
-        doc = '''
+        doc = """
             Name is a read/write property that controls the input of name.
              - If passed an invalid value it cleans the name with None
-             
+
             Usage:
             >>> d = Data(13); d.name = 'name_test'; print d
             name_test: 13
@@ -94,33 +94,33 @@
             last_name: 13
             >>> d.name = ''; print d
             13
-        '''
+        """
         def fget(self):
-            '''
+            """
                 returns the name as a string
-            '''
+            """
             return self.__name
-        
+
         def fset(self, name):
-            '''
+            """
                 Sets the name of the Data
-            '''
+            """
             if type(name) in STRTYPES and len(name) > 0:
                 self.__name = name
             else:
                 self.__name = None
-                
-        
-        
+
+
+
         return property(**locals())
 
     # Content property
     @apply
     def content():
-        doc = '''
+        doc = """
             Content is a read/write property that validate the data passed
             and return it.
-            
+
             Usage:
             >>> d = Data(); d.content = 13; d.content
             13
@@ -132,90 +132,90 @@
             (1, 2, 3)
             >>> d = Data(); d.content = [1.5,.2,3.3]; d.content
             (1.5, 0.20000000000000001, 3.2999999999999998)
-        '''
+        """
         def fget(self):
-            '''
+            """
                 Return the content of Data
-            '''
+            """
             return self.__content
 
         def fset(self, data):
-            '''
+            """
                 Ensures that data is a valid tuple/list or a number (int, float
                 or long)
-            '''
+            """
             # Type: None
             if data is None:
                 self.__content = None
                 return
-            
+
             # Type: Int or Float
             elif type(data) in NUMTYPES:
                 self.__content = data
-            
+
             # Type: List or Tuple
             elif type(data) in LISTTYPES:
                 # Ensures the correct size
                 if len(data) not in (2, 3):
                     raise TypeError, "Data (as list/tuple) must have 2 or 3 items"
                     return
-                    
+
                 # Ensures that all items in list/tuple is a number
                 isnum = lambda x : type(x) not in NUMTYPES
-                    
+
                 if max(map(isnum, data)):
                     # An item in data isn't an int or a float
                     raise TypeError, "All content of data must be a number (int or float)"
-                    
+
                 # Convert the tuple to list
                 if type(data) is list:
                     data = tuple(data)
-                    
+
                 # Append a copy and sets the type
                 self.__content = data[:]
-            
+
             # Unknown type!
             else:
                 self.__content = None
                 raise TypeError, "Data must be an int, float or a tuple with two or three items"
                 return
-            
+
         return property(**locals())
 
-    
+
     def clear(self):
-        '''
+        """
             Clear the all Data (content, name and parent)
-        '''
+        """
         self.content = None
         self.name = None
         self.parent = None
-        
+
     def copy(self):
-        '''
+        """
             Returns a copy of the Data structure
-        '''
+        """
         # The copy
         new_data = Data()
         if self.content is not None:
             # If content is a point
             if type(self.content) is tuple:
                 new_data.__content = self.content[:]
-                
+
             # If content is a number
             else:
                 new_data.__content = self.content
-                
+
         # If it has a name
         if self.name is not None:
             new_data.__name = self.name
-            
+
         return new_data
-    
+
     def __str__(self):
-        '''
+        """
             Return a string representation of the Data structure
-        '''
+        """
         if self.name is None:
             if self.content is None:
                 return ''
@@ -226,23 +226,23 @@
             return self.name+": "+str(self.content)
 
     def __len__(self):
-        '''
+        """
             Return the length of the Data.
              - If it's a number return 1;
              - If it's a list return it's length;
              - If its None return 0.
-        '''
+        """
         if self.content is None:
             return 0
         elif type(self.content) in NUMTYPES:
             return 1
         return len(self.content)
-    
-    
-    
+
+
+
 
 class Group(object):
-    '''
+    """
         Class that models a group of data. Every value (int, float, long, tuple
         or list) passed is converted to a list of Data.
         It can receive:
@@ -251,20 +251,20 @@
          - A tuple of numbers;
          - An instance of Data;
          - A list of Data;
-         
+
          Obs: If a tuple with 2 or 3 items is passed it is converted to a point.
               If a tuple with only 1 item is passed it's converted to a number;
               If a tuple with more than 2 items is passed it's converted to a
                list of numbers
-    '''
+    """
     def __init__(self, group=None, name=None, parent=None):
-        '''
+        """
             Starts main atributes in Group instance.
             @data_list  - a list of data which forms the group;
             @range      - a range that represent the x axis of possible functions;
             @name       - name of the data group;
             @parent     - the Serie parent of this group.
-            
+
             Usage:
             >>> g = Group(13, 'simple number'); print g
             simple number ['13']
@@ -280,24 +280,24 @@
             2D coordinated lists ['(1, 1)', '(2, 2)', '(3, 3)']
             >>> g = Group([[1,2],[1,2],[1,2]], '3D coordinate lists'); print g
             3D coordinated lists ['(1, 1, 1)', '(2, 2, 2)']
-        '''
+        """
         # Initial values
         self.__data_list = []
         self.__range = []
         self.__name = None
-        
-        
+
+
         self.parent = parent
         self.name = name
         self.data_list = group
-        
+
     # Name property
     @apply
     def name():
-        doc = '''
+        doc = """
             Name is a read/write property that controls the input of name.
              - If passed an invalid value it cleans the name with None
-             
+
             Usage:
             >>> g = Group(13); g.name = 'name_test'; print g
             name_test ['13']
@@ -311,32 +311,32 @@
             last_name ['13']
             >>> g.name = ''; print g
             ['13']
-        '''
+        """
         def fget(self):
-            '''
+            """
                 Returns the name as a string
-            '''
+            """
             return self.__name
-        
+
         def fset(self, name):
-            '''
+            """
                 Sets the name of the Group
-            '''
+            """
             if type(name) in STRTYPES and len(name) > 0:
                 self.__name = name
             else:
                 self.__name = None
-        
+
         return property(**locals())
 
     # data_list property
     @apply
     def data_list():
-        doc = '''
+        doc = """
             The data_list is a read/write property that can be a list of
             numbers, a list of points or a list of 2 or 3 coordinate lists. This
             property uses mainly the self.add_data method.
-            
+
             Usage:
             >>> g = Group(); g.data_list = 13; print g
             ['13']
@@ -356,32 +356,32 @@
             ['(1, 1, 1)', '(2, 2, 2)']
             >>> g.range = (10); g.data_list = lambda x:x**2; print g
             ['(0.0, 0.0)', '(1.0, 1.0)', '(2.0, 4.0)', '(3.0, 9.0)', '(4.0, 16.0)', '(5.0, 25.0)', '(6.0, 36.0)', '(7.0, 49.0)', '(8.0, 64.0)', '(9.0, 81.0)']
-        '''
+        """
         def fget(self):
-            '''
+            """
                 Returns the value of data_list
-            '''
+            """
             return self.__data_list
 
         def fset(self, group):
-            '''
+            """
                 Ensures that group is valid.
-            '''
+            """
             # None
             if group is None:
                 self.__data_list = []
-            
+
             # Int/float/long or Instance of Data
             elif type(group) in NUMTYPES or isinstance(group, Data):
                 # Clean data_list
                 self.__data_list = []
                 self.add_data(group)
-            
+
             # One point
             elif type(group) is tuple and len(group) in (2,3):
                 self.__data_list = []
                 self.add_data(group)
-            
+
             # list of items
             elif type(group) in LISTTYPES and type(group[0]) is not list:
                 # Clean data_list
@@ -389,7 +389,7 @@
                 for item in group:
                     # try to append and catch an exception
                     self.add_data(item)
-            
+
             # function lambda
             elif callable(group):
                 # Explicit is better than implicit
@@ -402,7 +402,7 @@
                     for x in self.range:
                         #self.add_data((x,round(group(x),2)))
                         self.add_data((x,function(x)))
-                        
+
                 # Only have range in parent
                 elif self.parent is not None and len(self.parent.range) is not 0:
                     # Copy parent range
@@ -413,12 +413,12 @@
                     for x in self.range:
                         #self.add_data((x,round(group(x),2)))
                         self.add_data((x,function(x)))
-                        
+
                 # Don't have range anywhere
                 else:
                     # x_data don't exist
                     raise Exception, "Data argument is valid but to use function type please set x_range first"
-                
+
             # Coordinate Lists
             elif type(group) in LISTTYPES and type(group[0]) is list:
                 # Clean data_list
@@ -430,10 +430,10 @@
                     data = zip(group[0], group[1])
                 else:
                     raise TypeError, "Only one list of coordinates was received."
-                
+
                 for item in data:
                     self.add_data(item)
-                
+
             else:
                 raise TypeError, "Group type not supported"
 
@@ -441,16 +441,16 @@
 
     @apply
     def range():
-        doc = '''
+        doc = """
             The range is a read/write property that generates a range of values
             for the x axis of the functions. When passed a tuple it almost works
             like the built-in range funtion:
              - 1 item, represent the end of the range started from 0;
              - 2 items, represents the start and the end, respectively;
              - 3 items, the last one represents the step;
-             
+
             When passed a list the range function understands as a valid range.
-            
+
             Usage:
             >>> g = Group(); g.range = 10; print g.range
             [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
@@ -465,21 +465,21 @@
             [0.0]
             >>> g = Group(); g.range = [0,10,20]; print g.range
             [0.0, 10.0, 20.0]
-        '''
+        """
         def fget(self):
-            '''
+            """
                 Returns the range
-            '''
+            """
             return self.__range
-        
+
         def fset(self, x_range):
-            '''
+            """
                 Controls the input of a valid type and generate the range
-            '''
+            """
             # if passed a simple number convert to tuple
             if type(x_range) in NUMTYPES:
                 x_range = (x_range,)
-            
+
             # A list, just convert to float
             if type(x_range) is list and len(x_range) > 0:
                 # Convert all to float
@@ -488,32 +488,32 @@
                 self.__range = list(set(x_range[:]))
                 # Sort the list to ascending order
                 self.__range.sort()
-            
+
             # A tuple, must check the lengths and generate the values
             elif type(x_range) is tuple and len(x_range) in (1,2,3):
                 # Convert all to float
                 x_range = map(float, x_range)
-                
+
                 # Inital values
                 start = 0.0
                 step = 1.0
                 end = 0.0
-                
+
                 # Only the end and it can't be less or iqual to 0
                 if len(x_range) is 1 and x_range > 0:
                         end = x_range[0]
-                
+
                 # The start and the end but the start must be less then the end
                 elif len(x_range) is 2 and x_range[0] < x_range[1]:
                         start = x_range[0]
                         end = x_range[1]
-                
+
                 # All 3, but the start must be less then the end
                 elif x_range[0] <= x_range[1]:
                         start = x_range[0]
                         end = x_range[1]
                         step = x_range[2]
-                
+
                 # Starts the range
                 self.__range = []
                 # Generate the range
@@ -521,19 +521,19 @@
                 while start < end:
                     self.__range.append(start)
                     start += step
-                
+
             # Incorrect type
             else:
                 raise Exception, "x_range must be a list with one or more items or a tuple with 2 or 3 items"
-        
+
         return property(**locals())
 
     def add_data(self, data, name=None):
-        '''
+        """
             Append a new data to the data_list.
              - If data is an instance of Data, append it
              - If it's an int, float, tuple or list create an instance of Data and append it
-            
+
             Usage:
             >>> g = Group()
             >>> g.add_data(12); print g
@@ -546,24 +546,24 @@
             ['a: (1, 1)']
             >>> g.add_data((2,2),'b'); print g
             ['a: (1, 1)', 'b: (2, 2)']
-            >>> 
+            >>>
             >>> g.add_data(Data((1,2),'c')); print g
             ['a: (1, 1)', 'b: (2, 2)', 'c: (1, 2)']
-        '''
+        """
         if not isinstance(data, Data):
             # Try to convert
             data = Data(data,name,self)
-        
+
         if data.content is not None:
             self.__data_list.append(data.copy())
             self.__data_list[-1].parent = self
-        
+
 
     def to_list(self):
-        '''
+        """
             Returns the group as a list of numbers (int, float or long) or a
             list of tuples (points 2D or 3D).
-            
+
             Usage:
             >>> g = Group([1,2,3,4],'g1'); g.to_list()
             [1, 2, 3, 4]
@@ -571,13 +571,13 @@
             [(1, 2), (2, 3), (3, 4)]
             >>> g = Group([(1,2,3),(3,4,5)],'g2'); g.to_list()
             [(1, 2, 3), (3, 4, 5)]
-        '''
+        """
         return [data.content for data in self]
-    
+
     def copy(self):
-        '''
+        """
             Returns a copy of this group
-        '''
+        """
         new_group = Group()
         new_group.__name = self.__name
         if self.__range is not None:
@@ -585,11 +585,11 @@
         for data in self:
             new_group.add_data(data.copy())
         return new_group
-    
+
     def get_names(self):
-        '''
+        """
             Return a list with the names of all data in this group
-        '''
+        """
         names = []
         for data in self:
             if data.name is None:
@@ -597,12 +597,12 @@
             else:
                 names.append(data.name)
         return names
-        
-    
+
+
     def __str__ (self):
-        '''
+        """
             Returns a string representing the Group
-        '''
+        """
         ret = ""
         if self.name is not None:
             ret += self.name + " "
@@ -612,25 +612,25 @@
         else:
             ret += "[]"
         return ret
-    
+
     def __getitem__(self, key):
-        '''
+        """
             Makes a Group iterable, based in the data_list property
-        '''
+        """
         return self.data_list[key]
-    
+
     def __len__(self):
-        '''
+        """
             Returns the length of the Group, based in the data_list property
-        '''
+        """
         return len(self.data_list)
 
 
 class Colors(object):
-    '''
+    """
         Class that models the colors its labels (names) and its properties, RGB
         and filling type.
-        
+
         It can receive:
         - A list where each item is a list with 3 or 4 items. The
           first 3 items represent the RGB values and the last argument
@@ -640,19 +640,19 @@
         - A dictionary where each key will be the color name and its item
           can be a list with 3 or 4 items. The first 3 items represent
           the RGB colors and the last argument defines the filling type.
-    '''
+    """
     def __init__(self, color_list=None):
-        '''
+        """
             Start the color_list property
             @ color_list - the list or dict contaning the colors properties.
-        '''
+        """
         self.__color_list = None
-        
+
         self.color_list = color_list
-    
+
     @apply
     def color_list():
-        doc = '''
+        doc = """
         >>> c = Colors([[1,1,1],[2,2,2,'linear'],[3,3,3,'gradient']])
         >>> print c.color_list
         {'Color 2': [2, 2, 2, 'linear'], 'Color 3': [3, 3, 3, 'gradient'], 'Color 1': [1, 1, 1, 'solid']}
@@ -662,21 +662,21 @@
         >>> c.color_list = {'a':[1,1,1],'b':(2,2,2,'solid'),'c':(3,3,3,'linear'), 'd':(4,4,4)}
         >>> print c.color_list
         {'a': [1, 1, 1, 'solid'], 'c': [3, 3, 3, 'linear'], 'b': [2, 2, 2, 'solid'], 'd': [4, 4, 4, 'solid']}
-        '''
+        """
         def fget(self):
-            '''
+            """
                 Return the color list
-            '''
+            """
             return self.__color_list
-        
+
         def fset(self, color_list):
-            '''
+            """
                 Format the color list to a dictionary
-            '''
+            """
             if color_list is None:
                 self.__color_list = None
                 return
-            
+
             if type(color_list) in LISTTYPES and type(color_list[0]) in LISTTYPES:
                 old_color_list = color_list[:]
                 color_list = {}
@@ -689,7 +689,7 @@
                         raise TypeError, "Unsuported color format"
             elif type(color_list) is not dict:
                 raise TypeError, "Unsuported color format"
-            
+
             for name, color in color_list.items():
                 if len(color) is 3:
                     if max(map(type, color)) in NUMTYPES:
@@ -702,12 +702,12 @@
                     else:
                         raise TypeError, "Unsuported color format"
             self.__color_list = color_list.copy()
-        
+
         return property(**locals())
-        
-    
+
+
 class Series(object):
-    '''
+    """
         Class that models a Series (group of groups). Every value (int, float,
         long, tuple or list) passed is converted to a list of Group or Data.
         It can receive:
@@ -726,15 +726,15 @@
            lists);
          - an instance of Data;
          - an instance of group.
-    '''
+    """
     def __init__(self, series=None, name=None, property=[], colors=None):
-        '''
+        """
             Starts main atributes in Group instance.
             @series     - a list, dict of data of which the series is composed;
             @name       - name of the series;
             @property   - a list/dict of properties to be used in the plots of
                           this Series
-            
+
             Usage:
             >>> print Series([1,2,3,4])
             ["Group 1 ['1', '2', '3', '4']"]
@@ -758,26 +758,26 @@
             ["Group 1 ['d1: 1']"]
             >>> print Series(Group([(1,2),(2,3)],'g1'))
             ["g1 ['(1, 2)', '(2, 3)']"]
-        '''
+        """
         # Intial values
         self.__group_list = []
         self.__name = None
         self.__range = None
-        
+
         # TODO: Implement colors with filling
         self.__colors = None
-        
+
         self.name = name
         self.group_list = series
         self.colors = colors
-        
+
     # Name property
     @apply
     def name():
-        doc = '''
+        doc = """
             Name is a read/write property that controls the input of name.
              - If passed an invalid value it cleans the name with None
-             
+
             Usage:
             >>> s = Series(13); s.name = 'name_test'; print s
             name_test ["Group 1 ['13']"]
@@ -791,30 +791,30 @@
             last_name ["Group 1 ['13']"]
             >>> s.name = ''; print s
             ["Group 1 ['13']"]
-        '''
+        """
         def fget(self):
-            '''
+            """
                 Returns the name as a string
-            '''
+            """
             return self.__name
-        
+
         def fset(self, name):
-            '''
+            """
                 Sets the name of the Group
-            '''
+            """
             if type(name) in STRTYPES and len(name) > 0:
                 self.__name = name
             else:
                 self.__name = None
-        
+
         return property(**locals())
-        
-        
-        
+
+
+
     # Colors property
     @apply
     def colors():
-        doc = '''
+        doc = """
         >>> s = Series()
         >>> s.colors = [[1,1,1],[2,2,2,'linear'],[3,3,3,'gradient']]
         >>> print s.colors
@@ -825,33 +825,33 @@
         >>> s.colors = {'a':[1,1,1],'b':(2,2,2,'solid'),'c':(3,3,3,'linear'), 'd':(4,4,4)}
         >>> print s.colors
         {'a': [1, 1, 1, 'solid'], 'c': [3, 3, 3, 'linear'], 'b': [2, 2, 2, 'solid'], 'd': [4, 4, 4, 'solid']}
-        '''
+        """
         def fget(self):
-            '''
+            """
                 Return the color list
-            '''
+            """
             return self.__colors.color_list
-        
+
         def fset(self, colors):
-            '''
+            """
                 Format the color list to a dictionary
-            '''
+            """
             self.__colors = Colors(colors)
-        
+
         return property(**locals())
-        
+
     @apply
     def range():
-        doc = '''
+        doc = """
             The range is a read/write property that generates a range of values
             for the x axis of the functions. When passed a tuple it almost works
             like the built-in range funtion:
              - 1 item, represent the end of the range started from 0;
              - 2 items, represents the start and the end, respectively;
              - 3 items, the last one represents the step;
-             
+
             When passed a list the range function understands as a valid range.
-            
+
             Usage:
             >>> s = Series(); s.range = 10; print s.range
             [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
@@ -866,21 +866,21 @@
             [0.0]
             >>> s = Series(); s.range = [0,10,20]; print s.range
             [0.0, 10.0, 20.0]
-        '''
+        """
         def fget(self):
-            '''
+            """
                 Returns the range
-            '''
+            """
             return self.__range
-        
+
         def fset(self, x_range):
-            '''
+            """
                 Controls the input of a valid type and generate the range
-            '''
+            """
             # if passed a simple number convert to tuple
             if type(x_range) in NUMTYPES:
                 x_range = (x_range,)
-            
+
             # A list, just convert to float
             if type(x_range) is list and len(x_range) > 0:
                 # Convert all to float
@@ -889,32 +889,32 @@
                 self.__range = list(set(x_range[:]))
                 # Sort the list to ascending order
                 self.__range.sort()
-            
+
             # A tuple, must check the lengths and generate the values
             elif type(x_range) is tuple and len(x_range) in (1,2,3):
                 # Convert all to float
                 x_range = map(float, x_range)
-                
+
                 # Inital values
                 start = 0.0
                 step = 1.0
                 end = 0.0
-                
+
                 # Only the end and it can't be less or iqual to 0
                 if len(x_range) is 1 and x_range > 0:
                         end = x_range[0]
-                
+
                 # The start and the end but the start must be lesser then the end
                 elif len(x_range) is 2 and x_range[0] < x_range[1]:
                         start = x_range[0]
                         end = x_range[1]
-                
+
                 # All 3, but the start must be lesser then the end
                 elif x_range[0] < x_range[1]:
                         start = x_range[0]
                         end = x_range[1]
                         step = x_range[2]
-                
+
                 # Starts the range
                 self.__range = []
                 # Generate the range
@@ -922,16 +922,16 @@
                 while start <= end:
                     self.__range.append(start)
                     start += step
-                
+
             # Incorrect type
             else:
                 raise Exception, "x_range must be a list with one or more item or a tuple with 2 or 3 items"
-            
+
         return property(**locals())
-    
+
     @apply
     def group_list():
-        doc = '''
+        doc = """
             The group_list is a read/write property used to pre-process the list
             of Groups.
             It can be:
@@ -952,7 +952,7 @@
                (coordinated lists) or lambdas
              - an instance of Data;
              - an instance of group.
-             
+
             Usage:
             >>> s = Series()
             >>> s.group_list = [1,2,3,4]; print s
@@ -985,48 +985,48 @@
             ["Group 1 ['d1: 1']"]
             >>> s.group_list = Group([(1,2),(2,3)],'g1'); print s
             ["g1 ['(1, 2)', '(2, 3)']"]
-        '''
+        """
         def fget(self):
-            '''
+            """
                 Return the group list.
-            '''
+            """
             return self.__group_list
-        
+
         def fset(self, series):
-            '''
+            """
                 Controls the input of a valid group list.
-            '''
+            """
             #TODO: Add support to the following strem of data: [ (0.5,5.5) , [(0,4),(6,8)] , (5.5,7) , (7,9)]
-            
+
             # Type: None
             if series is None:
                 self.__group_list = []
-            
+
             # List or Tuple
             elif type(series) in LISTTYPES:
                 self.__group_list = []
-                
+
                 is_function = lambda x: callable(x)
                 # Groups
                 if list in map(type, series) or max(map(is_function, series)):
                     for group in series:
                         self.add_group(group)
-                        
+
                 # single group
                 else:
                     self.add_group(series)
-                
+
                 #old code
                 ## List of numbers
                 #if type(series[0]) in NUMTYPES or type(series[0]) is tuple:
                 #    print series
                 #    self.add_group(series)
-                #    
+                #
                 ## List of anything else
                 #else:
                 #    for group in series:
                 #        self.add_group(group)
-            
+
             # Dict representing series of groups
             elif type(series) is dict:
                 self.__group_list = []
@@ -1034,72 +1034,72 @@
                 names.sort()
                 for name in names:
                     self.add_group(Group(series[name],name,self))
-                    
+
             # A single lambda
             elif callable(series):
                 self.__group_list = []
                 self.add_group(series)
-                
+
             # Int/float, instance of Group or Data
             elif type(series) in NUMTYPES or isinstance(series, Group) or isinstance(series, Data):
                 self.__group_list = []
                 self.add_group(series)
-                
+
             # Default
             else:
                 raise TypeError, "Serie type not supported"
 
         return property(**locals())
-    
+
     def add_group(self, group, name=None):
-        '''
+        """
             Append a new group in group_list
-        '''
+        """
         if not isinstance(group, Group):
             #Try to convert
             group = Group(group, name, self)
-            
+
         if len(group.data_list) is not 0:
             # Auto naming groups
             if group.name is None:
                 group.name = "Group "+str(len(self.__group_list)+1)
-            
+
             self.__group_list.append(group)
             self.__group_list[-1].parent = self
-            
+
     def copy(self):
-        '''
+        """
             Returns a copy of the Series
-        '''
+        """
         new_series = Series()
         new_series.__name = self.__name
         if self.__range is not None:
             new_series.__range = self.__range[:]
         #Add color property in the copy method
         #self.__colors = None
-        
+
         for group in self:
             new_series.add_group(group.copy())
-            
+
         return new_series
-    
+
     def get_names(self):
-        '''
+        """
             Returns a list of the names of all groups in the Serie
-        '''
+        """
         names = []
         for group in self:
             if group.name is None:
                 names.append('Group '+str(group.index()+1))
             else:
                 names.append(group.name)
-                
+
         return names
-        
+
     def to_list(self):
-        '''
+        """
             Returns a list with the content of all groups and data
-        '''
+        """
         big_list = []
         for group in self:
             for data in group:
@@ -1110,15 +1110,15 @@
         return big_list
 
     def __getitem__(self, key):
-        '''
+        """
             Makes the Series iterable, based in the group_list property
-        '''
+        """
         return self.__group_list[key]
-        
+
     def __str__(self):
-        '''
+        """
             Returns a string that represents the Series
-        '''
+        """
         ret = ""
         if self.name is not None:
             ret += self.name + " "
@@ -1128,13 +1128,13 @@
         else:
             ret += "[]"
         return ret
-    
+
     def __len__(self):
-        '''
+        """
             Returns the length of the Series, based in the group_lsit property
-        '''
+        """
         return len(self.group_list)
-    
+
 
 if __name__ == '__main__':
     doctest.testmod()

=== added file 'trunk/gtktests.py'
--- trunk/gtktests.py	1970-01-01 00:00:00 +0000
+++ trunk/gtktests.py	2010-04-07 05:06:25 +0000
@@ -0,0 +1,32 @@
+
+import gtk
+import cairoplot
+from cairoplot.handlers.gtk import GTKHandler
+
+class CairoPlotWindow(gtk.Window):
+    """GtkWindow to display a plot."""
+
+    def __init__(self):
+        """Make a plot to test."""
+        gtk.Window.__init__(self)
+        self.connect("destroy", gtk.main_quit)
+
+        # make plot handler
+        handler = GTKHandler()
+
+        # default data
+        data = [ (-2,10), (0,0), (0,15), (1,5), (2,0), (3,-10), (3,5) ]
+        plot = cairoplot.ScatterPlot(handler, data=data,
+                width=500, height=500, background="white",
+                border=20, axis=True, grid=True)
+        
+        handler.plot = plot
+        self.add(handler)
+        handler.show()
+
+
+if __name__ == "__main__":
+    window = CairoPlotWindow()
+    window.show()
+    gtk.main()
+

=== modified file 'trunk/seriestests.py'
--- trunk/seriestests.py	2009-07-09 21:57:24 +0000
+++ trunk/seriestests.py	2010-04-07 05:06:25 +0000
@@ -1,7 +1,7 @@
 import cairo, math, random
 
 import cairoplot
-from series import Series
+from cairoplot.series import Series
 
 # Line plotting
 test_scatter_plot = 1