Ext.namespace('lbgm.maplets');


// public methods
lbgm.maplets.mapobject = {

    map: null,
    tools: [],
    counter: 0,
    loadInit: true,
    layerloading: true,
    geocoding: false,
    gcCallback: null,
    geolocate: null,

    aResolutions: new Array(
                                156543.0339,
                                78271.51695,
                                39135.758475,
                                19567.8792375,
                                9783.93961875,
                                4891.969809375,
                                2445.9849046875,
                                1222.99245234375,
                                611.496226171875,
                                305.7481130859375,
                                152.87405654296876,
                                76.43702827148438,
                                38.21851413574219,
                                19.109257067871095,
                                9.554628533935547,
                                4.777314266967774,
                                2.388657133483887,
                                1.1943285667419434,
                                0.5971642833709717),

    vResolutions: null/*new Array(
                                    611.496226171875,
                                    305.7481130859375,
                                    152.87405654296876,
                                    76.43702827148438,
                                    38.21851413574219,
                                    19.109257067871095,
                                    9.554628533935547,
                                    4.777314266967774,
                                    2.388657133483887,
                                    1.1943285667419434,
                                    0.5971642833709717)*/,
    

    init: function(config) {

        Ext.apply(this, config);

        //OpenLayers.
        OpenLayers.ImgPath = "src/js/OpenLayers/themes/lb/images/";
        OpenLayers.Util.onImageLoadErrorColor = "transparent";
        OpenLayers.Util.onImageLoadError = function() {
            this.src='/geomaps/src/images/empty_tile.png';//'http://www.informationfreeway.org/images/emptysea.png';
        }

        this.createMap();
        this.loadLayers();
    },
    
    createMap: function() {

        this.vResolutions = new Array();
        var j=0;
        for(var i=lbgm.layout.minzoomlevel; i<this.aResolutions.length; i++) {
            this.vResolutions[j++] = this.aResolutions[i];
        }

        var left = -20037508.34;
        var bottom = -20037508.34;
        var right = 20037508.34;
        var top = 20037508.34;

        if(lbgm.layout.mapboundsleft != '') {
            left = lbgm.layout.mapboundsleft;
            bottom = lbgm.layout.mapboundsbottom;
            right = lbgm.layout.mapboundsright;
            top = lbgm.layout.mapboundstop;
        }

        this.mapoptions = {

            maxExtent: new OpenLayers.Bounds(-20037508.34,-20037508.34,20037508.34,20037508.34),
            //maxExtent: new OpenLayers.Bounds(3360485.167, 3637105.211,4031501.759, 4429549.126),

            maxResolution:156543.0339,
            //maxResolution:3095.48404296875,
            //maxResolution:305.7481130859375,
            //maxResolution:"auto",
            units:'m',
            //numZoomLevels: 20,
            projection: "EPSG:900913",
            displayProjection: new OpenLayers.Projection("EPSG:4326"),
            eventListeners: {
                "zoomend": this.zoomEnd
            },

            //3446395.7752, 3920217.97966, 3908071.09937, 4375777.00756
            restrictedExtent: new OpenLayers.Bounds(left,bottom,right,top),
            controls: []
        };

        this.map = new OpenLayers.Map ('geomaticmap',  this.mapoptions);
        this.mapcomponent = new lbgm.maplets.mapcomponent({map: this.map});

        //var loadingpanel = new OpenLayers.Control.LoadingPanel();
        //this.map.addControl(loadingpanel);
        // Map Event
        //this.map.events.register('preaddlayer', this, this.addLayer);

        

        // Activate Click Event
        //var click = new OpenLayers.Control.Click({map:this.map});
        //this.map.addControl(click);
        //click.activate();

        // Tooltips
        this.ttips = new OpenLayers.Control.ToolTips({id: "tooltips", mapid:"geomaticmap"});
        this.map.addControl(this.ttips);

        this.geolocate = new OpenLayers.Control.Geolocate({
            geolocationOptions: {
                enableHighAccuracy: false,
                maximumAge: 0,
                timeout: 7000
            }
        });
        this.map.addControl(this.geolocate);

        this.geolocate.events.register("locationupdated",this, this.myLocation);

        this.map.events.register('mousedown', this.map, this.onMouseDown);
        this.map.events.register('mouseup', this.map, this.onMouseUp);
    },

    addLayer: function(evt) {
        if (evt.layer) {
            //evt.layer.events.register('loadstart', evt.layer, this.increaseCounter);
            //evt.layer.events.register('loadend', evt.layer, this.decreaseCounter);
        }

    },

    loadLayers: function() {
        // AJAX to load layout
        var conn = new Ext.data.Connection();
        conn.request({
            url: 'src/php/conn/layers.conn.php',
            method: 'POST',
            params: {"request": "loadMapLayers", "appid": lbgm.layout.appid},
            success: function(responseObject) {
               obj = Ext.util.JSON.decode(responseObject.responseText);
               //alert('Doing Layout ' + this.layoutid);
               //var viewport = eval(obj.results);
               Ext.each(obj.layers, function(layer){

                   //alert(this.map.getNumLayers());

                   var isbase = false;
                   var isdefault = false;
                   if(layer.isbase == "1") isbase = true;
                   if(layer.isdefault == "1") isdefault = true;

                   var llayers = layer.layerid
                   if(layer.layers != null) {
                       llayers = layer.layers;
                   }

                   // Url or folder
                   var layertiles = layer.tilesfolder != '' ? layer.tilesfolder : layer.tileslink;
                   
                   //alert(layer.layertitle + "  " + layer.layers);

                    if(layer.layertype == 0) {
                       var tmsBase = isbase;
                       var ll = new OpenLayers.Layer.TMS(
                            layer.layertitle,
                            layertiles,
                            {
                                'type':'png',
                                'getURL': get_my_url,
                                'isBaseLayer': isbase,
                                //'opacity': 0.5,
                                /*eventListeners: {
                                    "loadstart": this.increaseCounter,
                                    "loadend": this.decreaseCounter,
                                    scope: this
                                },*/
                                //'transparent': true,
                                layers: llayers,
                                transitionEffect: isbase ? 'resize' : '',
                                //numZoomLevels: 19,
                                //minZoomLevel: 8, maxZoomLevel: 18,
                                serverResolutions: this.resolutions,
                                resolutions: this.vResolutions,
                                buffer: 0
                            }
                        );

                        //ll.events.register('loadstart', null, this.increaseCounter);
                        //ll.events.register('loadend', null, function() {alert('sdfsdfsdf');});

                        this.map.addLayer(ll);
                        if(isdefault && isbase) this.map.setBaseLayer(ll);
                        else if(isdefault) ll.setVisibility(true);
                        else ll.setVisibility(false);
                   }
                   else if(layer.layertype == 1) {
                       var ll = new OpenLayers.Layer.Google(
                            layer.layertitle,
                            {type: G_PHYSICAL_MAP,
                                'sphericalMercator': true,
                                'isBaseLayer': isbase,
                                layers: llayers,
                                transitionEffect: 'resize',
                                //numZoomLevels: 19,
                                minZoomLevel: parseInt(lbgm.layout.minzoomlevel),
                                maxZoomLevel: 18
                                
                            }
                        );

                        this.map.addLayer(ll);
                        if(isdefault && isbase) this.map.setBaseLayer(ll);

                        
                   }
                   else if(layer.layertype == 2) {// Google Sat
                       var ll = new OpenLayers.Layer.Google(
                            layer.layertitle,
                            {
                                type: G_SATELLITE_MAP,
                                'sphericalMercator': true,
                                'isBaseLayer': isbase,
                                layers: llayers,
                                transitionEffect: 'resize',
                                //numZoomLevels: 19,
                                minZoomLevel: parseInt(lbgm.layout.minzoomlevel),
                                maxZoomLevel: 18
                            }
                        );

                        this.map.addLayer(ll);
                        if(isdefault && isbase) this.map.setBaseLayer(ll);
                   }
                   else if(layer.layertype == 3) {
                       var ll = new OpenLayers.Layer.Google(
                            layer.layertitle,
                            {
                                type: G_HYBRID_MAP,
                                'sphericalMercator': true,
                                'isBaseLayer': isbase,
                                layers: llayers,
                                transitionEffect: 'resize',
                                //numZoomLevels: 18,
                                minZoomLevel: parseInt(lbgm.layout.minzoomlevel),
                                maxZoomLevel: 18
                            }
                        );

                        this.map.addLayer(ll);
                        if(isdefault && isbase) this.map.setBaseLayer(ll);
                   }
                   else if(layer.layertype == 4) {
                       var ll = new OpenLayers.Layer.Google(
                            layer.layertitle,
                            {
                                'sphericalMercator': true,
                                layers: llayers,
                                'isBaseLayer': isbase,
                                transitionEffect: 'resize',
                                //numZoomLevels: 18
                                minZoomLevel: parseInt(lbgm.layout.minzoomlevel),
                                maxZoomLevel: 18
                            }
                        );

                        this.map.addLayer(ll);
                        if(isdefault && isbase) this.map.setBaseLayer(ll);
                   }
                   else if(layer.layertype == 5) {
                        this.vector = new OpenLayers.Layer.Vector(layer.layertitle);
                        this.map.addLayer(this.vector);
                        this.vector.setVisibility(false);
                   }
                   else if(layer.layertype == 6) { // WMS
                       
                       // setup tiled layer
                       OpenLayers.IMAGE_RELOAD_ATTEMPTS = 5;
                       // make OL compute scale according to WMS spec
                       OpenLayers.DOTS_PER_INCH = 25.4 / 0.28;


                        var tiled = new OpenLayers.Layer.WMS(
                            layer.layertitle, "http://geomatic.com.cy:8054/geoserver/gwc/service/wms",
                            {
                                layers: layer.layerdescription,
                                styles: '',
                                srs: 'EPSG:900913',
                                format: 'image/png',
                                tiled: 'true',
                                transitionEffect: 'resize',
                                tilesOrigin : this.map.maxExtent.left + ',' + this.map.maxExtent.bottom,
                                transparent: (!isbase)
                            },
                            {
                                buffer: 0,
                                displayOutsideMaxExtent: true,
                                maxExtent: new OpenLayers.Bounds(3360512.788, 3637165.478, 4031546.679, 4429493.436),
                                maxResolution:3095.0310859374986,
                                //serverResolutions: this.resolutions,
                                //resolutions: this.vResolutions,
                                minZoomLevel: 10,
                                maxZoomLevel: 12,
                                'isBaseLayer': isbase
                            }
                        );

                        this.map.addLayer(tiled);
                        if(isdefault && isbase) this.map.setBaseLayer(tiled);
                   }
                   

               }, this);

            },
            failure: function() {
               Ext.Msg.alert(lbgm.optios.appname, 'Unable to load layers.');
            },
            scope: this,
            callback: this.initCont
        });

    },

    createControls: function() {

        /*
         *  Add
         *  Controls
         */
        this.map.addControl(new OpenLayers.Control.PanZoomBar({zoomWorldIcon: false}));
        //this.map.addControl(new OpenLayers.Control.LayerSwitcher());
        //map.addControl(new OpenLayers.Control.Permalink());
        this.map.addControl(new OpenLayers.Control.ScaleLine());
        //map.addControl(new OpenLayers.Control.Permalink('permalink'));

    },

    centerMap: function() {
        var lon = '33.3';
        var lat = '35.2';
        var zoomlvl = 9;

        if(lbgm.layout.initlongitude!='') lon = lbgm.layout.initlongitude;
        if(lbgm.layout.initlatitude!='') lat = lbgm.layout.initlatitude;

        // Zoom to sent zoomlevel
        var url =  document.URL;
        url = url.replace("#", "");
        var getParams =url.split("?");

        if(getParams.length > 1 ) {
           this.urlparams = Ext.urlDecode(getParams[1]);
           
           
           if(this.urlparams['z'] != undefined) {
               //this.map.zoomTo(zoomlvl - zoffset);
               zoomlvl = this.urlparams['z'];
           }


           if(this.urlparams['lon'] != undefined && this.urlparams['lat'] != undefined) {
               //var lonlat = new OpenLayers.LonLat(lon, lat) ;
               //lonlat.transform(this.map.displayProjection,this.map.getProjectionObject());
               //this.map.panTo(lonlat);
                lon = this.urlparams['lon'];
                lat = this.urlparams['lat'];
           }
         }

        var zoffset = (this.aResolutions.length - this.vResolutions.length);
        if(this.lonlat == undefined) this.lonLat = new OpenLayers.LonLat(lon, lat) ; // 10.2, 48.9
        this.lonLat.transform(this.map.displayProjection,this.map.getProjectionObject());

        if(this.zoomlevel==undefined)this.zoomlevel = zoomlvl - zoffset;
        //this.map.zoomToMaxExtent();
        this.map.setCenter(this.lonLat, this.zoomlevel);
    },

    createMainToolbar: function() {
        this.maintoolbar = new lbgm.maplets.toolbar({map: this.map});
        // Toolbar actions
        this.maintoolbar.addControl(
            new OpenLayers.Control.ZoomToMaxExtent({map: this.map}), {
            icon: 'src/images/fullextent.png',
            tooltip: "Zoom to Max Extent"
        });

        this.maintoolbar.addSpacer();
        this.maintoolbar.addSeparator();
        this.maintoolbar.addSpacer();

        this.maintoolbar.addControl(
            new OpenLayers.Control.Navigation({
                map: this.map,
                eventListeners: {
                    activate: function() {
                        this.map.div.style.cursor = "url(../images/openhand.cur), url(src/images/openhand.cur), default";
                    }
                }
            }), {
            icon: 'src/images/dragpan.png', // icons can also be specified inline
            // button options
            toggleGroup: "navi",
            allowDepress: false,
            pressed: true,
            tooltip: "navigate",
            // check item options
            group: "navi",
            checked: true
        });

        this.maintoolbar.addControl(
            new OpenLayers.Control.ZoomBox({
                map: this.map,
                eventListeners: {
                    activate: function() {
                        this.map.div.style.cursor = "crosshair";
                    }
                }
            }), {
            icon: 'src/images/zoominbox.png',
            //text: "Zoom Box In",
            tooltip: "Left click and drag to create the zoombox",
            // button options
            toggleGroup: "navi",
            allowDepress: false,
            pressed: false
        });

        this.maintoolbar.addControl(
            new OpenLayers.Control.ZoomBox({
                map: this.map,
                out: true,
                eventListeners: {
                    activate: function() {
                        this.map.div.style.cursor = "crosshair";
                    }
                }
            }), {
            icon: 'src/images/zoomoutbox.png',
            //text: "Zoom Box Out",
            tooltip: "Left click and drag to create the zoombox",
            // button options
            toggleGroup: "navi",
            allowDepress: false,
            pressed: false
        });

        this.maintoolbar.addSpacer();
        this.maintoolbar.addSeparator();
        this.maintoolbar.addSpacer();

        // Navigation history - two "button" controls
        var nav = new OpenLayers.Control.NavigationHistory();
        this.map.addControl(nav);
        nav.activate();

        var buttonPrevious = new Ext.Toolbar.Button({
            icon: 'src/images/previousextent.png',
            tooltip: "Previous in History",
            disabled: true,
            handler: nav.previous.trigger
        });

        var buttonNext = new Ext.Toolbar.Button({
            icon: 'src/images/nextextent.png',
            tooltip: "Next in History",
            disabled: true,
            handler: nav.next.trigger
        });

        this.maintoolbar.add(buttonPrevious);
        this.maintoolbar.add(buttonNext);

        nav.previous.events.register(
            "activate",
            buttonPrevious,
            function() {
                this.setDisabled(false);
            }
        );

        nav.previous.events.register(
            "deactivate",
            buttonPrevious,
            function() {
                this.setDisabled(true);
            }
        );

        nav.next.events.register(
            "activate",
            buttonNext,
            function(){
                this.setDisabled(false);
            }
        );

        nav.next.events.register(
            "deactivate",
            buttonNext,
            function() {
                this.setDisabled(true);
            }
        );

        this.maintoolbar.activate();

    },

    createToolsToolbar: function() {

        if(this.vector != undefined && this.vector != null) {

            this.toolstoolbar = new lbgm.maplets.toolbar({map: this.map});

            /*this.toolstoolbar.addControl(
                new OpenLayers.Control.DrawFeature(
                    this.vector, OpenLayers.Handler.Path, {
                        map: this.map,
                        featureAdded: function(feature) {
                            alert(feature.geometry.toString());
                            //lbgm.popup.showPopup(feature);
                        }
                    }
                ), {
                //text: "draw line",
                icon: 'src/images/draw_line_off.png',
                // button options
                toggleGroup: "draw",
                allowDepress: false,
                tooltip: "Draw Line",
                // check item options
                group: "draw"
            });

            this.toolstoolbar.addControl(
                new OpenLayers.Control.DrawFeature(
                    this.vector, OpenLayers.Handler.Polygon, {map: this.map}
                ),{
                //text: "draw poly",
                icon: 'src/images/draw_polygon_off.png',
                // button options
                toggleGroup: "draw",
                allowDepress: false,
                tooltip: "Draw Polygon",
                // check item options
                group: "draw"
            });

            this.toolstoolbar.addSpacer();
            this.toolstoolbar.addSeparator();
            this.toolstoolbar.addSpacer();
                
            this.toolstoolbar.addControl(
                new OpenLayers.Control.SelectFeature(this.vector, {
                    type: OpenLayers.Control.TYPE_TOGGLE,
                    hover: true,
                    map: this.map
                }), {
                //text: "select",
                icon: "src/images/cursor.png",
                // button options
                enableToggle: true,
                tooltip: "select feature"
            });

            this.toolstoolbar.addSpacer();
            this.toolstoolbar.addSeparator();
            this.toolstoolbar.addSpacer();
                */

            // style the sketch fancy
            var sketchSymbolizers = {
                "Point": {
                    pointRadius: 4,
                    graphicName: "square",
                    fillColor: "white",
                    fillOpacity: 1,
                    strokeWidth: 1,
                    strokeOpacity: 1,
                    strokeColor: "#333333"
                },
                "Line": {
                    strokeWidth: 3,
                    strokeOpacity: 1,
                    strokeColor: "#666666",
                    strokeDashstyle: "dash"
                },
                "Polygon": {
                    strokeWidth: 2,
                    strokeOpacity: 1,
                    strokeColor: "#666666",
                    fillColor: "white",
                    fillOpacity: 0.3
                }
            };
            var style = new OpenLayers.Style();
            style.addRules([
                new OpenLayers.Rule({symbolizer: sketchSymbolizers})
            ]);
            var styleMap = new OpenLayers.StyleMap({"default": style})

            this.toolstoolbar.addControl(
                new OpenLayers.Control.Measure(OpenLayers.Handler.Path, {
                    persist: true,
                    handlerOptions: {
                        layerOptions: {styleMap: styleMap}
                    },
                    eventListeners: {
                        measure: function(evt) {
                            Ext.get('mesureOP').update("<b>Length: </b>" + String(evt.measure).substring(0,8) + ' ' +evt.units);
                            //Ext.get('mesureOP').doLayout();
                            /*Ext.Msg.show({
                                title: 'Length',
                                msg: String(evt.measure).substring(0,8) + ' ' +evt.units,
                                icon: Ext.MessageBox.INFO
                            });*/
                            //alert("The length was " + evt.measure + evt.units);
                        },
                        measurepartial: function(evt) {Ext.get('mesureOP').update("<b>Area: </b>" + String(evt.measure).substring(0,8) + ' ' +evt.units);},
                        activate: function() {this.map.div.style.cursor = "crosshair";}
                    }, map: this.map
                }), {
                //text: "Length",
                icon: 'src/images/measurelength.png',
                // button options
                toggleGroup: "navi",
                allowDepress: false,
                tooltip: "Mesure Length",
                // check item options
                group: "navi"
            });

            this.toolstoolbar.addControl(
                new OpenLayers.Control.Measure(OpenLayers.Handler.Polygon, {
                    persist: true,
                    handlerOptions: {
                        layerOptions: {styleMap: styleMap}
                    },
                    eventListeners: {
                        measure: function(evt) {Ext.get('mesureOP').update("<b>Area: </b>" + String(evt.measure).substring(0,8) + ' ' +evt.units);},
                        measurepartial: function(evt) {Ext.get('mesureOP').update("<b>Area: </b>" + String(evt.measure).substring(0,8) + ' ' +evt.units);},
                        activate: function() {this.map.div.style.cursor = "crosshair";}
                            /*Ext.Msg.show({
                                title: 'Area',
                                msg: String(evt.measure).substring(0,8) + ' ' + evt.units,
                                icon: Ext.MessageBox.INFO
                            });*/
                            //alert("The length was " + evt.measure + evt.units);
                    }, map: this.map
                }), {
                //text: "Area",
                icon: 'src/images/measurearea.png',
                // button options
                toggleGroup: "navi",
                allowDepress: false,
                tooltip: "Mesure Area",
                // check item options
                group: "navi"
            });

            this.toolstoolbar.add({
                xtype: 'tbtext',
                text: '...',
                id: 'mesureOP'
            });

            this.toolsWnd = new Ext.Window({
                id: "map-tools",
                //animateTarget: 'tb_tools_btn',
                //layout:'anchor',
                width:250,
                height:58,
                closeAction:'hide',
                plain: false,
                closable: true,
                draggable: true,
                title: 'Mesurement Tools',
                constrain: true,
                autoScroll: true,
                resizable: false,
                style: {opacity:0.85},
                items: [this.toolstoolbar],
                //x: button.getEl().getX(),
                //y: button.getEl().getY() + 27,
                listeners: {
                    hide: {
                        scope: this,
                        fn: function() {
                            //alert('test');
                            this.maintoolbar._buttons[1].toggle(true);
                            //this.tools.navaction.items[0].toggle();
                            //lbgm.maplets.mapobject.map.div.style.cursor = 'default';
                        }
                    }
                }
            });

            this.tools.vector = new Ext.Button({
                id: "tb_tools_btn",
                icon: 'gmadmin/images/icons/cog.png',
                text: "Tools",
                tooltip: "Mesurement tools",
                listeners: {
                    click: {
                        scope: this,
                        fn: function(button, e) {
                            //if(!Ext.get('map-tools')) {
                               
                                this.toolsWnd.show();
                            //}
                        }
                    }
                }
            });
        }
    },

    initCont: function() {
        //this.markers = new OpenLayers.Layer.Markers("Markers", {displayInLayerSwitcher: false});
        //this.map.addLayer(this.markers);
        //this.markers.setVisibility(true);

        this.createControls();
        this.createMainToolbar();
        this.createToolsToolbar();

        lbgm.LayoutLoadCont();
        
        this.centerMap();

        //this.touchhandler = new TouchHandler( this.map, 4 );

    },

    zoomEnd: function() {
        //alert('sdds');
        //if(!lbgm.maplets.mapobject.loadInit)
        if(!lbgm.layout.initializing) {
            lbgm.maplets.poitree.loadPois();
            lbgm.maplets.mapobject.ttips.hide();
        }
    },

    increaseCounter: function() {
        lbgm.maplets.layerloading = true;
        lbgm.maplets.mapobject.counter++;

        //console.log("Inc: " +lbgm.maplets.mapobject.counter);
    },

    decreaseCounter: function() {
        //console.log("Dec: " +lbgm.maplets.mapobject.counter);
        if(lbgm.maplets.mapobject.counter > 0) {
            lbgm.maplets.mapobject.counter--;
        }

        if(lbgm.maplets.mapobject.counter == 0) {
            lbgm.maplets.mapobject.layersLoaded();
        }
    },

    layersLoaded: function() {
        //console.log('LOADED');
        //if(!lbgm.point.pointslayerPrepared) lbgm.point.preparePointLayer();
        if(lbgm.layout.initializing) {
            var getParams = document.URL.split("?");
            if(getParams.length > 1 ) {
               var urlparams = Ext.urlDecode(getParams[1]);
               if(urlparams['lon']!=undefined || urlparams['p']!=undefined || urlparams['a']!=undefined)
                   lbgm.point.showInitPoint();
               else {
                   if(urlparams['nvf_lat']!=undefined && urlparams['nvf_lon']!=undefined &&
                        urlparams['nvt_lat']!=undefined && urlparams['nvt_lon']!=undefined) {
                       lbgm.navigation.showInitNavigation(urlparams['nvf_lat'], urlparams['nvf_lon'], urlparams['nvt_lat'], urlparams['nvt_lon']);
                   }
               }
            }
            
            lbgm.layout.initializing = false;
            //lbgm.maplets.poitree.loadPois();
        }

        lbgm.maplets.layerloading = false;

        if(lbgm.maplets.popupcallbackF != undefined && lbgm.maplets.popupcallbackF != null) {
            lbgm.popup.showPopup(lbgm.maplets.popupcallbackF);
            lbgm.maplets.popupcallbackF = null;
        }
    },

    onMouseDown: function(e) {
       if(e.button == 2) {
           OpenLayers.Event.stop(e);
           lbgm.maplets.mapobject.map.div.oncontextmenu = function() {return false;}
       } 


       return false;
    },

    onMouseUp: function(e) {
        if(e.button == 2) {
            if(!lbgm.maplets.layerloading) {
               if(e.xy == undefined) e.xy = new OpenLayers.Pixel(e.layerX, e.layerY);
               lbgm.maplets.mapobject.showMenu(e.clientX, e.clientY, e.xy);
               OpenLayers.Event.stop(e);
            }
            
        }
        else {
            if(lbgm.maplets.mapobject.geocoding == true) {
                lbgm.maplets.mapobject.gcCallback.onMouseUp(e);
                OpenLayers.Event.stop(e);
            }
            else {
               lbgm.maplets.mapobject.hideMenu();

               if(lbgm.point.addPoint && !lbgm.point.adding) {
                    var lonlat = lbgm.maplets.mapobject.map.getLonLatFromViewPortPx(e.xy);
                    //alert("You clicked near " + lonlat.lat + " N, " +
                    //                          + lonlat.lon + " E");
                    lbgm.point.newPoint(lonlat);
                }
                if(lbgm.point.addPlacemark && !lbgm.point.addingPlacemark) {
                    var lonlat = lbgm.maplets.mapobject.map.getLonLatFromViewPortPx(e.xy);
                    lbgm.point.newPlacemark(lonlat);
                }
            }
        }
       
    },

    showMenu: function(x, y, pixel) {

        this.hideMenu();

        this.menu = new Ext.menu.Menu({
                    id: 'main_menu',
                    floating: true,
                    hidden: true,
                    defaultOffsets: [5,5],
                    shadow: false,
                    x: 100,
                    y: 100,
                    renderTo: Ext.getBody(),
                    items: []
                });

        var lonlat = this.map.getLonLatFromViewPortPx(pixel);
        //lonlat.transform(lbgm.maplets.mapobject.map.getProjectionObject(), lbgm.maplets.mapobject.map.displayProjection);
        // Add menu options

        // ** Nearest
        if(lbgm.layout.enablenearest == 1) {
            this.menu.addMenuItem({
               id: 'point_near_btn',
               text: 'Nearest Points',
               icon: 'gmadmin/images/icons/map.png',
               //disabled: disabled,
               lonlat: lonlat,
               handler: this.onMenuClick
            });
            this.menu.addSeparator();
        }
/* REMOVE THIS */
/*
        this.menu.addMenuItem({
               id: 'point_near_route_btn',
               text: 'Nearest Routes',
               icon: 'gmadmin/images/icons/map.png',
               //disabled: disabled,
               lonlat: lonlat,
               handler: this.onMenuClick
            });
            this.menu.addSeparator();
*/
        // ** Navigation
        if(lbgm.layout.enablenavigation == 1) {
            this.menu.addMenuItem({
               id: 'point_navigatefrom_btn',
               text: 'Navigate From',
               icon: 'gmadmin/images/icons/flag_green.png',
               lonlat: lonlat,
               handler: this.onMenuClick
            });

            this.menu.addMenuItem({
               id: 'point_navigateto_btn',
               text: 'Navigate To',
               icon: 'gmadmin/images/icons/flag_red.png',
               lonlat: lonlat,
               handler: this.onMenuClick
            });

            this.menu.addSeparator();
        }
        // ** Identification
        if(lbgm.layout.enableidentification == 1) {
            this.menu.addMenuItem({
               id: 'point_id_btn',
               text: 'Identify',
               icon: 'gmadmin/images/icons/information.png',
               //disabled: disabled,
               lonlat: lonlat,
               handler: this.onMenuClick
            });

            this.menu.addSeparator();
        }
        // ** Share
        if(lbgm.layout.enableshare == 1) {
            this.menu.addMenuItem({
               id: 'point_share_btn',
               text: 'Share',
               //disabled: disabled,
               icon: 'gmadmin/images/icons/email.png',
               lonlat: lonlat,
               handler: this.onMenuClick
            });
        }

        lbgm.maplets.mapobject.ttips.hide();

        if(this.menu.items.length > 0) {
            var newX = x;
            var newY = y;

            if(x+this.menu.getWidth()+5 > lbgm.helper.getBrowserWidth()) newX = x - (this.menu.getWidth() + 5);
            if(y+this.menu.getHeight()+5 > lbgm.helper.getBrowserHeight()) newY = y -(this.menu.getHeight() + 5);

            this.menu.showAt([newX+5, newY+5]);
            this.blMenuVisible = true;
        }
    },

    hideMenu: function() {
        if(this.menu) {
           this.menu.hide();
           this.blMenuVisible = false;
           this.menu.removeAll(true);

           delete lbgm.maplets.mapobject.menu;

           //if(lbgm.point.menuVisible) lbgm.point.hideMenu();
            
        }

        //if(lbgm.maplets.mapobject.menu)
            

    },

    onMenuClick: function(btn) {
        if(btn.id == 'point_navigatefrom_btn') {
            lbgm.navigation.setNaviFrom(lbgm.point.featureFromLonLat(btn.lonlat));
        }
        else if(btn.id == 'point_navigateto_btn') {
            lbgm.navigation.setNaviTo(lbgm.point.featureFromLonLat(btn.lonlat));
        }
        else if(btn.id == 'point_share_btn') {
            lbgm.point.shareLocation(btn.lonlat);
        }
        else if(btn.id == "point_id_btn") {
            var tmpLonLat = btn.lonlat;
            tmpLonLat.transform(lbgm.maplets.mapobject.map.getProjectionObject(), lbgm.maplets.mapobject.map.displayProjection);

            /*var url = document.URL;
            url = url.replace("#", "");
            var getParams = url.split("?");
            var key = '';
            if(getParams.length > 1 ) {
                this.urlparams = Ext.urlDecode(getParams[1]);
                key = this.urlparams['key'];
            }*/

            OpenLayers.Request.POST({
                url: 'src/php/conn/identify.php',
                data: OpenLayers.Util.getParameterString({lat: tmpLonLat.lat, lon: tmpLonLat.lon, key: lbgm.layout.key}),
                success: function(responseObject) {
                   //alert(responseObject.responseText);
                   obj = Ext.util.JSON.decode(responseObject.responseText);
                   //eval(obj.results);
                   lbgm.point.displayPointIdent(tmpLonLat.transform(lbgm.maplets.mapobject.map.displayProjection, lbgm.maplets.mapobject.map.getProjectionObject()), obj);

                },
                failure: function() {
                   Ext.Msg.alert(lbgm.options.appname, 'Unable to identify');
                   // Move it back to its original position
                },
                headers: {
                    "Content-Type": "application/x-www-form-urlencoded"
                }

            });
        }
        else if(btn.id == "point_near_btn") {
            var tmpLonLat = btn.lonlat;
            tmpLonLat.transform(lbgm.maplets.mapobject.map.getProjectionObject(), lbgm.maplets.mapobject.map.displayProjection);

            var selCategories = lbgm.maplets.poitree.getChecked();
            if(selCategories == '')  {
                Ext.Msg.alert(lbgm.options.appname, 'Please select al least one category first');
                return;
            }
            
            OpenLayers.Request.POST({
                url: 'src/php/conn/rgeoc.php',
                data: OpenLayers.Util.getParameterString({lat: tmpLonLat.lat, lon: tmpLonLat.lon, categories: selCategories, appid: lbgm.layout.appid}),
                success: function(responseObject) {
                   //alert(responseObject.responseText);
                   obj = Ext.util.JSON.decode(responseObject.responseText);
                   //eval(obj.results);

                   // Set results on the left side
                   lbgm.point.displayNearPoints(obj);

                },
                failure: function() {
                   Ext.Msg.alert(lbgm.options.appname, 'Unable to identify');
                   // Move it back to its original position
                },
                headers: {
                    "Content-Type": "application/x-www-form-urlencoded"
                }

            });
        }
        else if(btn.id == "point_near_route_btn") {
            lbgm.plp.showLoading();

            var tmpLonLat = btn.lonlat;
            tmpLonLat.transform(lbgm.maplets.mapobject.map.getProjectionObject(), lbgm.maplets.mapobject.map.displayProjection);

            var displayVal = 'pois';

            OpenLayers.Request.POST({
                url: 'src/php/conn/rgeoc_plp.php',
                data: OpenLayers.Util.getParameterString({lat: tmpLonLat.lat, lon: tmpLonLat.lon, appid: lbgm.layout.appid, display: displayVal}),
                success: function(responseObject) {
                   //alert(responseObject.responseText);
                   obj = Ext.util.JSON.decode(responseObject.responseText);
                   
                   if(displayVal == 'pois') {
                       lbgm.plp.displayNearPoints(obj);
                   }
                   else {
                       lbgm.plp.displayNearPlp(obj);
                   }
                },
                failure: function() {
                   Ext.Msg.alert(lbgm.options.appname, 'Unable to identify');
                   // Move it back to its original position
                },
                headers: {
                    "Content-Type": "application/x-www-form-urlencoded"
                }

            });
        }

        //this.hideMenu();
    },

    getZoomOffset: function() {
        return (lbgm.maplets.mapobject.aResolutions.length - lbgm.maplets.mapobject.vResolutions.length);
    },

    getZoomLevel: function() {
        return this.map.getZoom() + this.getZoomOffset();
    },

    myLocation: function(e) {
        var style = {
            fillColor: '#000',
            fillOpacity: 0.1,
            strokeWidth: 0
        };

        this.vector.removeAllFeatures();
        var circle = new OpenLayers.Feature.Vector(
            OpenLayers.Geometry.Polygon.createRegularPolygon(
                new OpenLayers.Geometry.Point(e.point.x, e.point.y),
                e.position.coords.accuracy/2,
                40,
                0
            ),
            {},
            style
        );

        this.vector.addFeatures([
            new OpenLayers.Feature.Vector(
                e.point,
                {},
                {
                    graphicName: 'cross',
                    strokeColor: '#f00',
                    strokeWidth: 2,
                    fillOpacity: 0,
                    pointRadius: 10
                }
            ),
            circle
        ]);
        this.map.zoomToExtent(this.vector.getDataExtent());
        this.vector.setVisibility(true);
        //pulsate(circle);
    }

}

//
function get_my_url (bounds) {
    var res = this.map.getResolution();

    var x = Math.round ((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));
    var y = Math.round ((this.maxExtent.top - bounds.top) / (res * this.tileSize.h));
    var z = this.map.getZoom();

    //if(this.map.baseLayer.gmBase != undefined)
        z += (lbgm.maplets.mapobject.aResolutions.length - lbgm.maplets.mapobject.vResolutions.length);

    var path = "/" + z + "/" + x + "_" + y + "." + this.type;
    var url = this.url;

    if (url instanceof Array) {
        url = this.selectUrl(path, url);
    }

    //console.log('res: ' + res + ' bounds.left: ' + bounds.left + ' this.maxExtent.left: ' + this.maxExtent.left + ' ' + url + path);
    return url + path;
}

// 
OpenLayers.Control.MousePosition.prototype.formatCoords = function (base) {
    var sign = '';
    if (base < 0) sign = '-';
    var abs_base = Math.abs(base);
    var t, t2;
    var minute_pad = '';
    var degrees = Math.floor(abs_base);
    t = (abs_base - degrees) * 60;
    var minutes = t;
    if (minutes < 10) minute_pad = '0';
    return (sign + degrees + "\u00B0 " + minute_pad + minutes.toFixed(3) + "\u0027 ");
};
OpenLayers.Control.MousePosition.prototype.formatOutput = function (lonLat) {
    var newHtml = this.formatCoords(lonLat.lon) + this.separator + this.formatCoords(lonLat.lat);
    return newHtml;
};