User can choose to fill or not tools in 'Shapes' Toolbar

Attributes changed in class ShapesToolbar
Minor changed when using Palettes

3 files changed, 290 insertions, 116 deletions

diff --git a/Area.py b/Area.py
index 8d62654..b9b0131 100644
--- a/Area.py
+++ b/Area.py
@@ -146,6 +146,9 @@ class Area(gtk.DrawingArea):
         
         # Number of sides for regular polygon
         self.polygon_sides = 5
+        
+        # Shapes will be filled or not?
+        self.fill = True
 
     # Create a new backing pixmap of the appropriate size
     def configure_event(self, widget, event):
@@ -251,6 +254,9 @@ class Area(gtk.DrawingArea):
         coords = int(event.x), int(event.y)
         if self.tool == 'text':
             self.d.text(widget,event)
+#         else:
+#             self.janela._textview.hide()
+            
         if not self.selmove or self.tool != 'marquee-rectangular':
             self.oldx = int(event.x)
             self.oldy = int(event.y)
@@ -323,11 +329,13 @@ class Area(gtk.DrawingArea):
                 # ellipse
                 elif self.tool == 'ellipse':
                     self.configure_line(self.line_size)
-                    self.d.circle(widget,coords,True,True)    
+                    #self.d.circle(widget,coords,True,True)
+                    self.d.circle(widget,coords,True,self.fill)
                 # rectangle
                 elif self.tool == 'rectangle':
                     self.configure_line(self.line_size)
-                    self.d.square(widget,coords,True,True)
+                    #self.d.square(widget,coords,True,True)
+                    self.d.square(widget,coords,True,self.fill)
                 # selection
                 elif self.tool == 'marquee-rectangular' and not self.selmove:
                     x1, y1, x2, y2 = self.d.selection(widget,coords,True,False)
@@ -338,36 +346,44 @@ class Area(gtk.DrawingArea):
                 #polygon    
                 elif self.tool == 'polygon':
                     self.configure_line(self.line_size)
-                    self.d.polygon(widget,coords,True,False)
+                    #self.d.polygon(widget,coords,True,False)
+                    self.d.polygon(widget,coords,True,self.fill)
                 #triangle
                 elif self.tool == 'triangle':
                     self.configure_line(self.line_size)
-                    self.d.triangle(widget,coords,True,True)
+                    #self.d.triangle(widget,coords,True,True)
+                    self.d.triangle(widget,coords,True,self.fill)
                 #trapezoid
                 elif self.tool == 'trapezoid':
                     self.configure_line(self.line_size)
-                    self.d.trapezoid(widget,coords,True,True)
+                    #self.d.trapezoid(widget,coords,True,True)
+                    self.d.trapezoid(widget,coords,True,self.fill)
                 #arrow
                 elif self.tool == 'arrow':
                     self.configure_line(self.line_size)
-                    self.d.arrow(widget,coords,True,True)
+                    #self.d.arrow(widget,coords,True,True)
+                    self.d.arrow(widget,coords,True,self.fill)
                 #parallelogram
                 elif self.tool == 'parallelogram':
                     self.configure_line(self.line_size)
-                    self.d.parallelogram(widget,coords,True,True)
+                    #self.d.parallelogram(widget,coords,True,True)
+                    self.d.parallelogram(widget,coords,True,self.fill)
                 #star
                 elif self.tool == 'star':
                     self.configure_line(self.line_size)
-                    self.d.star(widget,coords,True,True)
+                    #self.d.star(widget,coords,True,True)
+                    self.d.star(widget,coords,True,self.fill)
                 #polygon regular
                 elif self.tool == 'polygon_regular':
                     self.configure_line(self.line_size)
                     #n = 7
-                    self.d.polygon_regular(widget,coords,self.polygon_sides,True,True)
+                    #self.d.polygon_regular(widget,coords,self.polygon_sides,True,True)
+                    self.d.polygon_regular(widget,coords,self.polygon_sides,True,self.fill)
                 #Heart
                 elif self.tool == 'heart':
                     self.configure_line(self.line_size)
-                    self.d.heart(widget,coords,True,True)
+                    #self.d.heart(widget,coords,True,True)
+                    self.d.heart(widget,coords,True,self.fill)
 
 
     def mouseup(self,widget,event): 
@@ -389,11 +405,13 @@ class Area(gtk.DrawingArea):
                 self.enableUndo(widget)
             # ellipse
             elif self.tool == 'ellipse':
-                self.d.circle(widget,coords,False,True)
+                #self.d.circle(widget,coords,False,True)
+                self.d.circle(widget,coords,False,self.fill)
                 self.enableUndo(widget)
             # rectangle
             elif self.tool == 'rectangle':
-                self.d.square(widget,coords,False,True)
+                #self.d.square(widget,coords,False,True)
+                self.d.square(widget,coords,False,self.fill)
                 self.enableUndo(widget)
             # selection
             elif self.tool == 'marquee-rectangular':
@@ -416,7 +434,8 @@ class Area(gtk.DrawingArea):
                 self.emit('selected')
             # polygon
             elif self.tool == 'polygon':
-                self.d.polygon(widget, coords, False, False)
+                #self.d.polygon(widget, coords, False, False)
+                self.d.polygon(widget, coords, False, self.fill)
             #to undo pencil
             elif self.tool == 'pencil':
                 widget.queue_draw() 
@@ -429,32 +448,39 @@ class Area(gtk.DrawingArea):
                 self.enableUndo(widget)
             #triangle
             elif self.tool == 'triangle':
-                self.d.triangle(widget,coords,False,True)
+                #self.d.triangle(widget,coords,False,True)
+                self.d.triangle(widget,coords,False,self.fill)
                 self.enableUndo(widget)
             #trapezoid
             elif self.tool == 'trapezoid':
-                self.d.trapezoid(widget,coords,False,True)
+                #self.d.trapezoid(widget,coords,False,True)
+                self.d.trapezoid(widget,coords,False,self.fill)
                 self.enableUndo(widget)
             #arrow
             elif self.tool == 'arrow':
-                self.d.arrow(widget,coords,False,True)
+                #self.d.arrow(widget,coords,False,True)
+                self.d.arrow(widget,coords,False,self.fill)
                 self.enableUndo(widget)
             #parallelogram
             elif self.tool == 'parallelogram':
-                self.d.parallelogram(widget,coords,False,True)
+                #self.d.parallelogram(widget,coords,False,True)
+                self.d.parallelogram(widget,coords,False,self.fill)
                 self.enableUndo(widget)
             #star
             elif self.tool == 'star':
-                self.d.star(widget,coords,False,True)
+                #self.d.star(widget,coords,False,True)
+                self.d.star(widget,coords,False,self.fill)
                 self.enableUndo(widget)
             #polygon regular
             elif self.tool == 'polygon_regular':
                 #n = 7
-                self.d.polygon_regular(widget,coords,self.polygon_sides,False,True)
+                #self.d.polygon_regular(widget,coords,self.polygon_sides,False,True)
+                self.d.polygon_regular(widget,coords,self.polygon_sides,False,self.fill)
                 self.enableUndo(widget)
             #heart
             elif self.tool == 'heart':
-                self.d.heart(widget,coords,False,True)
+                #self.d.heart(widget,coords,False,True)
+                self.d.heart(widget,coords,False,self.fill)
                 self.enableUndo(widget)
 
         if self.tool == 'brush' or self.tool == 'eraser' or self.tool == 'rainbow':
diff --git a/NEWS b/NEWS
index 3b76917..822acdbc 100644
--- a/NEWS
+++ b/NEWS
@@ -1,10 +1,7 @@
 5
 ===
-<<<<<<< .mine
 Added 'Clear' button (alexandre)
-=======
 Modifications on selection and gelection bounds (pekayatt)
->>>>>>> .r96
 Added rainbow effect (andremossinato)
 Side number for regular polygon can be choosen (alexandre)
 New shape available: Heart (andremossinato)
diff --git a/toolbox.py b/toolbox.py
index 9fba643..536070b 100644
--- a/toolbox.py
+++ b/toolbox.py
@@ -600,18 +600,18 @@ class ButtonStrokeColor(gtk.ColorButton):
 
 class ShapesToolbar(gtk.Toolbar):
 
-    _TOOL_SHAPE_ARROW = 'arrow'
-    _TOOL_SHAPE_CURVE = 'curve'
-    _TOOL_SHAPE_ELLIPSE = 'ellipse'
-    _TOOL_SHAPE_FREEFORM = 'freeform'
-    _TOOL_SHAPE_HEART = 'heart'
-    _TOOL_SHAPE_LINE = 'line'
-    _TOOL_SHAPE_PARALLELOGRAM = 'parallelogram'
-    _TOOL_SHAPE_POLYGON = 'polygon_regular'
-    _TOOL_SHAPE_RECTANGLE = 'rectangle'
-    _TOOL_SHAPE_STAR = 'star'
-    _TOOL_SHAPE_TRAPEZOID = 'trapezoid'
-    _TOOL_SHAPE_TRIANGLE = 'triangle'
+    _SHAPE_ARROW = 'arrow'
+    _SHAPE_CURVE = 'curve'
+    _SHAPE_ELLIPSE = 'ellipse'
+    _SHAPE_FREEFORM = 'freeform'
+    _SHAPE_HEART = 'heart'
+    _SHAPE_LINE = 'line'
+    _SHAPE_PARALLELOGRAM = 'parallelogram'
+    _SHAPE_POLYGON = 'polygon_regular'
+    _SHAPE_RECTANGLE = 'rectangle'
+    _SHAPE_STAR = 'star'
+    _SHAPE_TRAPEZOID = 'trapezoid'
+    _SHAPE_TRIANGLE = 'triangle'
 
     def __init__(self, activity):
         gtk.Toolbar.__init__(self)
@@ -653,85 +653,118 @@ class ShapesToolbar(gtk.Toolbar):
         self.insert(separator, -1)
         separator.show()
 
-        self._tool_shape_ellipse = ToolButton('tool-shape-ellipse')
-        self.insert(self._tool_shape_ellipse, -1)
-        self._tool_shape_ellipse.show()
-        self._tool_shape_ellipse.set_tooltip(_('Ellipse'))
-
-        self._tool_shape_rectangle = ToolButton('tool-shape-rectangle')
-        self.insert(self._tool_shape_rectangle, -1)
-        self._tool_shape_rectangle.show()
-        self._tool_shape_rectangle.set_tooltip(_('Rectangle'))
-
-        self._tool_shape_line = ToolButton('tool-shape-line')
-        self.insert(self._tool_shape_line, -1)
-        self._tool_shape_line.show()
-        self._tool_shape_line.set_tooltip(_('Line'))
-        
-        self._tool_shape_polygon = ToolButton('tool-shape-polygon')
-        self.insert(self._tool_shape_polygon, -1)
-        self._tool_shape_polygon.show()
-        self._tool_shape_polygon.set_tooltip(_('Polygon'))
-#         try:
-        self._configure_palette(self._tool_shape_polygon, self._TOOL_SHAPE_POLYGON)
-#         except:
-#             logging.debug('Could not create palette for Regular Polygon')
+        self._shape_ellipse = ToolButton('tool-shape-ellipse')
+        self.insert(self._shape_ellipse, -1)
+        self._shape_ellipse.show()
+        self._shape_ellipse.set_tooltip(_('Ellipse'))
+        try:
+            self._configure_palette_shape_ellipse()
+        except:
+            logging.debug('Could not create palette for Shape Ellipse')
 
+        self._shape_rectangle = ToolButton('tool-shape-rectangle')
+        self.insert(self._shape_rectangle, -1)
+        self._shape_rectangle.show()
+        self._shape_rectangle.set_tooltip(_('Rectangle'))
+        try:
+            self._configure_palette_shape_rectangle()
+        except:
+            logging.debug('Could not create palette for Shape Ellipse')
+        
+        self._shape_line = ToolButton('tool-shape-line')
+        self.insert(self._shape_line, -1)
+        self._shape_line.show()
+        self._shape_line.set_tooltip(_('Line'))
+        
+        self._shape_polygon = ToolButton('tool-shape-polygon')
+        self.insert(self._shape_polygon, -1)
+        self._shape_polygon.show()
+        self._shape_polygon.set_tooltip(_('Polygon'))
+        try:
+            #self._configure_palette(self._shape_polygon, self._SHAPE_POLYGON)
+            self._configure_palette_shape_polygon()
+        except:
+            logging.debug('Could not create palette for Regular Polygon')
+        
         """
         
-        self._tool_shape_freeform = ToolButton('tool-shape-freeform')
-        self.insert(self._tool_shape_freeform, -1)
-        self._tool_shape_freeform.show()
-        self._tool_shape_freeform.set_tooltip(_('Freeform'))
+        self._shape_freeform = ToolButton('tool-shape-freeform')
+        self.insert(self._shape_freeform, -1)
+        self._shape_freeform.show()
+        self._shape_freeform.set_tooltip(_('Freeform'))
 
         """
 
-        self._tool_shape_heart = ToolButton('tool-shape-heart')
-        self.insert(self._tool_shape_heart, -1)
-        self._tool_shape_heart.show()
-        self._tool_shape_heart.set_tooltip(_('Heart'))
-
-        self._tool_shape_parallelogram = ToolButton('tool-shape-parallelogram')
-        self.insert(self._tool_shape_parallelogram, -1)
-        self._tool_shape_parallelogram.show()
-        self._tool_shape_parallelogram.set_tooltip(_('Parallelogram'))
+        self._shape_heart = ToolButton('tool-shape-heart')
+        self.insert(self._shape_heart, -1)
+        self._shape_heart.show()
+        self._shape_heart.set_tooltip(_('Heart'))
+        try:
+            self._configure_palette_shape_heart()
+        except:
+            logging.debug('Could not create palette for Shape Heart')
+        
 
-        self._tool_shape_arrow = ToolButton('tool-shape-arrow')
-        self.insert(self._tool_shape_arrow, -1)
-        self._tool_shape_arrow.show()
-        self._tool_shape_arrow.set_tooltip(_('Arrow'))
+        self._shape_parallelogram = ToolButton('tool-shape-parallelogram')
+        self.insert(self._shape_parallelogram, -1)
+        self._shape_parallelogram.show()
+        self._shape_parallelogram.set_tooltip(_('Parallelogram'))
+        try:
+            self._configure_palette_shape_parallelogram()
+        except:
+            logging.debug('Could not create palette for Shape Parallelogram')
 
-        self._tool_shape_star = ToolButton('tool-shape-star')
-        self.insert(self._tool_shape_star, -1)
-        self._tool_shape_star.show()
-        self._tool_shape_star.set_tooltip(_('Star'))
+        self._shape_arrow = ToolButton('tool-shape-arrow')
+        self.insert(self._shape_arrow, -1)
+        self._shape_arrow.show()
+        self._shape_arrow.set_tooltip(_('Arrow'))
+        try:
+            self._configure_palette_shape_arrow()
+        except:
+            logging.debug('Could not create palette for Shape Arrow')
 
-        self._tool_shape_trapezoid = ToolButton('tool-shape-trapezoid')
-        self.insert(self._tool_shape_trapezoid, -1)
-        self._tool_shape_trapezoid.show()
-        self._tool_shape_trapezoid.set_tooltip(_('Trapezoid'))
+        self._shape_star = ToolButton('tool-shape-star')
+        self.insert(self._shape_star, -1)
+        self._shape_star.show()
+        self._shape_star.set_tooltip(_('Star'))
+        try:
+            self._configure_palette_shape_star()
+        except:
+            logging.debug('Could not create palette for Shape Star')
 
-        self._tool_shape_triangle = ToolButton('tool-shape-triangle')
-        self.insert(self._tool_shape_triangle, -1)
-        self._tool_shape_triangle.show()
-        self._tool_shape_triangle.set_tooltip(_('Triangle'))
+        self._shape_trapezoid = ToolButton('tool-shape-trapezoid')
+        self.insert(self._shape_trapezoid, -1)
+        self._shape_trapezoid.show()
+        self._shape_trapezoid.set_tooltip(_('Trapezoid'))
+        try:
+            self._configure_palette_shape_trapezoid()
+        except:
+            logging.debug('Could not create palette for Shape Trapezoid')
 
+        self._shape_triangle = ToolButton('tool-shape-triangle')
+        self.insert(self._shape_triangle, -1)
+        self._shape_triangle.show()
+        self._shape_triangle.set_tooltip(_('Triangle'))
+        try:
+            self._configure_palette_shape_triangle()
+        except:
+            logging.debug('Could not create palette for Shape Triangle')
         
         
         self._icon_stroke.connect('clicked', self._on_icon_stroke_clicked)
         self._icon_fill.connect('clicked', self._on_icon_fill_clicked)
 
-        self._tool_shape_arrow.connect('clicked', self.set_tool, self._TOOL_SHAPE_ARROW)
-        self._tool_shape_ellipse.connect('clicked', self.set_tool, self._TOOL_SHAPE_ELLIPSE)
-        #self._tool_shape_freeform.connect('clicked', self.set_tool, self._TOOL_SHAPE_FREEFORM)
-        self._tool_shape_heart.connect('clicked', self.set_tool, self._TOOL_SHAPE_HEART)
-        self._tool_shape_line.connect('clicked', self.set_tool, self._TOOL_SHAPE_LINE)
-        self._tool_shape_parallelogram.connect('clicked', self.set_tool, self._TOOL_SHAPE_PARALLELOGRAM)
-        self._tool_shape_polygon.connect('clicked', self.set_tool, self._TOOL_SHAPE_POLYGON)
-        self._tool_shape_rectangle.connect('clicked', self.set_tool, self._TOOL_SHAPE_RECTANGLE)
-        self._tool_shape_star.connect('clicked', self.set_tool, self._TOOL_SHAPE_STAR)
-        self._tool_shape_trapezoid.connect('clicked', self.set_tool, self._TOOL_SHAPE_TRAPEZOID)
-        self._tool_shape_triangle.connect('clicked', self.set_tool, self._TOOL_SHAPE_TRIANGLE)
+        self._shape_arrow.connect('clicked', self.set_tool, self._SHAPE_ARROW)
+        self._shape_ellipse.connect('clicked', self.set_tool, self._SHAPE_ELLIPSE)
+        #self._shape_freeform.connect('clicked', self.set_tool, self._SHAPE_FREEFORM)
+        self._shape_heart.connect('clicked', self.set_tool, self._SHAPE_HEART)
+        self._shape_line.connect('clicked', self.set_tool, self._SHAPE_LINE)
+        self._shape_parallelogram.connect('clicked', self.set_tool, self._SHAPE_PARALLELOGRAM)
+        self._shape_polygon.connect('clicked', self.set_tool, self._SHAPE_POLYGON)
+        self._shape_rectangle.connect('clicked', self.set_tool, self._SHAPE_RECTANGLE)
+        self._shape_star.connect('clicked', self.set_tool, self._SHAPE_STAR)
+        self._shape_trapezoid.connect('clicked', self.set_tool, self._SHAPE_TRAPEZOID)
+        self._shape_triangle.connect('clicked', self.set_tool, self._SHAPE_TRIANGLE)
     
     def set_tool(self, widget, tool):
         
@@ -773,50 +806,168 @@ class ShapesToolbar(gtk.Toolbar):
         logging.debug('setting a palette for %s', tool)
         
         palette = widget.get_palette()
+        vbox = gtk.VBox()
+        vbox.show()
+        palette.action_bar.pack_start(vbox)
         
         if tool is None:
             logging.debug('Trying to configure Palette, but there is no tool!')
             raise TypeError
             
-        elif tool is self._TOOL_SHAPE_POLYGON:
+        elif tool is self._SHAPE_POLYGON:
             spin = gtk.SpinButton()
             spin.show()
             
+            # When inserted in a Palette, a spinbutton does not display text in black
             black = gtk.gdk.Color(0,0,0)
-            #white = gtk.gdk.Color(255,255,255)
-            
-            #spin.modify_base(gtk.STATE_NORMAL, black)
-            #spin.modify_base(gtk.STATE_ACTIVE, white)
             spin.modify_text(gtk.STATE_NORMAL, black)
             
             # This is where we set restrictions for Regular Polygon:
             # Initial value, minimum value, maximum value, step
             try:
-                initial = self._activity._area.polygon_sides
+                initial = float(self._activity._area.polygon_sides)
             except:
-                initial = 5
-            adj = gtk.Adjustment(float(initial), 3.0, 50.0, 1.0)
+                initial = 5.0
+            adj = gtk.Adjustment(initial, 3.0, 50.0, 1.0)
             spin.set_adjustment(adj)
-            
-            spin.set_numeric(True)            
-            #palette.set_content(spin)
+            spin.set_numeric(True)
             
             frame = gtk.Frame(_('Sides'))
             frame.add(spin)
-            frame.show()          
-            #palette.set_content(frame)
-            
-            vbox = gtk.VBox()
-            vbox.show()
-            palette.action_bar.pack_start(vbox)
+            frame.show()
             
             vbox.pack_start(frame)
             spin.connect('value-changed', self._on_value_changed)
             
+            separator1 = gtk.HSeparator()
+            vbox.pack_start(separator1)
+            separator1.show()
+            
+            checkbutton = gtk.CheckButton(_('Fill'))
+            checkbutton.connect('toggled', self._on_checkbutton_toggled)
+            vbox.pack_start(checkbutton)
+            checkbutton.show()
+            checkbutton.set_active(True)
+            
+            
     def _on_value_changed(self, spinbutton, data=None):
         self._activity._area.polygon_sides = spinbutton.get_value_as_int()
-        self.set_tool(self._tool_shape_polygon, self._TOOL_SHAPE_POLYGON)
+        self.set_tool(self._shape_polygon, self._SHAPE_POLYGON)
+        
+    def _on_fill_checkbutton_toggled(self, checkbutton, button=None):
+        logging.debug('Checkbutton is Active: %s', checkbutton.get_active() )
+        #TODO: this is not connected to any Area method. Should set filling in regular polygon
+        self._activity._area.fill = checkbutton.get_active()
+        try:
+            button.emit('clicked')
+        except:
+            pass
             
+    def _configure_palette_shape_ellipse(self):
+        logging.debug('Creating palette to shape ellipse')
+        self._create_simple_palette(self._shape_ellipse)
+    
+    def _configure_palette_shape_rectangle(self):
+        logging.debug('Creating palette to shape rectangle')
+        self._create_simple_palette(self._shape_rectangle)
+    
+    def _configure_palette_shape_polygon(self):
+        logging.debug('Creating palette to shape polygon')
+        
+        self._create_simple_palette(self._shape_polygon)
+        
+        palette = self._shape_polygon.get_palette()
+        
+        vbox = gtk.VBox()
+        vbox.show()
+        #palette.action_bar.pack_start(vbox)
+        #palette.set_content(vbox)
+        
+        spin = gtk.SpinButton()
+        spin.show()
+        
+        # When inserted in a Palette, a spinbutton does not display text in black
+        black = gtk.gdk.Color(0,0,0)
+        spin.modify_text(gtk.STATE_NORMAL, black)
+        
+        # This is where we set restrictions for Regular Polygon:
+        # Initial value, minimum value, maximum value, step
+        try:
+            initial = float(self._activity._area.polygon_sides)
+        except:
+            initial = 5.0
+        adj = gtk.Adjustment(initial, 3.0, 50.0, 1.0)
+        spin.set_adjustment(adj)
+        spin.set_numeric(True)
+        
+#         separator1 = gtk.HSeparator()
+#         vbox.pack_start(separator1)
+#         separator1.show()
+        
+        frame = gtk.Frame(_('Sides'))
+        frame.add(spin)
+        frame.show()
+        
+        #vbox.pack_start(frame)
+        palette.set_content(frame)
+        spin.connect('value-changed', self._on_value_changed)
+        
+        
+        
+    def _configure_palette_shape_heart(self):
+        logging.debug('Creating palette to shape heart')
+        self._create_simple_palette(self._shape_heart)
+    
+    def _configure_palette_shape_parallelogram(self):
+        logging.debug('Creating palette to shape parallelogram')
+        self._create_simple_palette(self._shape_parallelogram)
+    
+    def _configure_palette_shape_arrow(self):
+        logging.debug('Creating palette to shape arrow')
+        self._create_simple_palette(self._shape_arrow)
+    
+    def _configure_palette_shape_star(self):
+        logging.debug('Creating palette to shape star')
+        self._create_simple_palette(self._shape_star)
+    
+    def _configure_palette_shape_trapezoid(self):
+        logging.debug('Creating palette to shape trapezoid')
+        self._create_simple_palette(self._shape_trapezoid)
+    
+    def _configure_palette_shape_triangle(self):
+        logging.debug('Creating palette to shape triangle')
+        self._create_simple_palette(self._shape_triangle)
+    
+    def _create_simple_palette(self, button):
+        '''
+        Create a simple palette with an CheckButton named "Fill". Most tools use only this.
+        Keyword arguments:
+        widget -- a ToolButton to associate the palette.
+        '''
+        palette = button.get_palette()
+        
+        fill_checkbutton = gtk.CheckButton(_('Fill'))
+        fill_checkbutton.show()
+        fill_checkbutton.set_active(self._activity._area.fill)
+        
+        fill_checkbutton.connect('toggled', self._on_fill_checkbutton_toggled, button)
+        
+        fill_checkbutton.connect('map', self._on_fill_checkbutton_map)
+#         widget.connect_after('clicked', self._on_fill_checkbutton_after_clicked, fill_checkbutton)
+        
+        palette.set_content(fill_checkbutton)
+    
+    def _on_fill_checkbutton_map(self, checkbutton, data=None):
+        '''
+        Update checkbutton condition to agree with Area.Area object; this prevents tools to have fill checked but be drawed not filled.
+        '''
+        self._activity._area.fill = checkbutton.get_active()
+    
+#     def _on_fill_checkbutton_after_clicked(self, widget, checkbutton):
+#         # Trying to prevent same condition described at self._on_fill_checkbutton_map
+#         self._activity._area.fill = checkbutton.get_active()
+    
+    
 class TextToolbar(gtk.Toolbar):
 
     _ACTION_TEXT = 'text'