Ongoing development.

src/Netzmacht/Contao/Leaflet/Boot.php

@@ -0,0 +1,89 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet;
+
+use Netzmacht\Contao\Leaflet\Event\InitializeDefinitionMapperEvent;
+use Netzmacht\Contao\Leaflet\Event\InitializeEventDispatcherEvent;
+use Netzmacht\Contao\Leaflet\Event\InitializeLeafletBuilderEvent;
+use Netzmacht\Contao\Leaflet\Mapper\DefinitionMapper;
+use Netzmacht\LeafletPHP\Leaflet;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface as EventDispatcher;
+
+/**
+ * Class Boot initialize the leaflet map extension.
+ *
+ * @package Netzmacht\Contao\Leaflet
+ */
+class Boot
+{
+    /**
+     * The event dispatcher.
+     *
+     * @var EventDispatcher
+     */
+    private $eventDispatcher;
+
+    /**
+     * Construct.
+     *
+     * @param EventDispatcher $eventDispatcher The event dispatcher.
+     */
+    public function __construct(EventDispatcher $eventDispatcher)
+    {
+        $this->eventDispatcher = $eventDispatcher;
+    }
+
+    /**
+     * Initialize definition mapper.
+     *
+     * @param DefinitionMapper $definitionMapper The definition mapper.
+     *
+     * @return DefinitionMapper
+     */
+    public function initializeDefinitionMapper(DefinitionMapper $definitionMapper)
+    {
+        $event = new InitializeDefinitionMapperEvent($definitionMapper);
+        $this->eventDispatcher->dispatch($event::NAME, $event);
+
+        return $definitionMapper;
+    }
+
+    /**
+     * Initialize the internal used event dispatcher of the leaflet encoding system.
+     *
+     * @param EventDispatcher $eventDispatcher The internal event dispatcher.
+     *
+     * @return EventDispatcher
+     */
+    public function initializeEventDispatcher(EventDispatcher $eventDispatcher)
+    {
+        $event = new InitializeEventDispatcherEvent($eventDispatcher);
+        $this->eventDispatcher->dispatch($event::NAME, $event);
+
+        return $eventDispatcher;
+    }
+
+    /**
+     * Initialize the leaflet builder.
+     *
+     * @param Leaflet $leaflet The leaflet builder.
+     *
+     * @return Leaflet
+     */
+    public function initializeLeafletBuilder(Leaflet $leaflet)
+    {
+        $event = new InitializeLeafletBuilderEvent($leaflet);
+        $this->eventDispatcher->dispatch($event::NAME, $event);
+
+        return $leaflet;
+    }
+}

src/Netzmacht/Contao/Leaflet/ContaoAssets.php

@@ -0,0 +1,82 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet;
+
+use Netzmacht\LeafletPHP\Assets;
+
+/**
+ * Class ContaoAssets
+ * @package Netzmacht\Contao\Leaflet
+ */
+class ContaoAssets implements Assets
+{
+    /**
+     * @var
+     */
+    private $map;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addJavascript($script, $type = self::TYPE_SOURCE)
+    {
+        switch ($type) {
+            case static::TYPE_SOURCE:
+                $GLOBALS['TL_HEAD'][] = sprintf('<script>%s</script>', $script);
+                break;
+
+            case static::TYPE_FILE:
+                $script .= '|static';
+                // no break
+
+            default:
+                $GLOBALS['TL_JAVASCRIPT'][] = $script;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addStylesheet($stylesheet, $type = self::TYPE_FILE)
+    {
+        switch ($type) {
+            case static::TYPE_SOURCE:
+                $GLOBALS['TL_HEAD'][] = sprintf('<style>%s</style>', $stylesheet);
+                break;
+
+            case static::TYPE_FILE:
+                $stylesheet .= '||static';
+                // no break
+
+            default:
+                $GLOBALS['TL_CSS'][] = $stylesheet;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMap()
+    {
+        return $this->map;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setMap($map)
+    {
+        $this->map = $map;
+
+        return $this;
+    }
+}

src/Netzmacht/Contao/Leaflet/Dca/Content.php

@@ -0,0 +1,40 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Dca;
+
+use Netzmacht\Contao\Leaflet\Model\MapModel;
+
+/**
+ * Class Content
+ * @package Netzmacht\Contao\Leaflet\Dca
+ */
+class Content
+{
+    /**
+     * Get all leaflet maps.
+     *
+     * @return array
+     */
+    public function getMaps()
+    {
+        $options    = array();
+        $collection = MapModel::findAll();
+
+        if ($collection) {
+            foreach ($collection as $map) {
+                $options[$map->id] = $map->title;
+            }
+        }
+
+        return $options;
+    }
+}

src/Netzmacht/Contao/Leaflet/Dca/Leaflet.php

@@ -0,0 +1,63 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Dca;
+
+
+use Netzmacht\Contao\Leaflet\Mapper\DefinitionMapper;
+use Netzmacht\Contao\Leaflet\Mapper\MapMapper;
+use Netzmacht\Contao\Leaflet\Model\MapModel;
+use Netzmacht\LeafletPHP\Definition\Type\LatLng;
+
+class Leaflet
+{
+    /**
+     * Validate a coordinate.
+     *
+     * @param $value
+     *
+     * @return mixed
+     */
+    public function validateCoordinate($value)
+    {
+        if (!empty($value)) {
+            // Validate by creating latlng object. Throws an exception.
+
+            LatLng::fromString($value);
+        }
+
+        return $value;
+    }
+
+
+    public function getZoomLevels()
+    {
+        return range(1, 20);
+    }
+
+
+    public function getGeocoder($dataContainer)
+    {
+        $template = new \BackendTemplate('be_leaflet_geocode');
+        $template->field = 'ctrl_' . $dataContainer->field;
+
+        try {
+            $latLng = LatLng::fromString($dataContainer->value);
+            $template->marker = $latLng->toJson();
+        } catch(\Exception $e) {
+
+        }
+
+
+        return $template->parse();
+    }
+
+}

src/Netzmacht/Contao/Leaflet/Event/BuildDefinitionEvent.php

@@ -0,0 +1,71 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Event;
+
+use Netzmacht\LeafletPHP\Definition;
+use Symfony\Component\EventDispatcher\Event;
+
+/**
+ * Class BuildDefinitionEvent is emitted when the mapper maps between the model and the definition.
+ *
+ * @package Netzmacht\Contao\Leaflet\Event
+ */
+class BuildDefinitionEvent extends Event
+{
+    const NAME = 'leaflet.mapper.definition';
+
+    /**
+     * The leaflet object definition.
+     *
+     * @var Definition
+     */
+    private $definition;
+
+    /**
+     * The model.
+     *
+     * @var \Model
+     */
+    private $model;
+
+    /**
+     * Construct.
+     *
+     * @param Definition $definition The leaflet definition.
+     * @param \Model     $model      The definition model.
+     */
+    public function __construct(Definition $definition, \Model $model)
+    {
+        $this->definition = $definition;
+        $this->model = $model;
+    }
+
+    /**
+     * Get the definition.
+     *
+     * @return Definition
+     */
+    public function getDefinition()
+    {
+        return $this->definition;
+    }
+
+    /**
+     * Get the model.
+     *
+     * @return \Model
+     */
+    public function getModel()
+    {
+        return $this->model;
+    }
+}

src/Netzmacht/Contao/Leaflet/Event/GetJavascriptEvent.php

@@ -0,0 +1,71 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Event;
+
+use Netzmacht\LeafletPHP\Definition\Map;
+use Symfony\Component\EventDispatcher\Event;
+
+/**
+ * Class GetJavascriptEvent is emitted after the map javascript was created.
+ *
+ * @package Netzmacht\Contao\Leaflet\Event
+ */
+class GetJavascriptEvent extends Event
+{
+    const NAME = 'leaflet.service.get-javascript';
+
+    /**
+     * The generated javascript.
+     *
+     * @var string
+     */
+    private $javascript;
+
+    /**
+     * The map definition.
+     *
+     * @var Map
+     */
+    private $map;
+
+    /**
+     * Construct.
+     *
+     * @param Map    $map        The map definition.
+     * @param string $javascript The generated javascript.
+     */
+    public function __construct($map, $javascript)
+    {
+        $this->map        = $map;
+        $this->javascript = $javascript;
+    }
+
+    /**
+     * Get the generated javascript.
+     *
+     * @return string
+     */
+    public function getJavascript()
+    {
+        return $this->javascript;
+    }
+
+    /**
+     * Get the map definition.
+     *
+     * @return Map
+     */
+    public function getMap()
+    {
+        return $this->map;
+    }
+}

src/Netzmacht/Contao/Leaflet/Event/InitializeDefinitionMapperEvent.php

@@ -0,0 +1,50 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Event;
+
+use Netzmacht\Contao\Leaflet\Mapper\DefinitionMapper;
+use Symfony\Component\EventDispatcher\Event;
+
+/**
+ * Class InitializeDefinitionMapperEvent
+ *
+ * @package Netzmacht\Contao\Leaflet\Event
+ */
+class InitializeDefinitionMapperEvent extends Event
+{
+    const NAME = 'leaflet.boot.initialize-definition-mapper';
+
+    /**
+     * @var DefinitionMapper
+     */
+    private $definitionMapper;
+
+    /**
+     * Construct.
+     *
+     * @param DefinitionMapper $definitionMapper The definition mapper.
+     */
+    public function __construct(DefinitionMapper $definitionMapper)
+    {
+        $this->definitionMapper = $definitionMapper;
+    }
+
+    /**
+     * Get the definition mapper.
+     *
+     * @return DefinitionMapper
+     */
+    public function getDefinitionMapper()
+    {
+        return $this->definitionMapper;
+    }
+}

src/Netzmacht/Contao/Leaflet/Event/InitializeEventDispatcherEvent.php

@@ -0,0 +1,52 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Event;
+
+use Symfony\Component\EventDispatcher\Event;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface as EventDispatcher;
+
+/**
+ * InitializeEventDispatcherEvent is emitted then the internal event dispatcher of the encoding system is initialized.
+ *
+ * @package Netzmacht\Contao\Leaflet\Event
+ */
+class InitializeEventDispatcherEvent extends Event
+{
+    const NAME = 'leaflet.boot.initialize-event-dispatcher';
+
+    /**
+     * The event dispatcher.
+     *
+     * @var EventDispatcher
+     */
+    private $eventDispatcher;
+
+    /**
+     * The event dispatcher.
+     *
+     * @param EventDispatcher $eventDispatcher The event dispatcher.
+     */
+    public function __construct(EventDispatcher $eventDispatcher)
+    {
+        $this->eventDispatcher = $eventDispatcher;
+    }
+
+    /**
+     * Get the event dispatcher.
+     *
+     * @return EventDispatcher
+     */
+    public function getEventDispatcher()
+    {
+        return $this->eventDispatcher;
+    }
+}

src/Netzmacht/Contao/Leaflet/Event/InitializeLeafletBuilderEvent.php

@@ -0,0 +1,52 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Event;
+
+use Netzmacht\LeafletPHP\Leaflet;
+use Symfony\Component\EventDispatcher\Event;
+
+/**
+ * Class InitializeLeafletBuilderEvent is emitted when the leaflet builder is created.
+ *
+ * @package Netzmacht\Contao\Leaflet\Event
+ */
+class InitializeLeafletBuilderEvent extends Event
+{
+    const NAME = 'leaflet.boot.initialize-leaflet-builder';
+
+    /**
+     * The leaflet builder.
+     *
+     * @var Leaflet
+     */
+    private $builder;
+
+    /**
+     * Construct.
+     *
+     * @param Leaflet $builder The leaflet builder.
+     */
+    public function __construct(Leaflet $builder)
+    {
+        $this->builder = $builder;
+    }
+
+    /**
+     * Get the builder.
+     *
+     * @return Leaflet
+     */
+    public function getBuilder()
+    {
+        return $this->builder;
+    }
+}

src/Netzmacht/Contao/Leaflet/LeafletMapElement.php

@@ -0,0 +1,62 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet;
+
+/**
+ * @property int leaflet_map
+ */
+class LeafletMapElement extends \ContentElement
+{
+    /**
+     * Template name.
+     *
+     * @var string
+     */
+    protected $strTemplate = 'ce_leaflet_map';
+
+    /**
+     * @var MapService
+     */
+    private $mapService;
+
+    /**
+     * Construct.
+     *
+     * @param \ContentModel $objElement Content element model.
+     * @param string        $strColumn  Layout column.
+     */
+    public function __construct($objElement, $strColumn = 'main')
+    {
+        parent::__construct($objElement, $strColumn);
+
+        $this->mapService = $GLOBALS['container']['leaflet.map.service'];
+    }
+
+    /**
+     * Compile the content element.
+     *
+     * @return void
+     *
+     * @throws \Exception
+     */
+    protected function compile()
+    {
+        try {
+            $mapId = 'map_' . ($this->cssID[0] ?: $this->id);
+
+            $this->Template->mapId = $mapId;
+            $this->Template->map   = $this->mapService->getJavascript($this->leaflet_map, $mapId);
+        } catch(\Exception $e) {
+            throw $e;
+        }
+    }
+}

src/Netzmacht/Contao/Leaflet/MapService.php

@@ -0,0 +1,117 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet;
+
+use Netzmacht\Contao\Leaflet\Event\GetJavascriptEvent;
+use Netzmacht\Contao\Leaflet\Mapper\DefinitionMapper;
+use Netzmacht\Contao\Leaflet\Model\MapModel;
+use Netzmacht\LeafletPHP\Assets;
+use Netzmacht\LeafletPHP\Definition\Map;
+use Netzmacht\LeafletPHP\Leaflet;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface as EventDispatcher;
+
+/**
+ * Class MapService.
+ *
+ * @package Netzmacht\Contao\Leaflet
+ */
+class MapService
+{
+    /**
+     * The definition mapper.
+     *
+     * @var DefinitionMapper
+     */
+    private $mapper;
+
+    /**
+     * The leaflet service.
+     *
+     * @var Leaflet
+     */
+    private $leaflet;
+    /**
+     * @var EventDispatcher
+     */
+    private $eventDispatcher;
+
+    /**
+     * Construct.
+     *
+     * @param DefinitionMapper $mapper          The definition mapper.
+     * @param Leaflet          $leaflet         The Leaflet instance.
+     * @param EventDispatcher  $eventDispatcher The Contao event dispatcher.
+     */
+    public function __construct(DefinitionMapper $mapper, Leaflet $leaflet, EventDispatcher $eventDispatcher)
+    {
+        $this->mapper          = $mapper;
+        $this->leaflet         = $leaflet;
+        $this->eventDispatcher = $eventDispatcher;
+    }
+
+    /**
+     * Get map definition.
+     *
+     * @param int    $mapId     The map database id.
+     * @param string $elementId Optional element id. If none given the mapId or alias is used.
+     *
+     * @return Map
+     */
+    public function getDefinition($mapId, $elementId = null)
+    {
+        $model = $this->getModel($mapId);
+
+        return $this->mapper->handle($model, $elementId);
+    }
+
+    /**
+     * Get map model.
+     *
+     * @param int $mapId Model id.
+     *
+     * @return MapModel
+     *
+     * @throws \InvalidArgumentException If no model is found.
+     */
+    public function getModel($mapId)
+    {
+        $model = MapModel::findByPk($mapId);
+
+        if ($model === null) {
+            throw new \InvalidArgumentException(sprintf('Model "%s" not found', $mapId));
+        }
+
+        return $model;
+    }
+
+    /**
+     * Get map javascript.
+     *
+     * @param int $mapId The map id.
+     * @param string $elementId Optional element id. If none given the mapId or alias is used.
+     *
+     * @return string
+     *
+     * @throws \Exception If an error occurred in the process.
+     */
+    public function getJavascript($mapId, $elementId = null)
+    {
+        $definition = $this->getDefinition($mapId, $elementId);
+        $assets     = new ContaoAssets();
+        $javascript = $this->leaflet->build($definition, $assets);
+
+        $event = new GetJavascriptEvent($definition, $javascript);
+        $this->eventDispatcher->dispatch($event::NAME, $event);
+
+        return $event->getJavascript();
+    }
+}

src/Netzmacht/Contao/Leaflet/Mapper/AbstractMapper.php

@@ -0,0 +1,308 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper;
+
+use Netzmacht\LeafletPHP\Definition;
+
+/**
+ * Class AbstractBuilder.
+ *
+ * @package Netzmacht\Contao\Leaflet\Builder
+ */
+abstract class AbstractMapper implements Mapper
+{
+    /**
+     * Class of the model being build.
+     *
+     * @var string
+     */
+    protected static $modelClass = null;
+
+    /**
+     * Class of the definition being created.
+     *
+     * @var string
+     */
+    protected static $definitionClass = null;
+
+    /**
+     * Options mapping.
+     *
+     * @var array
+     */
+    private $options = array();
+
+    /**
+     * Conditional option mapping.
+     *
+     * @var array
+     */
+    private $conditional = array();
+
+    /**
+     * Construct.
+     */
+    public function __construct()
+    {
+        $this->initialize();
+    }
+
+    /**
+     * Add a option mapping.
+     *
+     * @param string $option  Name of the option.
+     * @param string $mapping Mapping column name. Set if column name differs.
+     *
+     * @return $this
+     */
+    public function addOption($option, $mapping = null)
+    {
+        if (!isset($this->options[$option])) {
+            $this->options[$option] = $this->getMapping($option, $mapping);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Add options mapping.
+     *
+     * @param array|mixed $options List of option names.
+     *
+     * @return $this
+     */
+    public function addOptions($options)
+    {
+        $arguments = func_get_args();
+
+        if (count($arguments) > 1) {
+            $options = $arguments;
+        }
+
+        foreach ($options as $key => $value) {
+            if (is_numeric($key)) {
+                $this->addOption($value);
+            } else {
+                $this->addOption($key, $value);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Add a conditional option.
+     *
+     * @param string $column  Condition column.
+     * @param string $option  Option name.
+     * @param null   $mapping Mapping column name.
+     * @param mixed  $value   Value of the conditional column.
+     *
+     * @return $this
+     */
+    public function addConditionalOption($column, $option, $mapping = null, $value = '1')
+    {
+        if (!isset($this->conditional[$column][$value][$option])) {
+            $this->conditional[$column][$value][$option] = $this->getMapping($option, $mapping);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Add a conditional options.
+     *
+     * @param string $column  Condition column.
+     * @param array  $options Option names.
+     * @param mixed  $value   Value of the conditional column.
+     *
+     * @return $this
+     */
+    public function addConditionalOptions($column, array $options, $value = '1')
+    {
+        foreach ($options as $key => $option) {
+            if (is_numeric($key)) {
+                $this->addConditionalOption($column, $option, null, $value);
+            } else {
+                $this->addConditionalOption($column, $key, $option, $value);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function handle(\Model $model, DefinitionMapper $builder)
+    {
+        $definition = $this->createInstance($model, $builder);
+
+        $this->buildOptions($definition, $model);
+        $this->buildConditionals($definition, $model);
+        $this->doBuild($definition, $model, $builder);
+
+        return $definition;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function match(\Model $model)
+    {
+        $modelClass = static::$modelClass;
+
+        return ($model instanceof $modelClass);
+    }
+
+    /**
+     * Initialize the builder.
+     *
+     * @return void
+     */
+    abstract protected function initialize();
+
+    /**
+     * Use for specific build methods.
+     *
+     * @param Definition $definition The definition being built.
+     * @param \Model     $model      The model.
+     * @param DefinitionMapper    $builder    The definition builder.
+     *
+     * @return void
+     */
+    protected function doBuild(Definition $definition, \Model $model, DefinitionMapper $builder)
+    {
+    }
+
+    /**
+     * Create a new definition instance.
+     *
+     * @param \Model           $model  The model.
+     * @param DefinitionMapper $mapper The definition mapper.
+     *
+     * @return Definition
+     */
+    protected function createInstance(\Model $model, DefinitionMapper $mapper)
+    {
+        $reflector = new \ReflectionClass(static::$definitionClass);
+        $instance  = $reflector->newInstanceArgs($this->buildConstructArguments($model, $mapper));
+
+        return $instance;
+    }
+
+    /**
+     * Get construct arguments.
+     *
+     * @param \Model           $model  The model.
+     * @param DefinitionMapper $mapper The definition mapper.
+     *
+     * @return array
+     */
+    protected function buildConstructArguments(\Model $model, DefinitionMapper $mapper)
+    {
+        return array(
+            $model->alias ?: $model->id
+        );
+    }
+
+    /**
+     * Build options.
+     *
+     * @param Definition $definition The definition being built.
+     * @param \Model     $model      The model.
+     *
+     * @return void
+     */
+    private function buildOptions($definition, $model)
+    {
+        $this->applyOptions($this->options, $definition, $model);
+    }
+
+    /**
+     * Build conditional options.
+     *
+     * @param Definition $definition The definition being built.
+     * @param \Model     $model      The model.
+     *
+     * @return void
+     */
+    private function buildConditionals(Definition $definition, \Model $model)
+    {
+        foreach ($this->conditional as $column => $conditions) {
+            foreach ($conditions as $value => $options) {
+                if ($model->$column == $value) {
+                    $this->applyOptions($options, $definition, $model);
+                }
+            }
+        }
+    }
+
+    /**
+     * Get the mapping column.
+     *
+     * @param string      $option  Option name.
+     * @param string|null $mapping Mapping column.
+     *
+     * @return string
+     */
+    private function getMapping($option, $mapping)
+    {
+        if ($mapping === null) {
+            return $option;
+        }
+
+        return $mapping;
+    }
+
+    /**
+     * Apply options from the model to the definition.
+     *
+     * @param array      $options    The options.
+     * @param Definition $definition The definition being built.
+     * @param \Model     $model      The model.
+     */
+    private function applyOptions($options, $definition, $model)
+    {
+        foreach ($options as $option => $mapping) {
+            $setter = 'set' . ucfirst($option);
+
+            if ($model->$option != $this->getDefaultOption($option, $definition)) {
+                $definition->$setter($model->$mapping);
+            }
+        }
+    }
+
+    /**
+     * Get default option value.
+     *
+     * @param string     $option     The option name.
+     * @param Definition $definition The definition being built.
+     *
+     * @return mixed
+     */
+    private function getDefaultOption($option, $definition)
+    {
+        $keys   = array('has', 'is', 'get');
+        $suffix = ucfirst($option);
+
+        foreach ($keys as $key) {
+            $method = $key . $suffix;
+
+            if (method_exists($definition, $method)) {
+                return $definition->$method();
+            }
+        }
+
+        return null;
+    }
+}

src/Netzmacht/Contao/Leaflet/Mapper/DefinitionMapper.php

@@ -0,0 +1,116 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper;
+
+use Netzmacht\Contao\Leaflet\Event\BuildDefinitionEvent;
+use Netzmacht\LeafletPHP\Definition;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface as EventDispatcher;
+
+/**
+ * Class DefinitionBuilder is the main builder instance which contains all other builders as children.
+ *
+ * @package Netzmacht\Contao\Leaflet\Builder
+ */
+class DefinitionMapper
+{
+    /**
+     * Registered builders.
+     *
+     * @var AbstractMapper[][]
+     */
+    private $builders = array();
+
+    /**
+     * The event dispatcher.
+     *
+     * @var EventDispatcher
+     */
+    private $eventDispatcher;
+
+    /**
+     * Map id of the current built map.
+     *
+     * @var string
+     */
+    private $mapId;
+
+    /**
+     * Construct.
+     *
+     * @param EventDispatcher $eventDispatcher The event dispatcher.
+     */
+    public function __construct($eventDispatcher)
+    {
+        $this->eventDispatcher = $eventDispatcher;
+    }
+
+    /**
+     * Add a builder.
+     *
+     * @param Mapper $builder  The builder.
+     * @param int    $priority The priority. The higher priorities get called first.
+     *
+     * @return $this
+     */
+    public function register(Mapper $builder, $priority = 0)
+    {
+        $this->builders[$priority][] = $builder;
+
+        return $this;
+    }
+
+    /**
+     * Get the map id of the current built map.
+     *
+     * @return string
+     */
+    public function getMapId()
+    {
+        return $this->mapId;
+    }
+
+    /**
+     * Build a model.
+     *
+     * @param \Model $model The definition model.
+     * @param string $elementId Optional element id. If none given the mapId or alias is used.
+     *
+     * @return Definition
+     */
+    public function handle(\Model $model, $elementId = null)
+    {
+        krsort($this->builders);
+
+        $this->mapId = $elementId ?: ($model->alias ?: ('map_' . $model->id));
+
+        foreach ($this->builders as $builders) {
+            foreach($builders as $builder) {
+                if ($builder->match($model)) {
+                    $definition = $builder->handle($model, $this);
+
+                    $event = new BuildDefinitionEvent($definition, $model);
+                    $this->eventDispatcher->dispatch($event::NAME, $event);
+
+                    return $definition;
+                }
+            }
+        }
+
+        throw new \RuntimeException(
+            sprintf(
+                'Could not build model "%s::%s". No matching builders found.',
+                $model->getTable(),
+                $model->{$model->getPk()}
+            )
+        );
+    }
+}

src/Netzmacht/Contao/Leaflet/Mapper/MapMapper.php

@@ -0,0 +1,106 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper;
+
+use Netzmacht\Contao\Leaflet\Model\MapModel;
+use Netzmacht\LeafletPHP\Definition;
+use Netzmacht\LeafletPHP\Definition\Map;
+
+class MapMapper extends AbstractMapper
+{
+    /**
+     * Class of the model being build.
+     *
+     * @var string
+     */
+    protected static $modelClass = 'Netzmacht\Contao\Leaflet\Model\MapModel';
+
+    /**
+     * Class of the definition being created.
+     *
+     * @var string
+     */
+    protected static $definitionClass = 'Netzmacht\LeafletPHP\Definition\Map';
+
+    /**
+     * @inheritdoc
+     */
+    protected function initialize()
+    {
+        $this
+            ->addOptions('center', 'zoom', 'zoomControl')
+            ->addOptions('dragging', 'touchZoom', 'scrollWheelZoom', 'doubleClickZoom', 'boxZoom', 'tap', 'keyboard')
+            ->addOptions('trackResize', 'closePopupOnClick', 'bounceAtZoomLimits')
+            ->addConditionalOptions('adjustZoomExtra', array('minZoom', 'maxZoom'))
+            ->addConditionalOptions('keyboard', array('keyboardPanOffset', 'keyboardZoomOffset'));
+    }
+
+    /**
+     * @inheritdoc
+     */
+    protected function doBuild(Definition $map, \Model $model, DefinitionMapper $builder)
+    {
+        if ($map instanceof Map && $model instanceof MapModel) {
+            $this->buildCustomOptions($map, $model);
+            $this->buildControls($map, $model, $builder);
+            $this->buildLayers($map, $model, $builder);
+        }
+    }
+
+    /**
+     * @inheritdoc
+     */
+    protected function buildConstructArguments(\Model $model, DefinitionMapper $mapper)
+    {
+        return array(
+            $mapper->getMapId(),
+            $mapper->getMapId()
+        );
+    }
+
+    /**
+     * Build map custom options.
+     *
+     * @param Map      $map   The map being built.
+     * @param MapModel $model The map model.
+     *
+     * @return void
+     */
+    protected function buildCustomOptions(Map $map, MapModel $model)
+    {
+        if ($model->options) {
+            $map->setOptions(json_decode($model->options, true));
+        }
+    }
+
+    /**
+     * Build map controls.
+     *
+     * @param Map              $map    The map being built.
+     * @param MapModel         $model  The map model.
+     * @param DefinitionMapper $mapper The definition mapper.
+     */
+    private function buildControls(Map $map, MapModel$model, DefinitionMapper $mapper)
+    {
+    }
+
+    /**
+     * Build map layers.
+     *
+     * @param Map              $map    The map being built.
+     * @param MapModel         $model  The map model.
+     * @param DefinitionMapper $mapper Definition mapper.
+     */
+    private function buildLayers(Map $map, MapModel $model, DefinitionMapper $mapper)
+    {
+    }
+}

src/Netzmacht/Contao/Leaflet/Mapper/Mapper.php

@@ -0,0 +1,36 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper;
+
+use Netzmacht\LeafletPHP\Definition;
+
+interface Mapper
+{
+    /**
+     * Map model to the definition.
+     *
+     * @param \Model  $model   The model being built.
+     * @param DefinitionMapper $builder The definition builder.
+     *
+     * @return Definition
+     */
+    public function handle(\Model $model, DefinitionMapper $builder);
+
+    /**
+     * Check if builder is responsible for the model.
+     *
+     * @param \Model $model The model being build.
+     *
+     * @return bool
+     */
+    public function match(\Model $model);
+}

src/Netzmacht/Contao/Leaflet/Model/MapModel.php

@@ -0,0 +1,19 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Model;
+
+
+class MapModel extends \Model
+{
+    protected static $strTable = 'tl_leaflet_map';
+
+}

src/Netzmacht/Contao/Leaflet/Subscriber/BootSubscriber.php

@@ -0,0 +1,117 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Subscriber;
+
+use ContaoCommunityAlliance\Contao\EventDispatcher\EventDispatcherInitializer;
+use Netzmacht\Contao\Leaflet\Event\GetJavascriptEvent;
+use Netzmacht\Contao\Leaflet\Event\InitializeDefinitionMapperEvent;
+use Netzmacht\Contao\Leaflet\Event\InitializeEventDispatcherEvent;
+use Netzmacht\Contao\Leaflet\Event\InitializeLeafletBuilderEvent;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+
+/**
+ * Class BootSubscriber
+ *
+ * @package Netzmacht\Contao\Leaflet\Subscriber
+ */
+class BootSubscriber implements EventSubscriberInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public static function getSubscribedEvents()
+    {
+        return array(
+            InitializeDefinitionMapperEvent::NAME => 'initializeDefinitionMapper',
+            InitializeEventDispatcherEvent::NAME  => 'initializeEventDispatcher',
+            InitializeLeafletBuilderEvent::NAME   => 'initializeLeafletBuilder',
+            GetJavascriptEvent::NAME              => 'loadAssets'
+        );
+    }
+
+    /**
+     * Create and register all configured mappers.
+     *
+     * @param InitializeDefinitionMapperEvent $event The subscribed event.
+     *
+     * @return void
+     *
+     * @SuppressWarnings(PHPMD.Superglobals)
+     */
+    public function initializeDefinitionMapper(InitializeDefinitionMapperEvent $event)
+    {
+        $mapper = $event->getDefinitionMapper();
+
+        foreach ($GLOBALS['LEAFLET_MAPPERS'] as $className) {
+            if (is_array($className)) {
+                $mapper->register(new $className[0], $className[1]);
+            } else {
+                $mapper->register(new $className());
+            }
+        }
+    }
+
+    /**
+     * Register all leaflet encoders.
+     *
+     * @param InitializeEventDispatcherEvent $event The subscribed event.
+     *
+     * @return void
+     *
+     * @SuppressWarnings(PHPMD.Superglobals)
+     */
+    public function initializeEventDispatcher(InitializeEventDispatcherEvent $event)
+    {
+        $dispatcher  = $event->getEventDispatcher();
+        $initializer = new EventDispatcherInitializer();
+
+        $initializer->addSubscribers($dispatcher, $GLOBALS['LEAFLET_ENCODERS']);
+    }
+
+    /**
+     * Register all libraries assets.
+     *
+     * @param InitializeLeafletBuilderEvent $event The subscribed event.
+     *
+     * @return void
+     *
+     * @SuppressWarnings(PHPMD.Superglobals)
+     */
+    public function initializeLeafletBuilder(InitializeLeafletBuilderEvent $event)
+    {
+        $builder = $event->getBuilder();
+
+        foreach ($GLOBALS['LEAFLET_ASSETS'] as $name => $assets) {
+            if (!empty($assets['css'])) {
+                foreach ($assets['css'] as $javascript) {
+                    $builder->registerStylesheet($name, $javascript[0], $javascript[1]);
+                }
+            }
+
+            if (!empty($assets['javascript'])) {
+                foreach ($assets['javascript'] as $javascript) {
+                    $builder->registerJavascript($name, $javascript[0], $javascript[1]);
+                }
+            }
+        }
+    }
+
+    /**
+     * Load Contao leaflet assets.
+     *
+     * @return void
+     */
+    public function loadAssets()
+    {
+        $GLOBALS['TL_JAVASCRIPT'][] = 'system/modules/leaflet/assets/js/contao-leaflet.js';
+    }
+}

src/Netzmacht/Contao/Leaflet/Subscriber/EncoderSubscriber.php

@@ -0,0 +1,97 @@
+<?php
+
+/**
+ * @package    dev
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014 netzmacht creative David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Subscriber;
+
+use Netzmacht\Javascript\Event\BuildEvent;
+use Netzmacht\LeafletPHP\Definition\Map;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+
+/**
+ * Class EncoderSubscriber subscribes to the internal encoding event dispatcher.
+ *
+ * @package Netzmacht\Contao\Leaflet\Subscriber
+ */
+class EncoderSubscriber implements EventSubscriberInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public static function getSubscribedEvents()
+    {
+        return array(
+            BuildEvent::NAME => array(
+                array('startWrapper', 1000),
+                array('addAttribution'),
+                array('endWrapper', -1000)
+            )
+        );
+    }
+
+    /**
+     * Add contao-leaflet attribution.
+     *
+     * @param BuildEvent $event
+     */
+    public function addAttribution(BuildEvent $event)
+    {
+        $object = $event->getObject();
+
+        if ($object instanceof Map) {
+            $attribution = <<<HTML
+map.attributionControl.addAttribution(
+    '<a href="http://www.netzmacht.de/contao-leaflet">netzmacht <em>creative</em></a>'
+);
+HTML;
+            $event->getOutput()->addLine($attribution);
+
+            $event->getOutput()->addLine("var tileLayer = new L.TileLayer('http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', { attribution: \"test\"});
+tileLayer.addTo(map);");
+        }
+    }
+
+    /**
+     * Start the wrapper.
+     *
+     * The encoded map is wrapped so that it is added to window.ContaoLeaflet. You can subscribe the
+     * "mapadded" event on window.ContaoLeaflet if you can to do some customize stuff.
+     *
+     * @param BuildEvent $event The subscribed event.
+     *
+     * @return void
+     */
+    public function startWrapper(BuildEvent $event)
+    {
+        $object = $event->getObject();
+
+        if ($object instanceof Map) {
+            $line = sprintf('window.ContaoLeaflet.addMap(\'%s\', (function() {', $object->getId());
+            $event->getOutput()->addLine($line);
+        }
+    }
+
+    /**
+     * End the wrapper.
+     *
+     * @param BuildEvent $event The subscribed event.
+     *
+     * @return void
+     */
+    public function endWrapper(BuildEvent $event)
+    {
+        $object = $event->getObject();
+
+        if ($object instanceof Map) {
+            $line = 'return map; })());';
+            $event->getOutput()->addLine($line);
+        }
+    }
+}