ropenlayer 0.0.1 → 0.3.0

data/lib/ropenlayer/acts_as/nodeable.rb

@@ -0,0 +1,109 @@
+module Ropenlayer
+  module ActsAs
+      
+    # acts_as_localizable_on: give to the model facilities to store and draw object in a map.
+    #
+    #   class Team < ActiveRecord::Base
+    #     acts_as_map :default_layer => :google_streets, :nodes => [ :offices ]
+    #   end
+    #
+    #   class Office < ActiveRecord::Base
+    #     belongs_to :team
+    #     acts_as_localizable_on :team
+    #   end
+    #
+    # Avalaible options:
+    #
+    #  All the options can be mapped to a Proc object that will bind self or a Symbol which perform send(:symbol) method.
+    #  - :name, :Name of the point. By default, Just another Element
+    #  - :popup_content:Content of the popup, if set, element will render a popup in click with this xhtml content. by default, is false 
+    #  - :icon_url: Icon url to show, by default, /images/ropenlayer/default_marker.png
+    #  - :color: Background color, by default transparent
+    #
+    # Examples
+    #
+    # Build a Map of the team offices with custom icons
+    #
+    #   # on app/models/team.rb
+    #   class Team < ActiveRecord::Base
+    #     has_many :offices
+    #     acts_as_map :default_layer => :google_streets, :latitude => 40000.23, :longitude => 54555.233, :zoom => 3
+    #                 :nodes => [ :offices ]
+    #   end
+    #
+    #   # on app/models/office.rb
+    #   class Office < ActiveRecord::Base
+    #     belongs_to :team
+    #     acts_as_localizable_on :team, :icon_url      => Proc.new{|o| o.main ? '/images/main_office.png' : '/images/office.png' },
+    #                                   :color         => Proc.new{|o| o.main ? 'red' : 'blue' },
+    #                                   :popup_content => :full_description
+    #
+    #     def full_description
+    #       %( #{ name } - #{ address } )
+    #     end
+    #  end
+    #
+    #
+    # on your view, just
+    #  
+    #   apps/views/offices/index.html
+    # 
+    #   <div id="offices_for_team_map" style="width: 500px; height: 400px;"></div>
+    #   <%= raw @team.ropenlayer_map(:id => 'offices_for_team_map').to_js %>
+    module Nodeable
+      
+      class << self
+        def included(base)
+          
+          base.class_eval do 
+            
+            has_one :node,      :as => :nodeable, :dependent => :destroy, :include => :localizations, :class_name => "Ropenlayer::Node"
+            accepts_nested_attributes_for :node
+        
+            base.send :include, InstanceMethods
+            
+          end
+       end
+        
+       module InstanceMethods
+
+          def node_data
+            attributes_config = self.class.ropenlayer_node_config[:attributes] || {}
+            
+            node_map_attributes   = { }
+            [ :name, :popup_content, :icon_url, :color ].each do |attribute|
+              node_map_attributes[attribute] = eval_node_attribute(attributes_config[attribute]) unless attributes_config[attribute].nil?
+            end
+            
+            if self.node.localizations.any?
+              node_map_attributes[:id]            = self.node.id
+              node_map_attributes[:geometry]      = self.node.geometry
+              node_map_attributes[:longitude]     = self.node.localizations.first.longitude
+              node_map_attributes[:latitude]      = self.node.localizations.first.latitude
+              node_map_attributes[:localizations] = self.node.localizations.map{|l| { :latitude => l.latitude, :longitude => l.longitude }}
+            else
+              node_map_attributes = nil
+            end
+            node_map_attributes
+          end
+
+          def ensure_nodeable_model
+            raise "Model `#{ self.class }` doesnt acts as nodeable" unless self.class.methods.include?("acts_as_nodeable") and self.class.acts_as_nodeable
+          end
+          
+          private
+          def eval_node_attribute(attribute)
+            case attribute
+            when Symbol
+              return self.send(attribute)
+            when Proc
+              return attribute.call(self)
+            else
+              return attribute
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ropenlayer/acts_as.rb

@@ -0,0 +1,138 @@
+module Ropenlayer
+  module ActsAs
+    
+    # acts_as_map: give to the model map construiction and build facilities.
+    #
+    #   class Team < ActiveRecord::Base
+    #     acts_as_map :default_layer => :google_streets
+    #   end
+    #
+    # Avalaible options:
+    #
+    #  - :longitude, :latitude, :zoom : Default starting values for map. Can be a float (latitude, longitude) or integer (zoom) object, so values will be parsed as them are. 
+    #                                   A Symbol, in this case, ropenlayer will send :symbol method to mapper instance, or a valid Proc object
+    #  - :default_layer: Default layer for visualization. For avalaible layers see Ropenlayer::Openlayer::Map 
+    #  - :nodes: Relations which can be pointed on the map. Relations are expected to have acts_as_localizable_on behaviour in their class
+    #
+    # Examples
+    #
+    # Build a Map with static features, just for localization
+    #
+    #   class Team < ActiveRecord::Base
+    #     acts_as_map :default_layer => :google_streets, :latitude => 40000.23, :longitude => 54555.233, :zoom => 3
+    #   end
+    #
+    # Build a Map with Proc calls to perform automatic localization on forms
+    # 
+    #     class Team < ActiveRecord
+    # 
+    #       has_many :offices
+    #       has_one :main_office, :conditions => { :main => true }
+    # 
+    #       acts_as_map :default_layer => :google_streets, :longitude => :main_office_longitude, :latitude => :main_office_latitude, :zoom => :main_office_zoom
+    #                   :nodes         => [ :offices ]
+    # 
+    #       def main_office_longitude
+    #           main_office.longitude
+    #       end
+    # 
+    #       def main_office_longitude=(value)
+    #         main_office_longitude = value
+    #       end
+    # 
+    #       def main_office_latitude
+    #           main_office.latitude
+    #       end
+    # 
+    #       def main_office_latitude=(value)
+    #         main_office.latitude = value
+    #       end
+    # 
+    #       def main_office_longitude
+    #           main_office.longitude
+    #       end
+    # 
+    #       def main_office_zoom=(value)
+    #         main_office.zoom = value
+    #       end
+    # 
+    #     end
+    #
+    def acts_as_map(options = {})
+      
+      class_eval do
+      
+        cattr_reader :acts_as_mapper, :ropenlayer_mapper_config, :localizable
+        
+        send("class_variable_set", "@@acts_as_mapper",    true)
+        send("class_variable_set", "@@ropenlayer_mapper_config", options)
+      
+        include Ropenlayer::ActsAs::Mapper
+
+      end
+    end
+    
+    # acts_as_localizable_on: give to the model facilities to store and draw object in a map.
+    #
+    #   class Team < ActiveRecord::Base
+    #     acts_as_map :default_layer => :google_streets, :nodes => [ :offices ]
+    #   end
+    #
+    #   class Office < ActiveRecord::Base
+    #     belongs_to :team
+    #     acts_as_localizable_on :team
+    #   end
+    #
+    # Avalaible options:
+    #
+    #  All the options can be mapped to a Proc object that will bind self or a Symbol which perform send(:symbol) method.
+    #  - :name, :Name of the point. By default, Just another Element
+    #  - :popup_content:Content of the popup, if set, element will render a popup in click with this xhtml content. by default, is false 
+    #  - :icon_url: Icon url to show, by default, /images/ropenlayer/default_marker.png
+    #  - :color: Background color, by default transparent
+    #
+    # Examples
+    #
+    # Build a Map of the team offices with custom icons
+    #
+    #   # on app/models/team.rb
+    #   class Team < ActiveRecord::Base
+    #     has_many :offices
+    #     acts_as_map :default_layer => :google_streets, :latitude => 40000.23, :longitude => 54555.233, :zoom => 3
+    #                 :nodes => [ :offices ]
+    #   end
+    #
+    #   # on app/models/office.rb
+    #   class Office < ActiveRecord::Base
+    #     belongs_to :team
+    #     acts_as_localizable_on :team, :icon_url      => Proc.new{|o| o.main ? '/images/main_office.png' : '/images/office.png' },
+    #                                   :color         => Proc.new{|o| o.main ? 'red' : 'blue' },
+    #                                   :popup_content => :full_description
+    #
+    #     def full_description
+    #       %( #{ name } - #{ address } )
+    #     end
+    #  end
+    #
+    #
+    # on your view, just
+    #  
+    #   apps/views/offices/index.html
+    # 
+    #   <div id="offices_for_team_map" style="width: 500px; height: 400px;"></div>
+    #   <%= raw @team.ropenlayer_map(:id => 'offices_for_team_map').to_js %>
+    def acts_as_localizable_on(relation, options = {})
+      
+      class_eval do
+        
+        cattr_reader   :acts_as_nodeable
+        cattr_reader   :ropenlayer_node_config
+        
+        send("class_variable_set", "@@acts_as_nodeable",    true)
+        send("class_variable_set", "@@ropenlayer_node_config", options)
+        
+        include Ropenlayer::ActsAs::Nodeable
+      end
+    end
+  end
+end

data/lib/ropenlayer/category.rb

@@ -0,0 +1,14 @@
+module Ropenlayer
+  class Category < ActiveRecord::Base
+    
+    set_table_name    :ropenlayer_categories
+    
+    belongs_to        :mapper, :polymorphic => true
+    
+    #before_save       :ensure_format, Proc.new {|category| category.color.match(/^\#/) ? '' : category.color = "##{ category.color }"   
+
+  end
+  
+  
+  
+end

data/lib/ropenlayer/form_builder.rb

@@ -0,0 +1,69 @@
+module Ropenlayer
+  module FormBuilder
+    
+    def map_localization(options = {}, map_div_options = {})
+      self.object.ensure_mapper_model
+      self.object.ensure_localizable_model
+      
+      klass_config = self.object.class.ropenlayer_mapper_config
+      dom_id_map   = "ropenlayer_#{ @template.params[:action] }_#{ @template.params[:controller] }"
+      
+      map          = self.object.build_map(dom_id_map, klass_config)
+
+      map_div_options.merge!(:id => dom_id_map)
+      
+      return_tag = ''
+      
+      [ :longitude , :latitude, :zoom ].each do |data|
+        id_hidden_value                     = "#{ self.object.class.name.underscore }_#{ klass_config[data] }"
+        map.form_localizations_fields[data] = id_hidden_value
+        return_tag << hidden_field(klass_config[data], :id => id_hidden_value)
+      end
+        
+      
+      return_tag << "#{ @template.content_tag("div", '', map_div_options) } #{ @template.javascript_tag  map.to_js }" 
+      return_tag << localization_helper(map)
+      @template.raw  return_tag 
+    end
+    
+    
+    def map_nodes_editor(mapper_relation, options = {}, map_div_options = {})
+      self.object.ensure_nodeable_model
+      mapper = self.object.send(mapper_relation)
+      mapper.ensure_mapper_model
+      
+      mapper_config   = mapper.class.ropenlayer_mapper_config
+      nodeable_config = self.object.class.ropenlayer_node_config
+      
+      mapper_config.merge!(:edit_map => true)
+      
+      dom_id_map   = "ropenlayer_#{ mapper.class }_#{ @template.params[:action] }_#{ @template.params[:controller] }"
+      map         = mapper.build_map(dom_id_map, mapper_config)
+      
+      map_div_options.merge!(:id => dom_id_map)
+      
+      
+      return_tag = '' 
+      
+      self.object.node ||= self.object.build_node # FIXME has_many relation!
+      
+      self.fields_for :node do |node_form|
+        return_tag << node_form.hidden_field(:geometry_string)
+      end
+      
+      return_tag << @template.javascript_tag("#{ map.js_helper.create_new_feature_callback(map, self) }") unless map.options[:add_feature_callback] != map.class::DEFAULT_ADD_FEATURE_CALLBACK
+      return_tag << "#{ @template.content_tag("div", '', map_div_options) }#{ @template.javascript_tag map.to_js }" 
+      
+      @template.raw  return_tag
+    end
+    
+    
+    private
+    def localization_helper(ropenlayer_object)
+      @template.link_to_function 'Store localization', "a = #{ ropenlayer_object.js_id }.getCenter(); long_dom = getElementById('#{ ropenlayer_object.form_localizations_fields[:longitude] }'); long_dom.value = a['lon']; lat_dom = getElementById('#{ ropenlayer_object.form_localizations_fields[:latitude] }'); lat_dom.value = a['lat']; b =  #{ ropenlayer_object.js_id }.getZoom(); zoom_dom =  getElementById('#{ ropenlayer_object.form_localizations_fields[:zoom] }'); zoom_dom.value = b; #{ ropenlayer_object.js_notification_area }.innerHTML = 'kk'" 
+    end
+
+    
+  end
+end
+    

data/lib/ropenlayer/icon.rb

@@ -0,0 +1,12 @@
+module Ropenlayer
+  class Icon < ActiveRecord::Base
+    
+    set_table_name    :ropenlayer_icons
+    
+    belongs_to        :mapper, :polymorphic => true
+    
+    #has_attached_file :logo, :styles => { :'48' => "48x48", :'64' => "64x64", :'128' => "128x128", :'256' => "256x256" }
+
+  end
+  
+end

data/lib/ropenlayer/js_helper/jquery.rb

@@ -0,0 +1,63 @@
+module Ropenlayer
+  module JsHelper
+    module Jquery
+      
+      def self.create_xhtml_element(element_type, attributes = {})
+
+        inner_html = attributes.delete(:inner_html)
+        
+        
+        js_element = Ropenlayer::Openlayer::Js.new("$('<#{ element_type }")
+        
+        
+        attributes.each do |name, value|
+          if name.to_s.match(/^on/)
+            gsub_value = value.gsub("'","\\\\'")
+          else
+            gsub_value = value.gsub("'","")
+          end
+          
+          js_element.body << %( #{ name }="#{ gsub_value }" )
+          
+        end
+        js_element.body << ">"
+        js_element.body << inner_html.gsub("'","") if inner_html 
+        
+        js_element.body << "</#{ element_type }>')"
+        js_element.to_s
+        end
+      
+      def self.create_new_feature_callback(map, form)
+        Ropenlayer::Openlayer::Js.new("function addFeatureToMap(feature) {
+  
+          total_features = feature.layer.features.length;
+  
+          // Right now, just one feature for node
+          if(total_features > 1) {
+            first_feature =  feature.layer.features[0];
+            feature.layer.removeFeatures(first_feature);
+          }
+          //update_geomtry
+          $('##{ form.object.class.name.underscore  }_node_attributes_geometry_string').attr('value', feature.geometry);
+ 
+          }").to_s
+      end
+      
+      def self.insert_into_xhtml_element(js_element, content)
+        Ropenlayer::Openlayer::Js.new("$(#{ js_element }).append(#{ content })").to_s
+      end
+      
+      def self.update_xhtml_element(js_element, content)
+        Ropenlayer::Openlayer::Js.new("#{ js_element }.innerHTML = #{ content }").to_s
+      end
+      
+      def self.hide_xhtml_element(js_element)
+        Ropenlayer::Openlayer::Js.new("$(#{ js_element }).hide()").to_s
+      end
+             
+      def self.toggle_xhtml_element(js_element)
+        Ropenlayer::Openlayer::Js.new("$(#{ js_element }).toggle()").to_s
+      end
+    end    
+  end
+end

data/lib/ropenlayer/js_helper/prototype.rb

@@ -0,0 +1,51 @@
+module Ropenlayer
+  module JsHelper
+    module Prototype
+      
+      def self.create_xhtml_element(element_type, attributes = {})
+        inner_html     = attributes.delete(:inner_html)
+        
+        return_js      = Ropenlayer::Openlayer::Js.new_method("Element", :args => [ "'#{ element_type }'" ], :propierties => attributes)
+        return_js.body << ".update(#{ inner_html })" if inner_html
+        return_js.to_s
+      end
+      
+     
+      def self.create_new_feature_callback(map, form)
+        Ropenlayer::Openlayer::Js.new("function addFeatureToMap(feature) {
+  
+          total_features = feature.layer.features.size();
+  
+          // Right now, just one feature for node
+          if(total_features > 1) {
+            first_feature =  feature.layer.features.first();
+            feature.layer.removeFeatures(first_feature);
+          }
+          //update_geomtry
+          $('#{ form.object.class.name.underscore  }_node_attributes_geometry_string').value = feature.geometry;
+ 
+          }").to_s
+      end
+      
+      def self.insert_into_xhtml_element(js_element, content)
+        Ropenlayer::Openlayer::Js.new("#{ js_element }.insert(#{ content })").to_s
+      end
+      
+      def self.update_xhtml_element(js_element, content)
+        Ropenlayer::Openlayer::Js.new("#{ js_element }.update(#{ content })").to_s
+      end
+      
+      def self.hide_xhtml_element(js_element)
+        Ropenlayer::Openlayer::Js.new("#{ js_element }.hide()").to_s
+      end
+      
+      def self.toggle_xhtml_element(js_element)
+        Ropenlayer::Openlayer::Js.new("#{ js_element }.toggle()").to_s
+      end
+        
+      
+      
+      
+    end    
+  end
+end

data/lib/ropenlayer/localization.rb

@@ -0,0 +1,6 @@
+module Ropenlayer
+  class Localization < ActiveRecord::Base
+    set_table_name    :ropenlayer_localizations
+    belongs_to        :nodeable, :polymorphic => true
+  end
+end

data/lib/ropenlayer/node.rb

@@ -0,0 +1,38 @@
+module Ropenlayer
+  class Node < ActiveRecord::Base
+    
+    attr_accessor :geometry_string
+    
+    set_table_name :ropenlayer_nodes
+
+    GEOMETRY_TYPES = %w( POINT LINESTRING POLYGON )
+    
+    belongs_to :map,      :polymorphic => true
+    
+    has_many :localizations, :class_name => 'Ropenlayer::Localization'
+    
+    has_one :icon,     :class_name => 'Ropenlayer::Icon'
+    has_one :category, :class_name => 'Ropenlayer::Category'
+    
+   
+    def geometry_string
+      "#{ geometry }(#{ localizations.map{|l| "#{ l.longitude } #{ l.latitude }"}.join(',')})"
+    end
+    
+    def geometry_string=(data)
+      self.geometry       = data.split('(').first
+      localizations_split = data.split('(').last.gsub(')', '').split(',')
+      
+      self.localizations = []
+      order              = 0
+      localizations_split.each do |data|
+        self.localizations << self.localizations.new(:longitude => data.split.first, :latitude => data.split.last, :order => order = order.next)
+      end
+    end
+
+    
+  end
+  
+end
+    
+    

data/lib/ropenlayer/openlayer/box_control/base.rb

@@ -0,0 +1,57 @@
+module Ropenlayer
+  module Openlayer
+    module BoxControl
+      class Base
+        
+        attr_reader :map
+        attr_reader :name
+        attr_reader :js_links_id
+        
+        attr_accessor :links
+
+        
+        def initialize(name, map, options = {})
+          @name          = name
+          @map           = map
+          @links         = []
+          
+          @js_id         = "#{ map.js_id }_#{ name }"
+          @js_control_id = "#{ @js_id }_control" 
+          @js_links_id   = "#{ @js_id }_links" 
+          @js_panel_id   = "#{ @js_id }_panel" 
+          
+          @css_class = options[:css_class] || "olCustomControl#{ @name.camelize }"
+        end
+
+                            
+        def to_js
+          
+          create_links_container   = @map.js_helper.create_xhtml_element("div", { :class => "'#{ @css_class }Links'", :style => "'display: none;'", :id    => "'#{ @js_links_id }'" })
+          create_openlayer_control = Ropenlayer::Openlayer::Js.new_method("OpenLayers.Control.Button", :propierties => { :displayClass => "'#{ @css_class }'",
+                                                                                                                         :trigger      => "function() { #{ @map.js_helper.toggle_xhtml_element(@js_links_id) } }" }).to_s
+          create_openlayer_panel   = Ropenlayer::Openlayer::Js.new_method("OpenLayers.Control.Panel", :propierties => { :displayClass    => "'#{ @css_class }Panel'",
+                                                                                                                         :defaultControl  => "#{ @js_control_id }" }).to_s
+          
+          %( // Adding #{ @name } box control   
+            
+            #{ Ropenlayer::Openlayer::Js.new_var(@js_control_id, create_openlayer_control).to_js }
+            #{ Ropenlayer::Openlayer::Js.new_var(@js_links_id, create_links_container).to_js     }
+            #{ Ropenlayer::Openlayer::Js.new_var(@js_panel_id, create_openlayer_panel).to_js     }
+            
+            #{ Ropenlayer::Openlayer::Js.new("#{ @js_panel_id }.addControls([#{ @js_control_id }])").to_js }
+            #{ Ropenlayer::Openlayer::Js.new("#{ @map.js_id }.addControls([#{ @js_panel_id }])").to_js }
+
+            #{ Ropenlayer::Openlayer::Js.new(@map.js_helper.insert_into_xhtml_element("#{ @js_control_id }.div", @js_links_id)).to_js }
+
+            #{ links.inject('') do |links_string, link_config|
+                link_config[:inner_html] = "'#{ link_config.delete(:text) }'"
+                links_string << Ropenlayer::Openlayer::Js.new(@map.js_helper.insert_into_xhtml_element(@js_links_id, @map.js_helper.create_xhtml_element("a", link_config ))).to_js
+                links_string
+            end }
+            
+            )
+        end
+      end
+    end
+  end
+end

data/lib/ropenlayer/openlayer/box_control/edit_map.rb

@@ -0,0 +1,85 @@
+module Ropenlayer
+  module Openlayer
+    module BoxControl
+      class EditMap < Base
+        def initialize(map)
+          super('edit_map', map, :css_class => 'olControlEditMapControl')
+          Ropenlayer::Openlayer::BoxControl::EditMap.controls.each do |control_name, control_options|
+            
+            
+            @links  << { :id       => "'link_to_edit_map_control_#{ control_name }'",
+                         :class    => "'olControlEditMapControlLink with_icon action_#{ control_name }'",
+                         :text     => "'#{ control_options[:description] }'",
+                         :title    => "'#{ control_options[:description] }'",
+                         :onclick  => %( #{ map.js_helper.update_xhtml_element(map.js_notification_area, "'#{ control_options[:help]}'") }; \
+                                         #{ map.js_helper.hide_xhtml_element(@js_links_id) }; \
+                                         #{ map.js_id }ActivateEditControl('#{ control_name }'); return false ) }
+                       
+          end
+          @links << { :id       => "'link_to_edit_map_control_cancel'",
+                      :class    =>  "'olControlEditMapControlLink with_icon action_cancel'",
+                      :text     => "Cancelar",
+                      :onclick  => %( #{ map.js_id }ActivateEditControl('none'); #{  map.js_helper.hide_xhtml_element(@js_links_id) }; return false)  }
+        end
+        
+        def to_js
+          %( 
+            var #{ map.js_id }EditMapControls = {};
+            function #{ map.js_id }ActivateEditControl(selectedControl) {
+              for(key in #{ map.js_id }EditMapControls) {
+                var control = #{ map.js_id }EditMapControls[key];
+                if(selectedControl == key) {
+                  control.activate();
+                } else {
+                  control.deactivate();
+                }
+              }
+            }
+            #{ new_elements_layer = Ropenlayer::Openlayer::Layer::Base.new(:new_elements, @map)
+              new_elements_layer.to_js }
+
+            #{ Ropenlayer::Openlayer::BoxControl::EditMap.controls.inject('') do |edit_controls_js, control_array|
+                control_name    = control_array.first
+                control_options = control_array.last
+                control_options[:args] = [ new_elements_layer.js_id, control_options[:args]].flatten
+                control_options[:propierties][:featureAdded] = map.options[:add_feature_callback] || 'false' # FIXME
+
+                edit_controls_js << %( #{ Ropenlayer::Openlayer::Js.new_var("#{ map.js_id }_#{ control_name }", 
+                                                                            "#{ Ropenlayer::Openlayer::Js.new_method(control_options[:method], control_options) }").to_js }
+                                        #{ Ropenlayer::Openlayer::Js.new("#{ map.js_id }.addControl(#{ map.js_id }_#{ control_name })").to_js }
+                                        #{ Ropenlayer::Openlayer::Js.new("#{ map.js_id }EditMapControls['#{ control_name }'] = #{ map.js_id }_#{ control_name }").to_js }
+                )
+                edit_controls_js
+              end }
+      
+            #{ super }
+            )
+        end
+        
+        private
+        def self.controls
+          { :add_point        => {:method      => "OpenLayers.Control.DrawFeature",
+                                  :args        => [ "OpenLayers.Handler.Point" ],
+                                  :propierties => { },
+                                  :description => 'Crear un punto',
+                                  :help        => 'Para crear un punto en el mapa, haga click en la posición deseada'
+                                },
+            :add_line         => { :method      => "OpenLayers.Control.DrawFeature",
+                                  :args        => [ "OpenLayers.Handler.Path" ],
+                                  :propierties => { },
+                                  :description => 'Crear una línea',
+                                  :help        => 'Para crear un punto en el mapa, haga click en la posición deseada'
+
+                                },
+            :add_polygon      => { :method      => "OpenLayers.Control.DrawFeature",
+                                  :args        => [ "OpenLayers.Handler.Polygon" ],
+                                  :propierties => { },
+                                  :description => 'Crear un polígono',
+                                  :help        => 'Para crear un punto en el mapa, haga click en la posición deseada'
+                                }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ropenlayer/openlayer/box_control/layers_select.rb

@@ -0,0 +1,17 @@
+module Ropenlayer
+  module Openlayer
+    module BoxControl
+      class LayersSelect < Base
+        def initialize(map)
+          super('layers_select', map, :css_class => 'olControlLayersBoxControl')
+          map.layers.uniq.each do |layer|
+            @links << { :id      => "'link_to_base_layer_#{ layer.name }'",
+                        :class   => "'olControlLayersBoxControl'",
+                        :text    => " » Usar Mapa #{ layer.config[:description] }",
+                        :onclick => "#{ map.js_id }.setBaseLayer(#{ layer.js_id }); #{ map.js_helper.hide_xhtml_element(@js_links_id ) }; return false;" }
+          end
+        end
+      end
+    end
+  end
+end