diff --git a/include/fill.hpp b/include/fill.hpp
index 3fbfd39be..b37e50277 100644
--- a/include/fill.hpp
+++ b/include/fill.hpp
@@ -20,7 +20,6 @@
  *
  *****************************************************************************/
 
-
 //$Id$
 
 #ifndef FILL_HPP
@@ -30,7 +29,7 @@ namespace mapnik
 {
     class fill 
     {
-	
+        
     };
 }
 
diff --git a/include/map.hpp b/include/map.hpp
index fda7dae96..ab2287a56 100644
--- a/include/map.hpp
+++ b/include/map.hpp
@@ -34,57 +34,57 @@ namespace mapnik
 
     class MAPNIK_DECL Map
     {
-	friend class boost::serialization::access;
-	template <typename Archive>
-	void serialize(Archive & ar, const unsigned int /*version*/)
-	{
-	    ar  & boost::serialization::make_nvp("width",width_) 
-		& boost::serialization::make_nvp("height",height_) 
-		& boost::serialization::make_nvp("srid",srid_)
-		& boost::serialization::make_nvp("layers",layers_);
-	}
+        friend class boost::serialization::access;
+        template <typename Archive>
+        void serialize(Archive & ar, const unsigned int /*version*/)
+        {
+            ar  & boost::serialization::make_nvp("width",width_) 
+                & boost::serialization::make_nvp("height",height_) 
+                & boost::serialization::make_nvp("srid",srid_)
+                & boost::serialization::make_nvp("layers",layers_);
+        }
 	
-	static const unsigned MIN_MAPSIZE=16;
-	static const unsigned MAX_MAPSIZE=1024;
-	unsigned width_;
-	unsigned height_;
-	int srid_;
-	Color background_;
-	std::map<std::string,feature_type_style> styles_;
-	std::vector<Layer> layers_;
-	Envelope<double> currentExtent_;
+        static const unsigned MIN_MAPSIZE=16;
+        static const unsigned MAX_MAPSIZE=2048;
+        unsigned width_;
+        unsigned height_;
+        int srid_;
+        Color background_;
+        std::map<std::string,feature_type_style> styles_;
+        std::vector<Layer> layers_;
+        Envelope<double> currentExtent_;
+        
     public:
-	Map();
-	Map(int width,int height,int srid=-1);
-	Map(const Map& rhs);
-	Map& operator=(const Map& rhs);
-
-	bool insert_style(std::string const& name,feature_type_style const& style);
-	void remove_style(const std::string& name);
-	feature_type_style const& find_style(std::string const& name) const;
-	size_t layerCount() const;
-	void addLayer(const Layer& l);
-	const Layer& getLayer(size_t index) const;
-	Layer& getLayer(size_t index);
-	void removeLayer(size_t index);
-	std::vector<Layer> const& layers() const;
-	unsigned getWidth() const;
-	unsigned getHeight() const;
-	void setWidth(unsigned width);
-	void setHeight(unsigned height);
-	void resize(unsigned width,unsigned height);
-	int srid() const;
-	void setBackground(const Color& c);
-	const Color& getBackground() const;
-	void zoom(double zoom);
-	void zoomToBox(const Envelope<double>& box);
-	void pan(int x,int y);
-	void pan_and_zoom(int x,int y,double zoom);
-	const Envelope<double>& getCurrentExtent() const;
-	double scale() const;
-	virtual ~Map();
+        Map();
+        Map(int width,int height,int srid=-1);
+        Map(const Map& rhs);
+        Map& operator=(const Map& rhs);        
+        bool insert_style(std::string const& name,feature_type_style const& style);
+        void remove_style(const std::string& name);
+        feature_type_style const& find_style(std::string const& name) const;
+        size_t layerCount() const;
+        void addLayer(const Layer& l);
+        const Layer& getLayer(size_t index) const;
+        Layer& getLayer(size_t index);
+        void removeLayer(size_t index);
+        std::vector<Layer> const& layers() const;
+        unsigned getWidth() const;
+        unsigned getHeight() const;
+        void setWidth(unsigned width);
+        void setHeight(unsigned height);
+        void resize(unsigned width,unsigned height);
+        int srid() const;
+        void setBackground(const Color& c);
+        const Color& getBackground() const;
+        void zoom(double zoom);
+        void zoomToBox(const Envelope<double>& box);
+        void pan(int x,int y);
+        void pan_and_zoom(int x,int y,double zoom);
+        const Envelope<double>& getCurrentExtent() const;
+        double scale() const;
+        virtual ~Map();
     private:
-	void fixAspectRatio();
+        void fixAspectRatio();
     };
 }
 
diff --git a/include/polygon_symbolizer.hpp b/include/polygon_symbolizer.hpp
index 9549e8366..da8bbf32b 100644
--- a/include/polygon_symbolizer.hpp
+++ b/include/polygon_symbolizer.hpp
@@ -31,18 +31,21 @@ namespace mapnik
 {
     struct MAPNIK_DECL polygon_symbolizer
     {
-	polygon_symbolizer(Color const& fill)
-	    : fill_(fill) {}
-	Color const& get_fill() const
-	{
-	    return fill_;
-	}
-	void set_fill(Color const& fill)
-	{
-	    fill_ = fill;
-	}
+        explicit polygon_symbolizer() 
+            : fill_(Color(128,128,128) {}
+
+        polygon_symbolizer(Color const& fill)
+            : fill_(fill) {}
+        Color const& get_fill() const
+        {
+            return fill_;
+        }
+        void set_fill(Color const& fill)
+        {
+            fill_ = fill;
+        }
     private:
-	Color fill_;
+        Color fill_;
     };  
 }
 
diff --git a/include/rule.hpp b/include/rule.hpp
index 36e3154c3..bda8e3c44 100644
--- a/include/rule.hpp
+++ b/include/rule.hpp
@@ -40,52 +40,52 @@
 namespace mapnik
 {
     inline bool operator==(point_symbolizer const& lhs,
-			   point_symbolizer const& rhs)
+                           point_symbolizer const& rhs)
     {
-	return (&lhs == &rhs); 
+        return (&lhs == &rhs); 
     }
     inline bool operator==(line_symbolizer const& lhs,
-			   line_symbolizer const& rhs)
+                           line_symbolizer const& rhs)
     {
-	return (&lhs == &rhs); 
+        return (&lhs == &rhs); 
     }
     inline bool operator==(line_pattern_symbolizer const& lhs,
-			   line_pattern_symbolizer const& rhs)
+                           line_pattern_symbolizer const& rhs)
     {
-	return (&lhs == &rhs); 
+        return (&lhs == &rhs); 
     }
 
     inline bool operator==(polygon_symbolizer const& lhs,
-			   polygon_symbolizer const& rhs)
+                           polygon_symbolizer const& rhs)
     {
-	return (&lhs == &rhs); 
+        return (&lhs == &rhs); 
     }
     
     inline bool operator==(polygon_pattern_symbolizer const& lhs,
-			   polygon_pattern_symbolizer const& rhs)
+                           polygon_pattern_symbolizer const& rhs)
     {
-	return (&lhs == &rhs); 
+        return (&lhs == &rhs); 
     }
     
     inline bool operator==(raster_symbolizer const& lhs,
-			   raster_symbolizer const& rhs)
+                           raster_symbolizer const& rhs)
     {
-	return (&lhs == &rhs); 
+        return (&lhs == &rhs); 
     }
     
     inline bool operator==(text_symbolizer const& lhs,
-			   text_symbolizer const& rhs)
+                           text_symbolizer const& rhs)
     {
-	return (&lhs == &rhs); 
+        return (&lhs == &rhs); 
     }
     
     typedef boost::variant<point_symbolizer,
-			   line_symbolizer,
-			   line_pattern_symbolizer,
-			   polygon_symbolizer,
-			   polygon_pattern_symbolizer,
-			   raster_symbolizer,
-			   text_symbolizer> symbolizer;
+                           line_symbolizer,
+                           line_pattern_symbolizer,
+                           polygon_symbolizer,
+                           polygon_pattern_symbolizer,
+                           raster_symbolizer,
+                           text_symbolizer> symbolizer;
     
         
     typedef std::vector<symbolizer> symbolizers;    
@@ -94,183 +94,183 @@ namespace mapnik
     template <typename FeatureT,template <typename> class Filter>
     class rule
     {
-	typedef Filter<FeatureT> filter_type;
-	typedef boost::shared_ptr<filter_type> filter_ptr;
+        typedef Filter<FeatureT> filter_type;
+        typedef boost::shared_ptr<filter_type> filter_ptr;
     private:
 
-	std::string name_;
-	std::string title_;
-	std::string abstract_;
-	double min_scale_;
-	double max_scale_;
+        std::string name_;
+        std::string title_;
+        std::string abstract_;
+        double min_scale_;
+        double max_scale_;
         symbolizers syms_;
-	filter_ptr filter_;
-	bool else_filter_;
+        filter_ptr filter_;
+        bool else_filter_;
     public:
-	rule()
-	    : name_(),
-	      title_(),
-	      abstract_(),
-	      min_scale_(0),
-	      max_scale_(std::numeric_limits<double>::infinity()),
-	      syms_(),
-	      filter_(new all_filter<FeatureT>),
-	      else_filter_(false) {}
+        rule()
+            : name_(),
+              title_(),
+              abstract_(),
+              min_scale_(0),
+              max_scale_(std::numeric_limits<double>::infinity()),
+              syms_(),
+              filter_(new all_filter<FeatureT>),
+              else_filter_(false) {}
                 
-	rule(const std::string& name,
-	     const std::string& title="",
-	     double min_scale_denominator=0,
-	     double max_scale_denominator=std::numeric_limits<double>::infinity())
-	    : name_(name),
-	      title_(title),
-	      min_scale_(min_scale_denominator),
-	      max_scale_(max_scale_denominator),
-	      syms_(),
-	      filter_(new all_filter<FeatureT>),
-	      else_filter_(false) {}
+        rule(const std::string& name,
+             const std::string& title="",
+             double min_scale_denominator=0,
+             double max_scale_denominator=std::numeric_limits<double>::infinity())
+            : name_(name),
+              title_(title),
+              min_scale_(min_scale_denominator),
+              max_scale_(max_scale_denominator),
+              syms_(),
+              filter_(new all_filter<FeatureT>),
+              else_filter_(false) {}
 	    
-	rule(const rule& rhs)    
-	    : name_(rhs.name_),
-	      title_(rhs.title_),
-	      abstract_(rhs.abstract_),
-	      min_scale_(rhs.min_scale_),
-	      max_scale_(rhs.max_scale_),
-	      syms_(rhs.syms_),
-	      filter_(rhs.filter_),
-	      else_filter_(rhs.else_filter_) {}
+        rule(const rule& rhs)    
+            : name_(rhs.name_),
+              title_(rhs.title_),
+              abstract_(rhs.abstract_),
+              min_scale_(rhs.min_scale_),
+              max_scale_(rhs.max_scale_),
+              syms_(rhs.syms_),
+              filter_(rhs.filter_),
+              else_filter_(rhs.else_filter_) {}
 	
         rule& operator=(rule const& rhs) 
-	{
-	    rule tmp(rhs);
-	    swap(tmp);
-	    return *this;
-	}
-	bool operator==(rule const& other)
-	{
-	    return  (this == &other); 
-	}
+        {
+            rule tmp(rhs);
+            swap(tmp);
+            return *this;
+        }
+        bool operator==(rule const& other)
+        {
+            return  (this == &other); 
+        }
 	
-	void set_max_scale(double scale)
-	{
-	    max_scale_=scale;
-	}
+        void set_max_scale(double scale)
+        {
+            max_scale_=scale;
+        }
 
-	double get_min_scale() const
-	{
-	    return min_scale_;
-	}
+        double get_min_scale() const
+        {
+            return min_scale_;
+        }
 
-	double get_max_scale() const
-	{
-	    return max_scale_;
-	}
+        double get_max_scale() const
+        {
+            return max_scale_;
+        }
 
-	void set_min_scale(double scale)
-	{
-	    min_scale_=scale;
-	}
+        void set_min_scale(double scale)
+        {
+            min_scale_=scale;
+        }
 
-	void set_name(std::string const& name)
-	{
-	    name_=name;
-	}
+        void set_name(std::string const& name)
+        {
+            name_=name;
+        }
 	
-	std::string const& get_name() const
-	{
-	    return name_;
-	}
+        std::string const& get_name() const
+        {
+            return name_;
+        }
 	
-	std::string const& get_title() const
-	{
-	    return  title_;
-	}
+        std::string const& get_title() const
+        {
+            return  title_;
+        }
 
-	void set_title(std::string const& title)
-	{
-	    title_=title;
-	}
+        void set_title(std::string const& title)
+        {
+            title_=title;
+        }
   
-	void set_abstract(std::string const& abstract)
-	{
-	    abstract_=abstract;
-	}
+        void set_abstract(std::string const& abstract)
+        {
+            abstract_=abstract;
+        }
 	
-	std::string const& get_abstract() const
-	{
-	    return abstract_;
-	}
+        std::string const& get_abstract() const
+        {
+            return abstract_;
+        }
 		
-	void append(const symbolizer& sym)
-	{
-	    syms_.push_back(sym);
-	}
+        void append(const symbolizer& sym)
+        {
+            syms_.push_back(sym);
+        }
 	
-	void remove_at(size_t index)
-	{
-	    if (index < syms_.size())
-	    {
-		syms_.erase(syms_.begin()+index);
-	    }
-	}
+        void remove_at(size_t index)
+        {
+            if (index < syms_.size())
+            {
+                syms_.erase(syms_.begin()+index);
+            }
+        }
 	
-	const symbolizers& get_symbolizers() const
-	{
-	    return syms_;
-	}
+        const symbolizers& get_symbolizers() const
+        {
+            return syms_;
+        }
 	
-	symbolizers::const_iterator begin()
-	{
-	    return syms_.begin();
-	}
+        symbolizers::const_iterator begin()
+        {
+            return syms_.begin();
+        }
 	
-	symbolizers::const_iterator end()
-	{
-	    return syms_.end();
-	}
+        symbolizers::const_iterator end()
+        {
+            return syms_.end();
+        }
 	
-	void set_filter(const filter_ptr& filter)
-	{
-	    filter_=filter;
-	}
+        void set_filter(const filter_ptr& filter)
+        {
+            filter_=filter;
+        }
 
-	filter_ptr const& get_filter() const
-	{
-	    return filter_;
-	}
+        filter_ptr const& get_filter() const
+        {
+            return filter_;
+        }
 	
-	void set_else(bool else_filter)
-	{
-	    else_filter_=else_filter;
-	}
+        void set_else(bool else_filter)
+        {
+            else_filter_=else_filter;
+        }
      
-	bool has_else_filter() const
-	{
-	    return else_filter_;
-	}
+        bool has_else_filter() const
+        {
+            return else_filter_;
+        }
         
-	bool active(double scale) const
-	{
-	    return ( scale > min_scale_ && scale < max_scale_ );
-	}
+        bool active(double scale) const
+        {
+            return ( scale > min_scale_ && scale < max_scale_ );
+        }
 
-	void accept(filter_visitor<FeatureT>& v) const
-	{
-	    v.visit(*this);
-	}
+        void accept(filter_visitor<FeatureT>& v) const
+        {
+            v.visit(*this);
+        }
 	
     private:
 	
-	void swap(rule& rhs) throw()
-	{
-	    name_=rhs.name_;
-	    title_=rhs.title_;
-	    abstract_=rhs.abstract_;
-	    min_scale_=rhs.min_scale_;
-	    max_scale_=rhs.max_scale_;
-	    syms_=rhs.syms_;
-	    filter_=rhs.filter_;
-	    else_filter_=rhs.else_filter_;
-	}
+        void swap(rule& rhs) throw()
+        {
+            name_=rhs.name_;
+            title_=rhs.title_;
+            abstract_=rhs.abstract_;
+            min_scale_=rhs.min_scale_;
+            max_scale_=rhs.max_scale_;
+            syms_=rhs.syms_;
+            filter_=rhs.filter_;
+            else_filter_=rhs.else_filter_;
+        }
     };
 
     typedef rule<Feature,filter> rule_type;
diff --git a/include/utils.hpp b/include/utils.hpp
index 8adaccf8f..323727af1 100644
--- a/include/utils.hpp
+++ b/include/utils.hpp
@@ -201,21 +201,21 @@ namespace mapnik
     template <typename T>
     inline std::string toString(const T& x)
     {
-	std::ostringstream o;
-	if (!(o << x))
-	    throw BadConversion(std::string("toString(")
-				+ typeid(x).name() + ")");
-	return o.str();
+        std::ostringstream o;
+        if (!(o << x))
+            throw BadConversion(std::string("toString(")
+                                + typeid(x).name() + ")");
+        return o.str();
     }
     
     template<typename T>
     inline void fromString(const std::string& s, T& x,
-			   bool failIfLeftoverChars = true)
+                           bool failIfLeftoverChars = true)
     {
-	std::istringstream i(s);
-	char c;
-	if (!(i >> x) || (failIfLeftoverChars && i.get(c)))
-	    throw BadConversion("fromString("+s+")");
+        std::istringstream i(s);
+        char c;
+        if (!(i >> x) || (failIfLeftoverChars && i.get(c)))
+            throw BadConversion("fromString("+s+")");
     }
     
     //inline bool space (char c)