mapnik 0.2.0

data/ext/ruby_mapnik/_mapnik_raster_colorizer.rb.h

@@ -0,0 +1,32 @@
+/*****************************************************************************
+Copyright (C) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the ‘Software’), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+ *****************************************************************************/
+#ifndef PIKA2_MAPNIK_RASTER_COLORIZER
+#define PIKA2_MAPNIK_RASTER_COLORIZER
+
+namespace Rice
+{
+ class Module; 
+}
+
+void register_raster_colorizer(Rice::Module rb_mapnik);
+
+#endif

data/ext/ruby_mapnik/_mapnik_raster_symbolizer.rb.cpp

@@ -0,0 +1,87 @@
+/*****************************************************************************
+Copyright (C) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the ‘Software’), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+ *****************************************************************************/
+#include "_mapnik_raster_symbolizer.rb.h"
+
+// Rice
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Class.hpp>
+#include <rice/Enum.hpp>
+
+// Mapnik
+#include <mapnik/version.hpp>
+#include <mapnik/raster_symbolizer.hpp>
+
+#if MAPNIK_VERSION >= 200100
+  #include <mapnik/image_scaling.hpp>
+#endif
+
+void register_raster_symbolizer(Rice::Module rb_mapnik){
+
+#if MAPNIK_VERSION >= 200100  
+  Rice::Enum<mapnik::scaling_method_e> scaling_enum = Rice::define_enum<mapnik::scaling_method_e>("ScalingMethod", rb_mapnik);
+  
+  scaling_enum.define_value("NEAR",mapnik::SCALING_NEAR);
+  scaling_enum.define_value("BILINEAR",mapnik::SCALING_BILINEAR);
+  scaling_enum.define_value("BICUBIC", mapnik::SCALING_BICUBIC);
+  scaling_enum.define_value("SPLINE16", mapnik::SCALING_SPLINE16);
+  scaling_enum.define_value("SPLINE36", mapnik::SCALING_SPLINE36);
+  scaling_enum.define_value("HANNING", mapnik::SCALING_HANNING);
+  scaling_enum.define_value("HAMMING", mapnik::SCALING_HAMMING);
+  scaling_enum.define_value("HERMITE", mapnik::SCALING_HERMITE);
+  scaling_enum.define_value("KAISER", mapnik::SCALING_KAISER);
+  scaling_enum.define_value("QUADRIC", mapnik::SCALING_QUADRIC);
+  scaling_enum.define_value("CATROM", mapnik::SCALING_CATROM);
+  scaling_enum.define_value("GAUSSIAN", mapnik::SCALING_GAUSSIAN);
+  scaling_enum.define_value("BESSEL", mapnik::SCALING_BESSEL);
+  scaling_enum.define_value("MITCHELL", mapnik::SCALING_MITCHELL);
+  scaling_enum.define_value("SINC", mapnik::SCALING_SINC);
+  scaling_enum.define_value("LANCZOS", mapnik::SCALING_LANCZOS);
+  scaling_enum.define_value("BLACKMAN", mapnik::SCALING_BLACKMAN);
+  scaling_enum.define_value("BILINEAR8", mapnik::SCALING_BILINEAR8);
+#endif
+
+  /*  
+    @@Module_var rb_mapnik = Mapnik
+  */
+  Rice::Data_Type< mapnik::raster_symbolizer > rb_craster_symbolizer = Rice::define_class_under< mapnik::raster_symbolizer >(rb_mapnik, "RasterSymbolizer");
+  rb_craster_symbolizer.define_constructor(Rice::Constructor< mapnik::raster_symbolizer >());
+  
+  rb_craster_symbolizer.define_method("mode", &mapnik::raster_symbolizer::get_mode);
+  rb_craster_symbolizer.define_method("mode=", &mapnik::raster_symbolizer::set_mode);
+
+#if MAPNIK_VERSION >= 200100
+  rb_craster_symbolizer.define_method("scaling", &mapnik::raster_symbolizer::get_scaling_method);
+  rb_craster_symbolizer.define_method("scaling=", &mapnik::raster_symbolizer::set_scaling_method);
+#else
+  rb_craster_symbolizer.define_method("scaling", &mapnik::raster_symbolizer::get_scaling);
+  rb_craster_symbolizer.define_method("scaling=", &mapnik::raster_symbolizer::set_scaling);
+#endif
+
+  rb_craster_symbolizer.define_method("opacity", &mapnik::raster_symbolizer::get_opacity);
+  rb_craster_symbolizer.define_method("opacity=", &mapnik::raster_symbolizer::set_opacity);
+  
+  
+  rb_craster_symbolizer.define_method("filter_factor", &mapnik::raster_symbolizer::get_filter_factor);
+  rb_craster_symbolizer.define_method("filter_factor=", &mapnik::raster_symbolizer::set_filter_factor);
+  
+}

data/ext/ruby_mapnik/_mapnik_raster_symbolizer.rb.h

@@ -0,0 +1,32 @@
+/*****************************************************************************
+Copyright (C) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the ‘Software’), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+ *****************************************************************************/
+#ifndef PIKA2_MAPNIK_RASTER_SYMBOLIZER
+#define PIKA2_MAPNIK_RASTER_SYMBOLIZER
+
+namespace Rice
+{
+ class Module; 
+}
+
+void register_raster_symbolizer(Rice::Module rb_mapnik);
+
+#endif

data/ext/ruby_mapnik/_mapnik_rule.rb.cpp

@@ -0,0 +1,69 @@
+#include "_mapnik_rule.rb.h"
+
+// Rice
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Class.hpp>
+#include <rice/Array.hpp>
+
+// Mapnik
+#include <mapnik/rule.hpp>
+
+template<>
+Rice::Object to_ruby<std::vector<mapnik::symbolizer> >(std::vector<mapnik::symbolizer> const & x)
+{
+  return Rice::Array(x.begin(), x.end());
+}
+
+void register_rule(Rice::Module rb_mapnik){
+  /*
+    @@Module_var rb_mapnik = Mapnik
+  */
+  Rice::Data_Type< mapnik::rule > rb_crule = Rice::define_class_under< mapnik::rule >(rb_mapnik, "Rule");
+  
+  /*
+  * Document-method: new
+  * @return [Mapnik::Rule]
+  */
+  rb_crule.define_constructor(Rice::Constructor< mapnik::rule >());
+  
+  /*
+  * Document-method: name
+  * @return [String]
+  */
+  rb_crule.define_method("name", &mapnik::rule::get_name);
+  
+  /*
+  * Document-method: name=
+  * call-seq:
+  *   name=(new_name)
+  * @param [String]
+  * @return [nil]
+  */
+  rb_crule.define_method("name=", &mapnik::rule::set_name, Rice::Arg("new_name"));
+    
+  /*
+  * Document-method: filter
+  * @return [Mapnik::Expression]
+  */
+  rb_crule.define_method("filter", &mapnik::rule::get_filter);
+  
+  /*
+  * Document-method: filter=
+  * call-seq:
+  *   filter=(new_filter)
+  * @param [Mapnik::Expression]
+  * @return [nil]
+  */
+  rb_crule.define_method("filter=", &mapnik::rule::set_filter, Rice::Arg("new_filter"));
+
+  // Dont-Document-method: __symbols__
+  rb_crule.define_method("__symbols__", &mapnik::rule::get_symbolizers);
+  
+  // Dont-Document-method: __append_symbol__
+  rb_crule.define_method("__append_symbol__", &mapnik::rule::append, Rice::Arg("new_symbol"));
+  
+  // Dont-Document-method: __remove_symbol__
+  rb_crule.define_method("__remove_symbol__", &mapnik::rule::remove_at, Rice::Arg("index"));
+  
+}

data/ext/ruby_mapnik/_mapnik_rule.rb.h

@@ -0,0 +1,32 @@
+/*****************************************************************************
+Copyright (C) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the ‘Software’), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+ *****************************************************************************/
+#ifndef PIKA2_MAPNIK_RULE
+#define PIKA2_MAPNIK_RULE
+
+namespace Rice
+{
+ class Module; 
+}
+
+void register_rule(Rice::Module rb_mapnik);
+
+#endif

data/ext/ruby_mapnik/_mapnik_shield_symbolizer.rb.cpp

@@ -0,0 +1,86 @@
+/*****************************************************************************
+Copyright (C) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the ‘Software’), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+ *****************************************************************************/
+#include "_mapnik_shield_symbolizer.rb.h"
+
+// Rice
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Class.hpp>
+#include <rice/Enum.hpp>
+
+// Mapnik
+#include <mapnik/text_symbolizer.hpp>  
+#include <mapnik/shield_symbolizer.hpp>
+
+namespace{
+
+  Rice::Object get_shield_displacement(const mapnik::shield_symbolizer& t){
+    mapnik::position pos = t.get_shield_displacement();
+    Rice::Array out;
+    out.push(pos.first);
+    out.push(pos.second);
+    return out;
+  }
+
+  void set_shield_displacement(mapnik::shield_symbolizer & t, Rice::Array ary){
+    double x = from_ruby<double>(ary[0]);
+    double y = from_ruby<double>(ary[1]);
+    t.set_shield_displacement(x,y);
+  }
+
+}
+void register_shield_symbolizer(Rice::Module rb_mapnik){  
+  /*
+    @@Module_var rb_mapnik = Mapnik
+  */
+  Rice::Data_Type< mapnik::shield_symbolizer > rb_cshield_symbolizer = Rice::define_class_under< mapnik::shield_symbolizer, mapnik::text_symbolizer >(rb_mapnik, "ShieldSymbolizer");
+  
+  /*
+  * Document-method: new
+  * call-seq:
+  *   new(expression, face_name, size, color, file)
+  *
+  * @param [Mapnik::Expression] expression
+  * @param [String] face_name
+  * @param [Integer] size
+  * @param [Mapnik::Color] color
+  * @param [Mapnik::PathExpression] file
+  *
+  * @return [Mapnik::ShieldSymbolizer]
+  */
+  rb_cshield_symbolizer.define_constructor(Rice::Constructor< mapnik::shield_symbolizer, mapnik::expression_ptr, std::string, unsigned, mapnik::color, mapnik::path_expression_ptr >());  
+  
+  /*
+  * Document-method: shield_displacement
+  * @return [Array] Two element array [x,y]
+  */
+  rb_cshield_symbolizer.define_method("shield_displacement", &get_shield_displacement);
+  
+  /*
+  * Document-method: shield_displacement=
+  * call-seq:
+  *   shield_displacement=(new_displacement)
+  * @param [Array] new_displacement Two element array [x,y]
+  */
+  rb_cshield_symbolizer.define_method("shield_displacement=", &set_shield_displacement);
+  
+}

data/ext/ruby_mapnik/_mapnik_shield_symbolizer.rb.h

@@ -0,0 +1,32 @@
+/*****************************************************************************
+Copyright (C) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the ‘Software’), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+ *****************************************************************************/
+#ifndef PIKA2_MAPNIK_SHIELD_SYMBOLIZER
+#define PIKA2_MAPNIK_SHIELD_SYMBOLIZER
+
+namespace Rice
+{
+ class Module; 
+}
+
+void register_shield_symbolizer(Rice::Module rb_mapnik);
+
+#endif

data/ext/ruby_mapnik/_mapnik_stroke.rb.cpp

@@ -0,0 +1,188 @@
+/*****************************************************************************
+Copyright (C) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the ‘Software’), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+ *****************************************************************************/
+#include "_mapnik_stroke.rb.h"
+
+// Rice
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Class.hpp>
+#include <rice/Enum.hpp>
+#include <rice/Array.hpp>
+#include <rice/Hash.hpp>
+#include <rice/Symbol.hpp>
+
+// Mapnik
+#include <mapnik/stroke.hpp>
+
+namespace {
+  
+  Rice::Object get_dashes(const mapnik::stroke& stroke){
+    Rice::Array out;
+    if (stroke.has_dash()) {
+        mapnik::dash_array const& dash = stroke.get_dash_array();
+        mapnik::dash_array::const_iterator iter = dash.begin();
+        mapnik::dash_array::const_iterator end = dash.end();
+        for (; iter != end; ++iter) {
+          Rice::Array tuple;
+          tuple.push(iter->first);
+          tuple.push(iter->second);
+          out.push(tuple);
+        }
+    } 
+    return out;
+  }
+
+  mapnik::line_cap_enum get_stroke_line_cap(mapnik::stroke const & self){
+    mapnik::line_cap_enum line_cap = self.get_line_cap();
+    return line_cap;
+  }
+
+  void set_stroke_line_cap(mapnik::stroke & self, mapnik::line_cap_enum val){
+    self.set_line_cap(val);
+  }
+
+  mapnik::line_join_enum get_stroke_line_join(mapnik::stroke const & self){
+    mapnik::line_join_enum line_join = self.get_line_join();
+    return line_join;
+  }
+
+  void set_stroke_line_join(mapnik::stroke & self, mapnik::line_join_enum val){
+    self.set_line_join(val);
+  }
+
+}
+
+void register_stroke(Rice::Module rb_mapnik){
+  /*
+    @@Module_var rb_mapnik = Mapnik
+  */
+  Rice::Data_Type< mapnik::stroke > rb_cstroke = Rice::define_class_under< mapnik::stroke >(rb_mapnik, "Stroke");
+  
+  /*
+  * Document-method: new
+  * call-seq:
+  *   new(color, width)
+  * @param [Mapnik::Color] color
+  * @param [Float] width
+  *
+  * @return [Mapnik::Stroke] 
+  */
+  rb_cstroke.define_constructor(Rice::Constructor< mapnik::stroke, mapnik::color, float >());
+  
+  /*
+  * Document-method: color
+  * @return [Mapnik::Color]
+  */
+  rb_cstroke.define_method("color", &mapnik::stroke::get_color);
+  
+  /*
+  * Document-method: color=
+  * call-seq:
+  *   color=(color)
+  * @param [Mapnik::Color] color
+  * @return [nil]
+  */
+  rb_cstroke.define_method("color=", &mapnik::stroke::set_color, Rice::Arg("new_color"));
+  
+  /*
+  * Document-method: opacity
+  * @return [Float]
+  */
+  rb_cstroke.define_method("opacity", &mapnik::stroke::get_opacity);
+  
+  /*
+  * Document-method: opacity=
+  * call-seq:
+  *   opactiy=(new_value)
+  * @param [Float] new_value
+  * @return [nil]
+  */
+  rb_cstroke.define_method("opacity=", &mapnik::stroke::set_opacity, Rice::Arg("new_opacity"));
+  
+  /*
+  * Document-method: gamma
+  * @return [Float]
+  */
+  rb_cstroke.define_method("gamma", &mapnik::stroke::get_gamma);
+  
+  /*
+  * Document-method: gamma=
+  * call-seq:
+  *   gamma=(new_value)
+  * @param [Float] new_value
+  * @return [nil]
+  */
+  rb_cstroke.define_method("gamma=", &mapnik::stroke::set_gamma, Rice::Arg("new_gamma"));
+  
+  /*
+  * Document-method: width
+  * @return [Float]
+  */
+  rb_cstroke.define_method("width", &mapnik::stroke::get_width);
+  
+  /*
+  * Document-method: width=
+  * call-seq:
+  *   width=(new_value)
+  * @param [Float] new_value
+  * @return [nil]
+  */
+  rb_cstroke.define_method("width=", &mapnik::stroke::set_width, Rice::Arg("new_width"));
+
+  /*
+  * Document-method: dash_offset
+  * @return [Float]
+  */
+  rb_cstroke.define_method("dash_offset", &mapnik::stroke::dash_offset);
+  
+  /*
+  * Document-method: dash_offset=
+  * call-seq:
+  *   dash_offset=(new_value)
+  * @param [Float] new_value
+  * @return [nil]
+  */
+  rb_cstroke.define_method("dash_offset=", &mapnik::stroke::set_dash_offset, Rice::Arg("new_dash_offset"));
+
+  rb_cstroke.define_method("line_cap", &get_stroke_line_cap);
+  rb_cstroke.define_method("line_cap=", &set_stroke_line_cap);
+  
+  rb_cstroke.define_method("line_join", &get_stroke_line_join);
+  rb_cstroke.define_method("line_join=", &set_stroke_line_join);
+  
+  // Dont-Document-method: __dashes__
+  rb_cstroke.define_method("__dashes__", &get_dashes);
+  
+  // Dont-Document-method: __add_dash__
+  rb_cstroke.define_method("__add_dash__", &mapnik::stroke::add_dash);
+
+  Rice::Enum<mapnik::line_cap_enum> rb_eline_cap_enum = Rice::define_enum<mapnik::line_cap_enum>("LineCap", rb_mapnik);
+  rb_eline_cap_enum.define_value("BUTT_CAP", mapnik::BUTT_CAP);
+  rb_eline_cap_enum.define_value("SQUARE_CAP", mapnik::SQUARE_CAP);
+  rb_eline_cap_enum.define_value("ROUND_CAP", mapnik::ROUND_CAP);
+ 
+  Rice::Enum<mapnik::line_join_enum> rb_eline_join_enum = Rice::define_enum<mapnik::line_join_enum>("LineJoin", rb_mapnik);
+  rb_eline_join_enum.define_value("MITER_JOIN", mapnik::MITER_JOIN);
+  rb_eline_join_enum.define_value("MITER_REVERT_JOIN", mapnik::MITER_REVERT_JOIN);
+  rb_eline_join_enum.define_value("ROUND_JOIN", mapnik::ROUND_JOIN);
+  rb_eline_join_enum.define_value("BEVEL_JOIN", mapnik::BEVEL_JOIN);
+}