Plug elements in 0.1.* API

folium/element.py

@@ -11,6 +11,7 @@
 ENV = Environment(loader=PackageLoader('folium', 'templates'))
 from collections import OrderedDict
 import json
+import base64
 
 from .six import urlopen
 from .utilities import _camelify, _parse_size
@@ -266,7 +267,7 @@ def _repr_html_(self, **kwargs):
 
         iframe = '<iframe src="{html}" width="{width}px" height="{height}px"></iframe>'\
             .format(\
-                    html = "data:text/html;base64,"+html.encode('utf8').encode('base64'),
+                    html = b"data:text/html;base64,"+base64.b64encode(html.encode('utf8')),
                     #html = self.HTML.replace('"','&quot;'),
                     width = int(60.*width),
                     height= int(60.*height),

folium/map.py

@@ -6,6 +6,8 @@
 Classes for drawing maps.
 """
 import warnings
+import json
+from collections import OrderedDict
 
 from jinja2 import Template
 
@@ -85,6 +87,8 @@ def __init__(self, location=None, width='100%', height='100%',
             self.location = location
             self.zoom_start = zoom_start
 
+        Figure().add_children(self)
+
         # Map Size Parameters.
         self.width  = _parse_size(width)
         self.height = _parse_size(height)
@@ -108,6 +112,7 @@ def __init__(self, location=None, width='100%', height='100%',
                 height: {{this.height[0]}}{{this.height[1]}};
                 left: {{this.left[0]}}{{this.left[1]}};
                 top: {{this.top[0]}}{{this.top[1]}};
+                }
             </style>
         {% endmacro %}
         {% macro html(this, kwargs) %}
@@ -169,7 +174,7 @@ def add_tile_layer(self, tiles='OpenStreetMap', name=None,
 
 class TileLayer(MacroElement):
     def __init__(self, tiles='OpenStreetMap', name=None,
-                 min_zoom=1, max_zoom=18, attr=None, API_key=None):
+                 min_zoom=1, max_zoom=18, attr=None, API_key=None, overlay = False):
         """TODO docstring here
         Parameters
         ----------
@@ -181,6 +186,8 @@ def __init__(self, tiles='OpenStreetMap', name=None,
         self.min_zoom = min_zoom
         self.max_zoom = max_zoom
 
+        self.overlay = overlay
+
         self.tiles = ''.join(tiles.lower().strip().split())
         if self.tiles in ('cloudmade', 'mapbox') and not API_key:
             raise ValueError('You must pass an API key if using Cloudmade'
@@ -197,6 +204,8 @@ def __init__(self, tiles='OpenStreetMap', name=None,
             if not attr:
                 raise ValueError('Custom tiles must'
                                  ' also be passed an attribution')
+            if isinstance(attr, binary_type):
+                attr = text_type(attr, 'utf8')
             self.attr = attr
 
         self._template = Template(u"""
@@ -213,6 +222,42 @@ def __init__(self, tiles='OpenStreetMap', name=None,
         {% endmacro %}
         """)
 
+class LayerControl(MacroElement):
+    """Adds a layer control to the map."""
+    def __init__(self):
+        """Creates a LayerControl object to be added on a folium map.
+
+        Parameters
+        ----------
+        """
+        super(LayerControl, self).__init__()
+        self._name = 'LayerControl'
+
+        self.base_layers = OrderedDict()
+        self.overlays = OrderedDict()
+
+        self._template = Template("""
+        {% macro script(this,kwargs) %}
+            var {{this.get_name()}} = {
+                base_layers : { {% for key,val in this.base_layers.items() %}"{{key}}" : {{val}},{% endfor %} },
+                overlays : { {% for key,val in this.overlays.items() %}"{{key}}" : {{val}},{% endfor %} }
+                };
+            L.control.layers(
+                {{this.get_name()}}.base_layers,
+                {{this.get_name()}}.overlays
+                ).addTo({{this._parent.get_name()}});
+        {% endmacro %}
+        """)
+
+    def render(self, **kwargs):
+        """TODO : docstring here."""
+        self.base_layers = OrderedDict([(val.tile_name,val.get_name()) \
+                       for key,val in self._parent._children.items() if isinstance(val,TileLayer) and not val.overlay])
+        self.overlays = OrderedDict([(val.tile_name,val.get_name()) \
+                       for key,val in self._parent._children.items() if isinstance(val,TileLayer) and val.overlay])
+
+        super(LayerControl, self).render()
+
 class Icon(MacroElement):
     def __init__(self, color='blue', icon='info-sign', angle=0):
         """TODO : docstring here"""
@@ -265,6 +310,10 @@ def __init__(self, location, popup=None, icon=None):
         super(Marker, self).__init__()
         self._name = 'Marker'
         self.location = location
+        if icon is not None:
+            self.add_children(icon)
+        if popup is not None:
+            self.add_children(popup)
 
         self._template = Template(u"""
             {% macro script(this, kwargs) %}
@@ -292,7 +341,7 @@ def __init__(self, html, max_width=300):
         self.script._parent = self
 
         if isinstance(html, Element):
-            self.html.add_children(html)
+            self.add_children(html)
         elif isinstance(html, text_type) or isinstance(html,binary_type):
             self.html.add_children(Html(text_type(html)))
 
@@ -324,3 +373,50 @@ def render(self, **kwargs):
 
         figure.script.add_children(Element(\
             self._template.render(this=self, kwargs=kwargs)), name=self.get_name())
+
+class FitBounds(MacroElement):
+    def __init__(self, bounds, padding_top_left=None,
+                   padding_bottom_right=None, padding=None, max_zoom=None):
+        """Fit the map to contain a bounding box with the maximum zoom level possible.
+
+        Parameters
+        ----------
+        bounds: list of (latitude, longitude) points
+            Bounding box specified as two points [southwest, northeast]
+        padding_top_left: (x, y) point, default None
+            Padding in the top left corner. Useful if some elements in
+            the corner, such as controls, might obscure objects you're zooming
+            to.
+        padding_bottom_right: (x, y) point, default None
+            Padding in the bottom right corner.
+        padding: (x, y) point, default None
+            Equivalent to setting both top left and bottom right padding to
+            the same value.
+        max_zoom: int, default None
+            Maximum zoom to be used.
+
+        """
+        super(FitBounds, self).__init__()
+        self._name = 'FitBounds'
+        self.bounds = json.loads(json.dumps(bounds))
+        options = {
+            'maxZoom': max_zoom,
+            'paddingTopLeft': padding_top_left,
+            'paddingBottomRight': padding_bottom_right,
+            'padding': padding,
+        }
+        self.fit_bounds_options = json.dumps({key:val for key,val in options.items() if val},
+                                             sort_keys=True)
+
+        self._template = Template(u"""
+            {% macro script(this, kwargs) %}
+                {% if this.autobounds %}
+                    var autobounds = L.featureGroup({{ this.features }}).getBounds()
+                {% endif %}
+
+                {{this._parent.get_name()}}.fitBounds(
+                    {% if this.bounds %}{{ this.bounds }}{% else %}"autobounds"{% endif %},
+                    {{ this.fit_bounds_options }}
+                    );
+            {% endmacro %}
+            """)

folium/plugins/__init__.py

@@ -9,6 +9,4 @@
 from .scroll_zoom_toggler import ScrollZoomToggler
 from .terminator import Terminator
 from .boat_marker import BoatMarker
-from .layer import Layer, LayerControl
-from .geo_json import GeoJson
 from .timestamped_geo_json import TimestampedGeoJson

folium/plugins/boat_marker.py

@@ -6,10 +6,11 @@
 Creates a marker shaped like a boat. Optionally you can append a wind direction. 
 """
 import json
+from jinja2 import Template
 
-from .plugin import Plugin
+from folium.element import JavascriptLink, MacroElement, Figure
 
-class BoatMarker(Plugin):
+class BoatMarker(MacroElement):
     """Adds a BoatMarker layer on the map."""
     def __init__(self, position=None, heading=0, wind_heading=None, wind_speed=0, **kwargs):
         """Creates a BoatMarker plugin to append into a map with
@@ -32,30 +33,28 @@ def __init__(self, position=None, heading=0, wind_heading=None, wind_speed=0, **
                 Speed of the wind in knots.
         """
         super(BoatMarker, self).__init__()
-        self.plugin_name = 'BoatMarker'
+        self._name = 'BoatMarker'
         self.position = None if position is None else tuple(position)
         self.heading = heading
         self.wind_heading = wind_heading
         self.wind_speed = wind_speed
-        self.kwargs = kwargs.copy()
-
-    def render_header(self, nb):
-        """Generates the HTML part of the plugin."""
-        return """
-            <script src="https://thomasbrueggemann.github.io/leaflet.boatmarker/js/leaflet.boatmarker.min.js"></script>
-            """  if nb==0 else ""
-
-    def render_js(self, nb):
-        """Generates the Javascript part of the plugin."""
-        kwargs_str =  "{%s}" % ",".join(["%s : %s" % (key,json.dumps(val)) for (key,val) in self.kwargs.items()])
-        position_str = "map.getCenter()" if self.position is None else "[%.12f,%.12f]"%self.position
-        out = 'var boatMarker_%s = L.boatMarker(%s, %s).addTo(map);' % (nb,position_str,kwargs_str)
-
-        if self.wind_heading is None:
-            out += "boatMarker_%s.setHeading(%s);" % (nb,int(self.heading))
-        else:
-            out += "boatMarker_%s.setHeadingWind(%s, %s, %s);"%(nb,int(self.heading),
-                                                             int(self.wind_speed),
-                                                             int(self.wind_heading),
-                                                             )
-        return out
+        self.kwargs = json.dumps(kwargs)
+
+        self._template = Template(u"""
+            {% macro script(this, kwargs) %}
+                var {{this.get_name()}} = L.boatMarker(
+                    [{{this.position[0]}},{{this.position[1]}}],
+                    {{this.kwargs}}).addTo({{this._parent.get_name()}});
+                {{this.get_name()}}.setHeadingWind({{this.heading}}, {{this.wind_speed}}, {{this.wind_heading}});
+            {% endmacro %}
+            """)
+    def render(self,**kwargs):
+        super(BoatMarker,self).render(**kwargs)
+
+        figure = self.get_root()
+        assert isinstance(figure,Figure), ("You cannot render this Element "
+            "if it's not in a Figure.")
+
+        figure.header.add_children(\
+            JavascriptLink("https://thomasbrueggemann.github.io/leaflet.boatmarker/js/leaflet.boatmarker.min.js"),
+                                   name='markerclusterjs')