/* use global var GISCLIENT_DEBUG to activate debug mode */
//GISCLIENT_DEBUG = 1;

(function($){

    $.widget("ui.gisclientmap", {
		
        options: {
            log_level: 'mail',
            baseLayerFirst: true,
            contextualLegend: true, // Contextual Legend: legend will be available only for active layers
            mapsetData: null,
            dialogDefaultPosition: {
                position: [600,0]
            }, // default position of dialogs, (left, top)
            mapDefaultSize: [550,400]
        },
		
        internalVars: {
            lastZoomOn: null,
            lastCustomSearch: null
        },
	
        _create: function() {
            this.element
            .addClass( "ui-gisclient ui-widget ui-widget-content" )
            .attr({
                role: "gisclient"
            });
            this.mapStarted = false;
            gisclient = this; // global variable
        },
		
        _init: function(){
            var self = this;

            self.divs = self.options.divs;
            self.callbacks = self.options.callbacks || {};
            self.toolsOptions = self.options.toolsOptions || {};
            self.componentsOptions = self.options.componentsOptions || {};
                        
            // apply proxy: for wfs requests on other domains
            if (self.options.proxy) {
                OpenLayers.ProxyHost = self.options.proxy;
                $.ajaxPrefilter( function( options ) {
                    if ( options.crossDomain ) {
                        var url = options.url;
                        if (options.data)
                            url += self.getQueryStringSeparator(url) + options.data;
                        options.url = self.options.proxy + encodeURIComponent(url);
                        options.crossDomain = false;
                    }
                });
            }
			
            // apply language
            if (self.options.language)
                OpenLayers.Lang.setCode(self.options.language);
			
            if(self.options.mapsetURL){
                $.getJSON(self.options.mapsetURL + "services/gcmap.php", {
                    jsonformat:true, // force service to return a json output
                    mapset:self.options.mapsetName,
                    legend:(typeof(self.divs.legendList) == 'undefined') ? 0 : 1, // TODO: no more used
                    querytemplate:self.options.querytemplate ? 1 : 0, // TODO: no more used
                    lang:OpenLayers.Lang.getCode()
                }, function(settings) {
                    self.options.mapsetData = settings;
                    self._initMap(self.options.mapsetData);
                });
            } else {
                alert('MISSING MAPSET URL');
            //self._initMap(self.options.mapsetData);
            }
        },
		
        getMap: function (){
            return this.map;
        },
		
        getProject:function(){
            return this.project;
        },
		
        getProjection: function() {
            return this.projection;
        },
		
        getResolutions: function() {
            return this.resolutions;
        },
		
        getMapTitle: function() {
            return this.mapTitle;
        },
		
        getMapOptions: function() {
            var self = this;
			
            var options = {
                mapsetURL: self.options.mapsetURL,
                dpi: self.options.dpi,
                legend: (typeof(self.divs.legendList) == 'undefined') ? false : true
            };
            return options;
        },
		
        _initMap: function(settings){
            var self = this;
			
            this.project = this.options.project_name;
            this.projection = settings.projection;
            this.resolutions = settings.resolutions;
            this.mapTitle = settings.title;
			
            this.toolObjects = {};
            this.componentObjects = {};
            
            var mapOptions = {
                controls:[
                new OpenLayers.Control.Attribution(),
                new OpenLayers.Control.Navigation({
                    isPermanent:true
                }),
                new OpenLayers.Control.KeyboardDefaults({
                    isPermanent:true
                }),
                new OpenLayers.Control.ScaleLine({
                    isPermanent:true
                }),
                new OpenLayers.Control.PanZoomBar({
                    forceFixedZoomLevel:true,
                    isPermanent:true
                })
                ],
                units: "m",
                projection: new OpenLayers.Projection(settings.projection),
                //displayProjection :new OpenLayers.Projection("EPSG:4326"), // questo serve solo se c'è un layer google o simili
                maxExtent: new OpenLayers.Bounds.fromArray(settings.restrictedExtent),
                resolutions: settings.resolutions,
                fractionalZoom:true,
                size: new OpenLayers.Size(this.options.mapDefaultSize[0], this.options.mapDefaultSize[1])
            };

            OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;
            OpenLayers.Util.onImageLoadErrorColor = "transparent";
            OpenLayers.DOTS_PER_INCH = settings.dpi;
            
            //Istanza dell'oggetto mappa
            var map = new OpenLayers.Map(this.element.get(0), mapOptions);
            map.events.register('zoomend',self,self._checkButtons);
			
            this.map=map;
            this.mapId = map.id.replace(".","_");
			
            var layersManagerOptions = {
                layerTree: (typeof(self.divs.treeList) == 'undefined') ? false : self.divs.treeList,
                legend: (typeof(self.divs.legendList) == 'undefined') ? false : self.divs.legendList,
                referenceMap: (typeof(self.divs.referenceMap) == 'undefined') ? false : self.divs.referenceMap,
				defaultFeatureFilters: (typeof(self.options.defaultFeatureFilters) == 'undefined') ? null : self.options.defaultFeatureFilters
            };
            $('#div_layermanager').gcLayersManager(layersManagerOptions);
			
            if(this.options.tools) this._initTools();
			
            if(typeof(gisclient.options.copyrightString) != 'undefined') {
                this.element.append('<div id="copyright_string" style="position:absolute;right:0px;bottom:0px;font-size:16px;">'+gisclient.options.copyrightString+'</div>');
            }
			
            self._trigger('gisclientready', null, {});
        },
		
        startMap: function() {
            var self = this;

            gisclient.componentObjects.gcLayersManager.loadLayers();
            self.mapStarted = true;
        },
		
        _updatePositionLink: function() {
            var center = gisclient.map.getCenter();
            var zoom = gisclient.map.getZoom();
            $('#'+gisclient.divs.positionLink).html('<a href="?x='+center.lon+'&y='+center.lat+'&zoom='+zoom+'">PosLink</a>');
        },
		
        _checkButtons: function() {
            var gisclient = this;
            if(typeof(gisclient.toolObjects) == 'undefined' || gisclient.toolObjects.length < 1) return;
            if(typeof(gisclient.toolObjects.zoomToMaxExtent) == 'undefined' || typeof(gisclient.toolObjects.zoomToHistoryPrevious) == 'undefined' || typeof(gisclient.toolObjects.zoomToHistoryNext) == 'undefined') return;
            // enable/disable maxextent, previous, next
            if(gisclient.map.getNumZoomLevels() > gisclient.map.zoom) {
                gisclient.toolObjects.zoomToMaxExtent.element.button('enable');
            } else {
                gisclient.toolObjects.zoomToMaxExtent.element.button('disable');
            }
            if(gisclient.toolObjects.zoomToHistoryPrevious.options.control.previousStack.length > 0) {
                gisclient.toolObjects.zoomToHistoryPrevious.element.button('enable');
            } else {
                gisclient.toolObjects.zoomToHistoryPrevious.element.button('disable');
            }
            if(gisclient.toolObjects.zoomToHistoryNext.options.control.nextStack.length > 0) {
                gisclient.toolObjects.zoomToHistoryNext.element.button('enable');
            } else {
                gisclient.toolObjects.zoomToHistoryNext.element.button('disable');
            }
        },
		
        _initTools: function() {
            var self=this;
            var domObj;
            var divs = self.divs;
            var callbacks = self.callbacks;
            var toolsOptions = self.toolsOptions;
			
            if(typeof(divs.mapInfoRefSystemDescription) != 'undefined' && typeof(self.options.mapsetData.projection_description) != 'undefined') {
                $('#'+divs.mapInfoRefSystemDescription).html(self.options.mapsetData.projection_description);
            }

            for(var key in this.options.tools) {
                
                domObj = $('#' + this.options.tools[key]); //elemento del dom associato al controllo
                switch(key){
                    case 'zoomFull':
                        $(domObj).zoomToMaxExtent();
                        break;
						
                    case 'zoomPrev':
                        $(domObj).zoomToHistoryPrevious();
                        break;
						
                    case 'zoomNext':
                        $(domObj).zoomToHistoryNext();
                        break;
						
                    case 'zoomIn':
                        $(domObj).zoomIn();
                        break;
						
                    case 'zoomOut':
                        $(domObj).zoomOut();
                        break;
						
                    case 'Pan':
                        $(domObj).pan();
                        break;

                    case 'selectFromMap':
                        if(typeof(divs.selectionSettings) != 'undefined' && typeof(divs.dataList) != 'undefined') {
                            $(domObj).selectFromMap({
                                idDialog: divs.selectionSettings,
                                idDataList: divs.dataList,
                                idTree: divs.tree
                            });
                        }
                        break;
						
                    case 'measureLine':
                        if(typeof(divs.lineMeasure) != 'undefined' && typeof(divs.lineMeasurePartial) != 'undefined') {
                            $(domObj).measureLine({
                                targetDiv:divs.lineMeasure,
                                targetPartialDiv:divs.lineMeasurePartial
                            });
                        }
                        break;
						
                    case 'measureArea':
                        if(typeof(divs.areaMeasure) != 'undefined') {
                            $(domObj).measureArea({
                                targetDiv:divs.areaMeasure
                            });
                        }
                        break;
					
                    case 'drawFeature':
                        if(typeof(callbacks['drawFeature']) != 'function') callbacks['drawFeature'] = function() {};
                        var options = {
                            save: callbacks['drawFeature']
                        };
                        if(typeof(toolsOptions['drawFeature']) == 'object') {
                            options = $.extend(options, toolsOptions['drawFeature']);
                        }
                        $(domObj).drawFeature(options);
                        break;
						
                    case 'reloadLayers':
                        $(domObj).reloadLayers();
                        break;
						
                    case 'selectPoint':
                        if(typeof(callbacks['selectPoint']) != 'function') callbacks['selectPoint'] = function() {};
                        $(domObj).selectPoint({
                            snapOptionsId: divs.snapOptionsId,
                            handleFeature: callbacks['selectPoint']
                        });
                        break;
						
                    case 'selectFeatures':
                        if(typeof(callbacks['selectFeatures']) != 'function') callbacks['selectFeatures'] = function() {};
                        var settingsId = (typeof(divs.selectFeaturesSettings) != 'undefined')?divs.selectFeaturesSettings:null;
                        if(typeof(gisclient.options.selectFeaturesSettings) != 'undefined') {
                            var featureType = (typeof(gisclient.options.selectFeaturesSettings.featureType) != 'undefined') ? gisclient.options.selectFeaturesSettings.featureType : null;
                            var filter = (typeof(gisclient.options.selectFeaturesSettings.filter) != 'undefined') ? gisclient.options.selectFeaturesSettings.filter : null;

                        }
                        $(domObj).selectFeatures({
                            displaySettingsId: settingsId,
                            featureType: featureType,
                            filter: filter,
                            handleFeature: callbacks['selectFeatures']
                        });
                        break;
						
                    case 'selectBox':
                        if(typeof(callbacks['selectBox']) != 'function') callbacks['selectBox'] = function() {};
                        $(domObj).selectBox({
                            snapOptionsId: divs.snapOptionsId,
                            handleFeature: callbacks['selectBox']
                        });
                        break;
						
                    case 'selectPolygon':
                        if(typeof(callbacks['selectPolygon']) != 'function') callbacks['selectPolygon'] = function() {};
                        $(domObj).selectPolygon({
                            snapOptionsId: divs.snapOptionsId,
                            handleFeature: callbacks['selectPolygon']
                        });
                        break;
						
                    case 'redline':
                        if(typeof(divs.redlineDialog) != 'undefined') {
                            $(domObj).redline({
                                redlineDialogDiv: divs.redlineDialog
                            });
                        }
                        break;
						
                    case 'toolTip':
                        $(domObj).toolTip();
                        break;
						
                    case 'mapPrint':
                        $(domObj).mapPrint();
                        break;
                    case 'toStreetView':
                        $(domObj).toStreetView();
                        break;
                }
				
                $('#'+divs.toolBar).find('span.gc-buttonset').buttonset();
            }
            if(typeof(divs.footer) != 'undefined') {
                $('#'+divs.footer).mapInfo({
                    idMapInfoScale: divs.mapInfoScale,
                    idMapInfoMousePosition: divs.mapInfoMousePosition,
                    idMapInfoMousePositionLatLon: divs.mapInfoMousePositionLatLon,
                    idmapInfoRefSystem: divs.mapInfoRefSystem
                });
            }
			
            if(typeof(divs.scaleDropDown) != 'undefined') {
                $('#'+divs.scaleDropDown).scaleDropDown();
            }
			
            if(typeof(divs.searchList) != 'undefined') {
                var options = {
                    idDataList: divs.dataList,
                    idTree: divs.tree
                };
                if(typeof(self.componentsOptions['searchForm']) == 'object') {
                    options = $.extend(options, self.componentsOptions['searchForm']);
                }
                $('#'+divs.searchList).searchForm(options);
            }
			
            if(typeof(divs.editingSettings) != 'undefined') {
                $('#'+divs.editingSettings).editingDialog();
            }
			
            if(typeof(divs.customSearch) != 'undefined') {
                $('#'+divs.customSearch).customSearch();
            }
			
            $('#'+divs.loading).loadingHandler();
			
            $('#'+divs.errors).errorHandler();
			
            if(typeof(gisclient.toolObjects.zoomToMaxExtent) != 'undefined') gisclient.toolObjects.zoomToMaxExtent.element.button('disable');
            if(typeof(gisclient.toolObjects.zoomToHistoryPrevious) != 'undefined') gisclient.toolObjects.zoomToHistoryPrevious.element.button('disable');
            if(typeof(gisclient.toolObjects.zoomToHistoryNext) != 'undefined') gisclient.toolObjects.zoomToHistoryNext.element.button('disable');
			
            if(typeof(gisclient.divs.positionLink) != 'undefined') {
                gisclient.map.events.register('moveend', self, self._updatePositionLink);
                $('#'+gisclient.divs.positionLink).html('<a href="?x=0&y=0&zoom=0">PosLink</a>');
            }
			
            if(typeof(gisclient.divs.goToLink) != 'undefined' && typeof(gisclient.divs.goToDialog) != 'undefined') {
                $('#'+gisclient.divs.goToLink).html('<a href="#" data-role="goToLink">'+OpenLayers.i18n('Go to')+'</a>');

            }
            $('a[data-role="goToLink"]').click(function() {
                var html = 'X: <input type="text" name="go_to_x"><br />Y: <input type="text" name="go_to_y"><br /><button name="go_to_button">'+OpenLayers.i18n('Go to')+'</button>';
                $('#'+gisclient.divs.goToDialog).html(html);
                var dialogOptions = $.extend(gisclient.options.dialogDefaultPosition, {
                    draggable:true,
                    title:OpenLayers.i18n('Go to'),
                    autoOpen:true
                });
                $('#'+gisclient.divs.goToDialog).dialog(dialogOptions);
				
                $('button[name="go_to_button"]').click(function() {
                    var x = $('input[name="go_to_x"]').val();
                    var y = $('input[name="go_to_y"]').val();
                    var lonLat = new OpenLayers.LonLat(x, y);
                    gisclient.map.setCenter(lonLat);
                    $('#'+gisclient.divs.goToDialog).dialog('close');
                });
            });
			
            self.toolObjects.pan._toggleControl();
        },

        getEditingLayer: function() { // deprecated!
            var self = this;
            var editingLayer = self.componentObjects.gcLayersManager.getEditingLayer();
            return editingLayer;
        },
		
        /*getSnapLayer: function() { // deprecated?
            var self = this;
            return self.snapLayer;
        },*/
		
        getSelectionLayer: function() { // deprecated!
            var self = this;
            return self.componentObjects.gcLayersManager.getSelectionLayer();
        },
        
        layerIsActive: function(themeId, layerId) { // deprecated!
            var self = this;
            return self.componentObjects.gcLayersManager.layerIsActive(themeId, layerId);
        },
		
        themeIsActive: function(themeId) { // deprecated!
            var self = this;
            return self.componentObjects.gcLayersManager.themeIsActive(themeId);
        },
		
        getExternalFeatureLink: function(featureId) {
            if(typeof(gisclient.options.externalFeatureLink) == 'undefined') return false;
            var links = gisclient.options.externalFeatureLink;
            if(typeof(links[featureId]) == 'undefined') return false;
            return links[featureId];
        },
		
        parentGoTo: function(url) {
            window.opener.location = url;
            window.opener.focus();
        },
		
        parentOpenDialog: function(url) {
            var context = window.opener;
		
            var options = {
                autoOpen: false, 
                bgiframe: true, 
                modal: true,
                width: 'auto',
                height: 'auto',
                position: [200,50],
                'resizable': false,
                'close': function(event, ui) {
                    context.$("#r3_dialog").remove()
                }
            };
			
            if (context.$('#r3_dialog', context).length == 0) context.$('<div id="r3_dialog"></div>').hide().appendTo('body');
            context.$('#r3_dialog').html('Loading ...');
            context.$('#r3_dialog').dialog('option', options);
            context.$('#r3_dialog').dialog(options).dialog('open').load(url);
            window.opener.focus();
        },
	
        getQueryableLayers: function(selectActive, includeHidden) { // deprecated!
            var self = this;
            if(typeof(selectActive) == 'undefined') selectActive = false;
            if(typeof(includeHidden) == 'undefined') includeHidden = false;
            return self.componentObjects.gcLayersManager.getQueryableLayers(selectActive, includeHidden);
        },
        
        getQueryStringSeparator: function(url) {
            if(url.indexOf('?') == -1) {
                return '?';

            }
            if(url.substr(-1) == '?') {
                return '';
            } else if(url.substr(-1) != '&') {
                return '&';
            }
            return '';
        },
		
        zoomOn: function(where, highlight) {
            // remove features to avoid problems with already highlighted objects
            var selectionLayer = gisclient.componentObjects.gcLayersManager.getSelectionLayer();
            selectionLayer.removeAllFeatures();
			
            gisclient.internalVars.lastCustomSearch = null;
            gisclient.internalVars.lastZoomOn = where;
            if(typeof(where.CLASS_NAME) != 'undefined' && where.CLASS_NAME == 'OpenLayers.Bounds') {
                gisclient.map.zoomToExtent(where);
                return true;
            } else {
                if(typeof(where.featureType) == 'undefined' || typeof(where.field) == 'undefined' || typeof(where.value) == 'undefined') return false;
                var featureType = where.featureType;
                var field = where.field;
                var value = where.value;
                if(typeof(highlight) == 'undefined' && typeof(where.highlightFeatures) != 'undefined') {
                    var highlight = where.highlightFeatures;
                }
				
                if(highlight) gisclient.internalVars.lastZoomOn.highlight = 1;
                else gisclient.internalVars.lastZoomOn.highlight = 0;
				
                var queryableLayers = gisclient.componentObjects.gcLayersManager.getQueryableLayers(false, true);
                if(featureType in queryableLayers) {
                    var queryModel = queryableLayers[featureType];
                    var filter = new OpenLayers.Filter.Comparison({
                        type: OpenLayers.Filter.Comparison.EQUAL_TO,
                        property: field,
                        value: value
                    });
                    var filter_1_0 = new OpenLayers.Format.Filter({
                        version: "1.0.0"
                    });
                    var xml = new OpenLayers.Format.XML();
                    var filterValue = xml.write(filter_1_0.write(filter));
					
                    var params = {
                        PROJECT: queryModel.layer.parameters.project,
                        MAP: queryModel.layer.parameters.map,
                        SERVICE: 'WFS',
                        VERSION: '1.0.0',
                        REQUEST: 'GETFEATURE',
                        SRS: gisclient.getProjection(),
                        TYPENAME: featureType,
                        FILTER: filterValue
                    };

                    $.ajax({
                        url: queryModel.layer.url,
                        type: 'GET',
                        dataType: 'xml',
                        data: params,
                        success: function(response, status, jqXHR) {
                            var format = new OpenLayers.Format.GML();
                            var features = format.read(response);
                            if(features.length < 1) {
                                gisclient.log(jqXHR.responseText);
                                return false;
                            }
                            
                            var gcLayersManager = gisclient.componentObjects.gcLayersManager;
							
                            if(highlight) {
                                var selectionLayer = gcLayersManager.getSelectionLayer();
                                selectionLayer.addFeatures(features);
                            }

                            if(!gcLayersManager.layerIsActive(queryModel.themeId, queryModel.layerId)) gcLayersManager.activateLayer(queryModel.themeId, queryModel.layerId);
								
                            var bounds = new OpenLayers.Bounds();
                            $.each(features, function(i, feature) {
                                bounds.extend(feature.bounds);
                            });
                            var extendedBounds = new OpenLayers.Bounds(
                                bounds.left-20,
                                bounds.bottom-20,
                                bounds.right+20,
                                bounds.top+20
                                );
                            var zoom = gisclient.map.getZoomForExtent(extendedBounds);
                            var numZoomLevels = gisclient.options.mapsetData.resolutions.length;
                            if(zoom > (numZoomLevels-3)) {
                                gisclient.map.setCenter(bounds.getCenterLonLat(), numZoomLevels-5);
                            } else {
                                gisclient.map.zoomToExtent(extendedBounds);
                            }
                            return true;
                        },
                        error: function(response, status, jqXHR) {
                            gisclient.log(jqXHR.responseText);
                            return false;
                        }
                    });
                }
                return false;
            }
        },
		
        addVectorFeatures: function(targetLayer, where) {
            if(typeof(where.featureType) == 'undefined' || (typeof(where.field) == 'undefined' || typeof(where.value) == 'undefined') && (typeof(where.filter) == 'undefined')) return false;
            var featureType = where.featureType;
            if(typeof(where.filter) == 'undefined') {
                var field = where.field;
                var value = where.value;
            }
			
            if(typeof(highlight) == 'undefined' && typeof(where.highlightFeatures) != 'undefined') {
                var highlight = where.highlightFeatures;
            }
			
            var queryableLayers = gisclient.componentObjects.gcLayersManager.getQueryableLayers(false, true);
            if(featureType in queryableLayers) {
                var queryModel = queryableLayers[featureType];
                var filter;
                if(typeof(where.filter) != 'undefined') {
                    filter = where.filter;
                } else {
                    var filter = new OpenLayers.Filter.Comparison({
                        type: OpenLayers.Filter.Comparison.EQUAL_TO,
                        property: where.field,
                        value: where.value
                    });

                }
                var filter_1_0 = new OpenLayers.Format.Filter({
                    version: "1.0.0"
                });
                var xml = new OpenLayers.Format.XML();
                var filterValue = xml.write(filter_1_0.write(filter));
				
                var params = {
                    PROJECT: queryModel.layer.parameters.project,
                    MAP: queryModel.layer.parameters.map,
                    SERVICE: 'WFS',
                    VERSION: '1.0.0',
                    REQUEST: 'GETFEATURE',
                    SRS: gisclient.getProjection(),
                    TYPENAME: featureType,
                    FILTER: filterValue
                };
				
                $.ajax({
                    url: queryModel.layer.url,
                    type: 'GET',
                    dataType: 'xml',
                    data: params,
                    success: function(response, status, jqXHR) {
                        var format = new OpenLayers.Format.GML();
                        var features = format.read(response);
                        if(features.length < 1) return false;

                        targetLayer.addFeatures(features);
                        return true;
                    },
                    error: function(response, status, jqXHR) {
                        gisclient.log(jqXHR.responseText);
                        return false;
                    }
                });
				
            } else gisclient.log(where);
            return false;
        },
		
        autocompleteFromQueryableLayer: function(request, response) {
            var featureType = this.options.feature;
            var selectedField = this.options.selectedField;

            var params = {
                PROJECT: gisclient.getProject(),
                MAP: featureType.themeId,
                SERVICE: 'WFS',
                VERSION: '1.0.0',
                REQUEST: 'GETFEATURE',
                SRS: gisclient.getProjection(),
                TYPENAME: featureType.featureId,
                PROPERTYNAME: '('+selectedField+')',
                OUTPUTFORMAT: 'text/xml',
                SUBTYPE: 'gml/2.1.2'
            };
			
            if(request.term.length > 0) {
                var filter = new OpenLayers.Filter.Comparison({
                    type: OpenLayers.Filter.Comparison.LIKE,
                    property: selectedField,
                    value: '*'+request.term+'*'
                });
                var filter_1_1 = new OpenLayers.Format.Filter({
                    version: "1.0.0"
                });
                var xml = new OpenLayers.Format.XML();
                var filterValue = xml.write(filter_1_1.write(filter));
                /* MAPSERVER HACK: need to specify matchcase=false in order to get case insensitive search */
                filterValue = filterValue.replace('escape="!">', 'escape="!" matchCase="false">');
                params.FILTER = filterValue;
            }
			
            $.ajax({
                url: featureType.layer.url,
                type: 'GET',
                dataType: 'xml',
                data: params,
                success: function(data, status, jqXHR) {
                    var format = new OpenLayers.Format.GML();
                    var features = format.read(data);
                    if(features.length < 1) {
                        response([]);
                        return false;
                    }
					
                    var data = [];
					
                    if(features.length > 0) {
                        $.each(features, function(e, feature) {
                            if($.inArray(feature.attributes[selectedField], data) == -1) data.push(feature.attributes[selectedField]);
                        });
                    }
                    data.sort();
                    returnData = [];
                    $.each(data, function(e, row) {
                        returnData.push({
                            label:row
                        });
                    });
                    response(returnData);
                },
                error: function() {
                    gisclient.log(arguments);
                    return false;
                }
            });
        },
		
        
        log: function(message) { 
            if(typeof(console) == 'object') console.log(message);
        }
    /*
        log: function(message) {
            switch(gisclient.options.log_level) {
                case 'mail':
                    $.ajax({
                        url: 'gisclient/mail.php',
                        type: 'POST',
                        dataType: 'json',
                        data: {
                            message: message
                        }
                    });
                    break;
				case 'console':
					if(typeof(console) != 'undefined') {
						console.log(message);
					}
				break;
            }
            
            return true;
        }*/			
    });

    $.extend($.ui.gisclientmap, {
        version: "3.0.0",
        instances: []
    });
	

})(jQuery);