;(function ($, window, google, undefined) {
    'use strict';

    /**
    * Maplace.js 0.1.33
    *
    * Copyright (c) 2013 Daniele Moraschi
    * Licensed under the MIT license
    * For all details and documentation:
    * http://maplacejs.com
    *
    * @version  0.1.33
    */


    var html_dropdown,
        html_ullist,
        Maplace;


    //dropdown menu type
    html_dropdown = {
        activateCurrent: function (index) {
            this.html_element.find('select').val(index);
        },

        getHtml: function () {
            var self = this,
                html = '',
                title,
                a;

            if (this.ln > 1) {
                html += '<select class="dropdown controls ' + this.o.controls_cssclass + '">';

                if (this.ShowOnMenu(this.view_all_key)) {
                    html += '<option value="' + this.view_all_key + '">' + this.o.view_all_text + '</option>';
                }

                for (a = 0; a < this.ln; a += 1) {
                    if (this.ShowOnMenu(a)) {
                        html += '<option value="' + (a + 1) + '">' + (this.o.locations[a].title || ('#' + (a + 1))) + '</option>';
                    }
                }
                html += '</select>';

                html = $(html).bind('change', function () {
                    self.ViewOnMap(this.value);
                });
            }

            title = this.o.controls_title;
            if (this.o.controls_title) {
                title = $('<div class="controls_title"></div>').css(this.o.controls_applycss ? {
                    fontWeight: 'bold',
                    fontSize: this.o.controls_on_map ? '12px' : 'inherit',
                    padding: '3px 10px 5px 0'
                } : {}).append(this.o.controls_title);
            }

            this.html_element = $('<div class="wrap_controls"></div>').append(title).append(html);

            return this.html_element;
        }
    };


    //ul list menu type
    html_ullist = {
        html_a: function (i, hash, ttl) {
            var self = this,
                index = hash || (i + 1),
                title = ttl || this.o.locations[i].title,
                el_a = $('<a data-load="' + index + '" id="ullist_a_' + index + '" href="#' + index + '" title="' + title + '"><span>' + (title || ('#' + (i + 1))) + '</span></a>');
            
            el_a.css(this.o.controls_applycss ? {
                color: '#666',
                display: 'block',
                padding: '5px',
                fontSize: this.o.controls_on_map ? '12px' : 'inherit',
                textDecoration: 'none'
            } : {});

            el_a.on('click', function (e) {
                e.preventDefault();
                var i = $(this).attr('data-load');
                self.ViewOnMap(i);
            });

            return el_a;
        },

        activateCurrent: function (index) {
            this.html_element.find('li').removeClass('active');
            this.html_element.find('#ullist_a_' + index).parent().addClass('active');
        },

        getHtml: function () {
            var html = $("<ul class='ullist controls " + this.o.controls_cssclass + "'></ul>").css(this.o.controls_applycss ? {
                margin: 0,
                padding: 0,
                listStyleType: 'none'
            } : {}),
                title, a;

            if (this.ShowOnMenu(this.view_all_key)) {
                html.append($('<li></li>').append(html_ullist.html_a.call(this, false, this.view_all_key, this.o.view_all_text)));
            }

            for (a = 0; a < this.ln; a++) {
                if (this.ShowOnMenu(a)) {
                    html.append($('<li></li>').append(html_ullist.html_a.call(this, a)));
                }
            }

            title = this.o.controls_title;
            if (this.o.controls_title) {
                title = $('<div class="controls_title"></div>').css(this.o.controls_applycss ? {
                    fontWeight: 'bold',
                    padding: '3px 10px 5px 0',
                    fontSize: this.o.controls_on_map ? '12px' : 'inherit'
                } : {}).append(this.o.controls_title);
            }

            this.html_element = $('<div class="wrap_controls"></div>').append(title).append(html);

            return this.html_element;
        }
    };


    Maplace = (function () {

        /**
        * Create a new instance
        * @class Maplace
        * @constructor  
        */
        function Maplace(args) {
            this.VERSION = '0.1.33';
            this.loaded = false;
            this.markers = [];
            this.circles = [];
            this.oMap = false;
            this.view_all_key = 'all';

            this.infowindow = null;
            this.maxZIndex = 0;
            this.ln = 0;
            this.oMap = false;
            this.oBounds = null;
            this.map_div = null;
            this.canvas_map = null;
            this.controls_wrapper = null;
            this.current_control = null;
            this.current_index = null;
            this.Polyline = null;
            this.Polygon = null;
            this.Fusion = null;
            this.directionsService = null;
            this.directionsDisplay = null;

            //default options
            this.o = {
                debug: false,
                map_div: '#gmap',
                controls_div: '#controls',
                generate_controls: true,
                controls_type: 'dropdown',
                controls_cssclass: '',
                controls_title: '',
                controls_on_map: true,
                controls_applycss: true,
                controls_position: google.maps.ControlPosition.RIGHT_TOP,
                type: 'marker',
                view_all: true,
                view_all_text: 'View All',
                pan_on_click: true,
                start: 0,
                locations: [],
                shared: {},
                map_options: {
                    mapTypeId: google.maps.MapTypeId.ROADMAP
                },
                stroke_options: {
                    strokeColor: '#0000FF',
                    strokeOpacity: 0.8,
                    strokeWeight: 2,
                    fillColor: '#0000FF',
                    fillOpacity: 0.4
                },
                directions_options: {
                    travelMode: google.maps.TravelMode.DRIVING,
                    unitSystem: google.maps.UnitSystem.METRIC,
                    optimizeWaypoints: false,
                    provideRouteAlternatives: false,
                    avoidHighways: false,
                    avoidTolls: false
                },
                circle_options: {
                    radius: 100,
                    visible: true
                },
                styles: {},
                fusion_options: {},
                directions_panel: null,
                draggable: false,
                editable: false,
                show_infowindows: true,
                show_markers: true,
                infowindow_type: 'bubble',
                listeners: {},

                //events
                beforeViewAll: function () {},
                afterViewAll: function () {},
                beforeShow: function (index, location, marker) {},
                afterShow: function (index, location, marker) {},
                afterCreateMarker: function (index, location, marker) {},

                beforeCloseInfowindow: function (index, location) {},
                afterCloseInfowindow: function (index, location) {},
                beforeOpenInfowindow: function (index, location, marker) {},
                afterOpenInfowindow: function (index, location, marker) {},

                afterRoute: function (distance, status, result) {},
                onPolylineClick: function (obj) {},
                onPolygonClick: function (obj) {},

                circleRadiusChanged: function (index, circle, marker) {},
                circleCenterChanged: function (index, circle, marker) {},

                drag: function (index, location, marker) {},
                dragEnd: function (index, location, marker) {},
                dragStart: function (index, location, marker) {}
            };

            //default menu types
            this.AddControl('dropdown', html_dropdown);
            this.AddControl('list', html_ullist);

            if (args && args.type === 'directions') {
                !args.show_markers && (args.show_markers = false);
                !args.show_infowindows && (args.show_infowindows = false);
            }

            //init
            $.extend(true, this.o, args);
        }

        //where to store the menu types
        Maplace.prototype.controls = {};

        //initialize google map object
        Maplace.prototype.create_objMap = function () {
            var self = this,
                count = 0,
                i;

            //if styled
            for (i in this.o.styles) {
                if (this.o.styles.hasOwnProperty(i)) {
                    if (count === 0) {
                        this.o.map_options.mapTypeControlOptions = {
                            mapTypeIds: [google.maps.MapTypeId.ROADMAP]
                        };
                    }
                    count++;
                    this.o.map_options.mapTypeControlOptions.mapTypeIds.push('map_style_' + count);
                }
            }

            //if init
            if (!this.loaded) {
                try {
                    this.map_div.css({
                        position: 'relative',
                        overflow: 'hidden'
                    });
                    
                    //create the container div into map_div
                    this.canvas_map = $('<div>').addClass('canvas_map').css({
                        width: '100%',
                        height: '100%'
                    }).appendTo(this.map_div);

                    this.oMap = new google.maps.Map(this.canvas_map.get(0), this.o.map_options);

                } catch (err) {
                    this.debug('create_objMap::' + this.map_div.selector, err.toString());
                }

            //else loads the new optionsl
            } else {
                self.oMap.setOptions(this.o.map_options);
            }

            //if styled
            count = 0;
            for (i in this.o.styles) {
                if (this.o.styles.hasOwnProperty(i)) {
                    count++;
                    this.oMap.mapTypes.set('map_style_' + count, new google.maps.StyledMapType(this.o.styles[i], {
                        name: i
                    }));
                    this.oMap.setMapTypeId('map_style_' + count);
                }
            }
        };

        //adds markers to the map
        Maplace.prototype.add_markers_to_objMap = function () {
            var a,
                point,
                type = this.o.type || 'marker';

            //switch how to display the locations
            switch (type) {
                case 'marker':
                    for (a = 0; a < this.ln; a++) {
                        point = this.create_objPoint(a);
                        this.create.marker.call(this, a, point);
                    }
                    break;
                default:
                    this.create[type].apply(this);
                    break;
            }
        };

        //create the main object point
        Maplace.prototype.create_objPoint = function (index) {
            var point = $.extend({}, this.o.locations[index]),
                visibility = point.visible === undefined ? undefined : point.visible;

            !point.type && (point.type = this.o.type);

            //set obj map
            point.map = this.oMap;
            point.position = new google.maps.LatLng(point.lat, point.lon);
            point.zIndex = point.zIndex === undefined ? 10000 : (point.zIndex + 100);
            point.visible = visibility === undefined  ? this.o.show_markers : visibility;

            this.o.maxZIndex = point.zIndex > this.maxZIndex ? point.zIndex : this.maxZIndex;

            if (point.image) {
                point.icon = new google.maps.MarkerImage(
                    point.image,
                    new google.maps.Size(point.image_w || 32, point.image_h || 32),
                    new google.maps.Point(0, 0),
                    new google.maps.Point((point.image_w || 32) / 2, (point.image_h || 32)  / 2)
                );
            }

            return point;
        };

        //create the main object circle
        Maplace.prototype.create_objCircle = function (point) {
            var def_stroke_opz,
                def_circle_opz,
                circle;
            
            circle = $.extend({}, point);
            def_stroke_opz = $.extend({}, this.o.stroke_options);
            def_circle_opz = $.extend({}, this.o.circle_options);

            $.extend(def_stroke_opz, point.stroke_options || {});
            $.extend(circle, def_stroke_opz);
            
            $.extend(def_circle_opz, point.circle_options || {});
            $.extend(circle, def_circle_opz);

            circle.center = point.position;
            circle.draggable = false;
            circle.zIndex = point.zIndex > 0 ? point.zIndex - 10 : 1;

            return circle;
        };

        //create the main object point
        Maplace.prototype.add_markerEv = function (index, point, marker) {
            var self = this;

            google.maps.event.addListener(marker, 'click', function (ev) {
                self.o.beforeShow(index, point, marker);

                //show infowindow?
                if (self.o.show_infowindows && (point.show_infowindow === false ? false : true)) {
                    self.open_infowindow(index, marker, ev);
                }

                //pan and zoom the map
                if (self.o.pan_on_click && (point.pan_on_click === false ? false : true)) {
                    self.oMap.panTo(point.position);
                    point.zoom && self.oMap.setZoom(point.zoom);
                }

                //activate related menu link
                if (self.current_control && self.o.generate_controls && self.current_control.activateCurrent) {
                    self.current_control.activateCurrent.call(self, index + 1);
                }

                //update current location index
                self.current_index = index;

                self.o.afterShow(index, point, marker);
            });

            if (point.draggable) {
                this.add_dragEv(index, point, marker);
            }
        };

        //add events to circles objs
        Maplace.prototype.add_circleEv = function (index, circle, marker) {
            var self = this;

            google.maps.event.addListener(marker, 'click', function () {
                self.ViewOnMap(index + 1);
            });

            google.maps.event.addListener(marker, 'center_changed', function() {
                self.o.circleCenterChanged(index, circle, marker);
            });

            google.maps.event.addListener(marker, 'radius_changed', function() {
                self.o.circleRadiusChanged(index, circle, marker);
            });

            if (circle.draggable) {
                this.add_dragEv(index, circle, marker);
            }
        };

        //add drag events
        Maplace.prototype.add_dragEv = function (index, obj, marker) {
            var self = this;

            google.maps.event.addListener(marker, 'drag', function (ev) {
                var pos,
                    extraType;

                if (marker.getPosition) {
                    pos = marker.getPosition();
                } else if (marker.getCenter) {
                    pos = marker.getCenter();
                } else {
                    return;
                }

                //update circle position
                if (self.circles[index]) {
                    self.circles[index].setCenter(pos);
                }

                //update polygon or polyline if defined
                if (self.Polyline) {
                    extraType = 'Polyline';
                } else if (self.Polygon) {
                    extraType = 'Polygon';
                }

                if (extraType) {
                    var path = self[extraType].getPath(),
                        pathArray = path.getArray(),
                        arr = [],
                        i = 0;

                    for(; i < pathArray.length; ++i) {
                        arr[i] = index === i
                            ? new google.maps.LatLng(pos.lat(), pos.lng())
                            : new google.maps.LatLng(pathArray[i].lat(), pathArray[i].lng());
                    }

                    self[extraType].setPath(new google.maps.MVCArray(arr));
                    self.add_polyEv(extraType);
                }

                //fire drag event
                self.o.drag(index, obj, marker);
            });

            google.maps.event.addListener(marker, 'dragend', function() {
                self.o.dragEnd(index, obj, marker);
            });

            google.maps.event.addListener(marker, 'dragstart', function() {
                self.o.dragStart(index, obj, marker);
            });

            google.maps.event.addListener(marker, 'center_changed', function() {
                //update marker position
                if (self.markers[index] && marker.getCenter) {
                    self.markers[index].setPosition(marker.getCenter());
                }

                self.o.drag(index, obj, marker);
            });
        };

        //add events to poly objs
        Maplace.prototype.add_polyEv = function (typeName) {
            var self = this;

            google.maps.event.addListener(this[typeName].getPath(), 'set_at', function(index, obj) {
                var item = self[typeName].getPath().getAt(index),
                    newPos = new google.maps.LatLng(item.lat(), item.lng());

                self.markers[index] && self.markers[index].setPosition(newPos);
                self.circles[index] && self.circles[index].setCenter(newPos);

                self.o['on' + typeName + 'Changed'](index, obj, self[typeName].getPath().getArray());
            });
        };

        //wrapper for the map types
        Maplace.prototype.create = {

            //single marker
            marker: function (index, point, marker) {
                var self = this,
                    circle;

                //allow mix circles with markers
                if (point.type == 'circle' && !marker) {
                    circle = this.create_objCircle(point);

                    if (!point.visible) {
                        circle.draggable = point.draggable;
                    }

                    marker = new google.maps.Circle(circle);
                    this.add_circleEv(index, circle, marker);

                    //store the new circle
                    this.circles[index] = marker;
                }

                point.type = 'marker';

                //create the marker and add click event
                marker = new google.maps.Marker(point);
                this.add_markerEv(index, point, marker);
                
                //extends bounds with this location
                this.oBounds.extend(point.position);

                //store the new marker
                this.markers[index] = marker;

                this.o.afterCreateMarker(index, point, marker);

                return marker;
            },


            //circle mode
            circle: function () {
                var self = this,
                    a,
                    point,
                    circle,
                    marker;

                for (a = 0; a < this.ln; a++) {
                    point = this.create_objPoint(a);

                    //allow mix markers with circles
                    if (point.type == 'circle') {
                        circle = this.create_objCircle(point);

                        if (!point.visible) {
                            circle.draggable = point.draggable;
                        }

                        marker = new google.maps.Circle(circle);
                        this.add_circleEv(a, circle, marker);

                        //store the new circle
                        this.circles[a] = marker;
                    }

                    point.type = 'marker';
                    this.create.marker.call(this, a, point, marker);
                }
            },


            //polyline mode
            polyline: function () {
                var self = this,
                    a,
                    point,
                    stroke = $.extend({}, this.o.stroke_options);
                
                stroke.path = [];
                stroke.draggable = this.o.draggable;
                stroke.editable = this.o.editable;
                stroke.map = this.oMap;
                stroke.zIndex = this.o.maxZIndex + 100;

                //create the path and location marker
                for (a = 0; a < this.ln; a++) {
                    point = this.create_objPoint(a);
                    this.create.marker.call(this, a, point);

                    stroke.path.push(point.position);
                }

                this.Polyline
                    ? this.Polyline.setOptions(stroke)
                    : this.Polyline = new google.maps.Polyline(stroke);

                this.add_polyEv('Polyline');
            },


            //polygon mode
            polygon: function () {
                var self = this,
                    a,
                    point,
                    stroke = $.extend({}, this.o.stroke_options);
                
                stroke.path = [];
                stroke.draggable = this.o.draggable;
                stroke.editable = this.o.editable;
                stroke.map = this.oMap;
                stroke.zIndex = this.o.maxZIndex + 100;

                //create the path and location marker
                for (a = 0; a < this.ln; a++) {
                    point = this.create_objPoint(a);
                    this.create.marker.call(this, a, point);

                    stroke.path.push(point.position);
                }

                this.Polygon
                    ? this.Polygon.setOptions(stroke)
                    : this.Polygon = new google.maps.Polygon(stroke);

                google.maps.event.addListener(this.Polygon, 'click', function (obj) {
                    self.o.onPolygonClick(obj);
                });

                this.add_polyEv('Polygon');
            },


            //fusion tables
            fusion: function () {
                this.o.fusion_options.styles = [this.o.stroke_options];
                this.o.fusion_options.map = this.oMap;

                this.Fusion
                    ? this.Fusion.setOptions(this.o.fusion_options)
                    : this.Fusion = new google.maps.FusionTablesLayer(this.o.fusion_options);
            },


            //directions mode
            directions: function () {
                var self = this,
                    a,
                    point,
                    stopover,
                    origin,
                    destination,
                    waypoints = [],
                    distance = 0;

                //create the waypoints and location marker
                for (a = 0; a < this.ln; a++) {
                    point = this.create_objPoint(a);

                    //first location start point
                    if (a === 0) {
                        origin = point.position;

                    //last location end point
                    } else if (a === (this.ln - 1)) {
                        destination = point.position;

                    //waypoints in the middle
                    } else {
                        stopover = this.o.locations[a].stopover === true ? true : false;
                        waypoints.push({
                            location: point.position,
                            stopover: stopover
                        });
                    }

                    this.create.marker.call(this, a, point);
                }

                this.o.directions_options.origin = origin;
                this.o.directions_options.destination = destination;
                this.o.directions_options.waypoints = waypoints;

                this.directionsService || (this.directionsService = new google.maps.DirectionsService());
                this.directionsDisplay 
                    ? this.directionsDisplay.setOptions({ draggable: this.o.draggable })
                    : this.directionsDisplay = new google.maps.DirectionsRenderer({ draggable: this.o.draggable });

                this.directionsDisplay.setMap(this.oMap);

                //show the directions panel
                if (this.o.directions_panel) {
                    this.o.directions_panel = $(this.o.directions_panel);
                    this.directionsDisplay.setPanel(this.o.directions_panel.get(0));
                }

                if (this.o.draggable) {
                    google.maps.event.addListener(this.directionsDisplay, 'directions_changed', function () {
                        distance = self.compute_distance(self.directionsDisplay.directions);
                        self.o.afterRoute(distance);
                    });
                }

                this.directionsService.route(this.o.directions_options, function (result, status) {
                    //directions found
                    if (status === google.maps.DirectionsStatus.OK) {
                        distance = self.compute_distance(result);
                        self.directionsDisplay.setDirections(result);
                    }
                    self.o.afterRoute(distance, status, result);
                });
            }
        };

        //route distance
        Maplace.prototype.compute_distance = function (result) {
            var total = 0,
                i,
                myroute = result.routes[0],
                rlen = myroute.legs.length;

            for (i = 0; i < rlen; i++) {
                total += myroute.legs[i].distance.value;
            }

            return total;
        };

        //wrapper for the infowindow types
        Maplace.prototype.type_to_open = {
            //google default infowindow
            bubble: function (location) {
                this.infowindow = new google.maps.InfoWindow({
                    content: location.html || ''
                });
            }
        };

        //open the infowindow
        Maplace.prototype.open_infowindow = function (index, marker, ev) {
            //close if any open
            this.CloseInfoWindow();
            var point = this.o.locations[index],
                type = this.o.infowindow_type;

            //show if content and valid infowindow type provided
            if (point.html && this.type_to_open[type]) {
                this.o.beforeOpenInfowindow(index, point, marker);
                this.type_to_open[type].call(this, point);
                this.infowindow.open(this.oMap, marker);
                this.o.afterOpenInfowindow(index, point, marker);
            }
        };

        //gets the html for the menu
        Maplace.prototype.get_html_controls = function () {
            if (this.controls[this.o.controls_type] && this.controls[this.o.controls_type].getHtml) {
                this.current_control = this.controls[this.o.controls_type];

                return this.current_control.getHtml.apply(this);
            }
            return '';
        };

        //creates the controls menu
        Maplace.prototype.generate_controls = function () {
            //append menu on the div container
            if (!this.o.controls_on_map) {
                this.controls_wrapper.empty();
                this.controls_wrapper.append(this.get_html_controls());
                return;
            }

            //else 
            //controls in map
            var cntr = $('<div class="on_gmap ' + this.o.controls_type + ' gmap_controls"></div>')
                .css(this.o.controls_applycss ? { margin: '5px' } : {}),

                inner = $(this.get_html_controls()).css(this.o.controls_applycss ? {
                    background: '#fff',
                    padding: '5px',
                    border: '1px solid rgb(113,123,135)',
                    boxShadow: 'rgba(0, 0, 0, 0.4) 0px 2px 4px',
                    maxHeight: this.map_div.find('.canvas_map').outerHeight() - 80,
                    minWidth: 100,
                    overflowY: 'auto',
                    overflowX: 'hidden'
                } : {});

            cntr.append(inner);

            //attach controls
            this.oMap.controls[this.o.controls_position].push(cntr.get(0));
        };

        //resets obj map, markers, bounds, listeners, controllers
        Maplace.prototype.init_map = function () {
            var self = this;

            this.Polyline && this.Polyline.setMap(null);
            this.Polygon && this.Polygon.setMap(null);
            this.Fusion && this.Fusion.setMap(null);
            this.directionsDisplay && this.directionsDisplay.setMap(null);

            for (var i = this.markers.length - 1; i >= 0; i -= 1) {
                try { 
                    this.markers[i] && this.markers[i].setMap(null);
                } catch (err) {
                    self.debug('init_map::markers::setMap', err.stack);
                }
            }

            this.markers.length = 0;
            this.markers = [];

            for (var i = this.circles.length - 1; i >= 0; i -= 1) {
                try { 
                    this.circles[i] && this.circles[i].setMap(null);
                } catch (err) {
                    self.debug('init_map::circles::setMap', err.stack);
                }
            }

            this.circles.length = 0;
            this.circles = [];

            if (this.o.controls_on_map && this.oMap.controls) {
                this.oMap.controls[this.o.controls_position].forEach(function (element, index) {
                    try {
                        self.oMap.controls[this.o.controls_position].removeAt(index);
                    } catch (err) { 
                        self.debug('init_map::removeAt', err.stack);
                    }
                });
            }

            this.oBounds = new google.maps.LatLngBounds();
        };

        //perform the first view of the map
        Maplace.prototype.perform_load = function () {
            //one location
            if (this.ln === 1) {
                if (this.o.map_options.set_center) {
                    this.oMap.setCenter(new google.maps.LatLng(this.o.map_options.set_center[0], this.o.map_options.set_center[1]));
                
                } else {
                    this.oMap.fitBounds(this.oBounds);
                    this.ViewOnMap(1);
                }

                this.o.map_options.zoom && this.oMap.setZoom(this.o.map_options.zoom);

            //no locations
            } else if (this.ln === 0) {
                if (this.o.map_options.set_center) {
                    this.oMap.setCenter(new google.maps.LatLng(this.o.map_options.set_center[0], this.o.map_options.set_center[1]));
                
                } else {
                    this.oMap.fitBounds(this.oBounds);
                }

                this.oMap.setZoom(this.o.map_options.zoom || 1);

            //n+ locations
            } else {
                this.oMap.fitBounds(this.oBounds);
                
                //check the start option
                if (typeof (this.o.start - 0) === 'number' && this.o.start > 0 && this.o.start <= this.ln) {
                    this.ViewOnMap(this.o.start);
                
                //check if set_center exists
                } else if (this.o.map_options.set_center) {
                    this.oMap.setCenter(new google.maps.LatLng(this.o.map_options.set_center[0], this.o.map_options.set_center[1]));
                
                //view all
                } else {
                    this.ViewOnMap(this.view_all_key);
                }

                this.o.map_options.zoom && this.oMap.setZoom(this.o.map_options.zoom);
            }
        };

        Maplace.prototype.debug = function (code, msg) {
            this.o.debug && console.log(code, msg);
            return this;
        };


        /////////////////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////////////////


        //adds a custom menu to the class
        Maplace.prototype.AddControl = function (name, func) {
            if (!name || !func) {
                self.debug('AddControl', 'Missing "name" and "func" callback.');
                return false;
            }
            this.controls[name] = func;
            return this;
        };

        //close the infowindow
        Maplace.prototype.CloseInfoWindow = function () {
            if (this.infowindow && (this.current_index || this.current_index === 0)) {
                this.o.beforeCloseInfowindow(this.current_index, this.o.locations[this.current_index]);
                this.infowindow.close();
                this.infowindow = null;
                this.o.afterCloseInfowindow(this.current_index, this.o.locations[this.current_index]);
            }
            return this;
        };

        //checks if a location has to be in menu
        Maplace.prototype.ShowOnMenu = function (index) {
            if (index === this.view_all_key && this.o.view_all && this.ln > 1) {
                return true;
            }

            index = parseInt(index, 10);
            if (typeof (index - 0) === 'number' && index >= 0 && index < this.ln) {
                var on_menu = this.o.locations[index].on_menu === false ? false : true;
                if (on_menu) {
                    return true;
                }
            }

            return false;
        };

        //triggers to show a location in map
        Maplace.prototype.ViewOnMap = function (index) {
            //view all
            if (index === this.view_all_key) {
                this.o.beforeViewAll();
                this.current_index = index;
                if (this.o.locations.length > 0 && this.o.generate_controls && this.current_control && this.current_control.activateCurrent) {
                    this.current_control.activateCurrent.apply(this, [index]);
                }
                this.oMap.fitBounds(this.oBounds);
                this.CloseInfoWindow();
                this.o.afterViewAll();

            //specific location
            } else {
                index = parseInt(index, 10);
                if (typeof (index - 0) === 'number' && index > 0 && index <= this.ln) {
                    try {
                        google.maps.event.trigger(this.markers[index - 1], 'click');
                    } catch (err) {
                        this.debug('ViewOnMap::trigger', err.stack);
                    }
                }
            }
            return this;
        };

        //replace current locations
        Maplace.prototype.SetLocations = function (locs, reload) {
            this.o.locations = locs;
            reload && this.Load();
            return this;
        };

        //adds one or more locations to the end of the array
        Maplace.prototype.AddLocations = function (locs, reload) {
            var self = this;

            if (Array.isArray(locs)) {
                $.each(locs, function (index, value) {
                    self.o.locations.push(value);
                });
            }

            if ($.isPlainObject(locs)) {
                this.o.locations.push(locs);
            }

            reload && this.Load();
            return this;
        };

        //adds a location at the specific index
        Maplace.prototype.AddLocation = function (location, index, reload) {
            var self = this;

            if ($.isPlainObject(location)) {
                this.o.locations.splice(index, 0, location);
            }

            reload && this.Load();
            return this;
        };

        //remove one or more locations
        Maplace.prototype.RemoveLocations = function (locs, reload) {
            var self = this,
                k = 0;

            if (Array.isArray(locs)) {
                $.each(locs, function (index, value) {
                    if ((value - k) < self.ln) {
                        self.o.locations.splice(value-k, 1);
                    }
                    k++;
                });
            } else {
                if (locs < this.ln) {
                    this.o.locations.splice(locs, 1);
                }
            }

            reload && this.Load();
            return this;
        };

        //check if already initialized with a Load()
        Maplace.prototype.Loaded = function () {
            return this.loaded;
        };

        //loads the options
        Maplace.prototype._init = function () {
            //store the locations length
            this.ln = this.o.locations.length;

            //update all locations with shared
            for (var i = 0; i < this.ln; i++) {
                var common = $.extend({}, this.o.shared);
                this.o.locations[i] = $.extend(common, this.o.locations[i]);
                if (this.o.locations[i].html) {
                    this.o.locations[i].html = this.o.locations[i].html.replace('%index', i + 1);
                    this.o.locations[i].html = this.o.locations[i].html.replace('%title', (this.o.locations[i].title || ''));
                }
            }

            //store dom references
            this.map_div = $(this.o.map_div);
            this.controls_wrapper = $(this.o.controls_div);
            return this;
        };

        //creates the map and menu
        Maplace.prototype.Load = function (args) {
            $.extend(true, this.o, args);
            args && args.locations && (this.o.locations = args.locations);
            this._init();

            //reset/init google map objects
            this.o.visualRefresh === false ? (google.maps.visualRefresh = false) : (google.maps.visualRefresh = true);
            this.init_map();
            this.create_objMap();

            //add markers
            this.add_markers_to_objMap();
            
            //generate controls
            if ((this.ln > 1 && this.o.generate_controls) || this.o.force_generate_controls)  {
                this.o.generate_controls = true;
                this.generate_controls();
            } else {
                this.o.generate_controls = false;
            }

            var self = this;

            //first call
            if (!this.loaded) {
                google.maps.event.addListenerOnce(this.oMap, 'idle', function () {
                    self.perform_load();
                });

                //adapt the div size on resize
                google.maps.event.addListener(this.oMap, 'resize', function () {
                    self.canvas_map.css({
                        width: self.map_div.width(),
                        height: self.map_div.height()
                    });
                });

                //add custom listeners
                var i;
                for (i in this.o.listeners) {
                    var map = this.oMap,
                        myListener = this.o.listeners[i];

                    if (this.o.listeners.hasOwnProperty(i)) {
                        google.maps.event.addListener(this.oMap, i, function (event) {
                            myListener(map, event);
                        });
                    }
                }
            //all other calls
            } else {
                this.perform_load();
            }

            this.loaded = true;

            return this;
        };


        return Maplace;

    })();


    if (typeof define == 'function' && define.amd) {
        define(function() { return Maplace; });
    } else {
        window.Maplace = Maplace;
    }

})(jQuery, this, google);
