var infowindowoffsetposition = -200;
var postgresql_field_domains = [];
var sqlite_field_domains = [];

function fn_get_postgresql_field_domains() {
    var _proxy_url_getdomains = host + "src/proxy/getdomains.php";
    _proxy_url_getdomains.replace('admin/', '');
    Ext.Ajax.request({
        url: _proxy_url_getdomains + '?db=postgres',
        success: function (response, opts) {
            try {
                postgresql_field_domains = Ext.decode(response.responseText);
            } catch (err) {
            }
        },
        failure: function (response, opts) {
            console.log('server-side failure with field domains ' + response.status);
        }
    });
}

function fn_get_sqlite_field_domains() {
    var _proxy_url_getdomains = host + "src/proxy/getdomains.php";
    _proxy_url_getdomains.replace('admin/', '');
    Ext.Ajax.request({
        url: _proxy_url_getdomains + '?db=sqlite',
        success: function (response, opts) {
            try {
                sqlite_field_domains = Ext.decode(response.responseText);
            } catch (err) {
            }
        },
        failure: function (response, opts) {
            console.log('server-side failure with field domains ' + response.status);
        }
    });
}

try {
    fn_get_postgresql_field_domains();
} catch (err) { }

try {
    fn_get_sqlite_field_domains();
} catch (err) { }

function fn_featureObject(record) {

    var _featureId = record.get("_featureId");
    var _layerId = record.get("_layerId");
    var _srsName = record.get("_srsName");
    var _featureUrl = record.get("_featureUrl");
    var _featureGeomFormat = record.get("_featureGeomFormat");
    var feature = {
        _featureId: _featureId,
        _layerId: _layerId,
        _srsName: _srsName,
        _featureUrl: _featureUrl,
        _featureGeomFormat: _featureGeomFormat,
        _featureAttributes: ""
    };

    return feature;

}

function fn_featureColumnModelForGrid(_appendColumns) {
    var output = new Array();

    output = [
        {
            _attributeName: "_featureUrl",
            _attributeSortable: false,
            _attributeType: "string",
            _attributeTranslation: "",
            hideable: false,
            hidden: true
        },
        {
            _attributeName: "_featureGeomFormat",
            _attributeSortable: false,
            _attributeType: "string",
            _attributeTranslation: "",
            hideable: false,
            hidden: true
        },
        {
            _attributeName: "_srsName",
            _attributeSortable: false,
            _attributeType: "string",
            _attributeTranslation: "",
            hideable: false,
            hidden: true
        },
        {
            _attributeName: "_featureId",
            _attributeSortable: false,
            _attributeType: "string",
            _attributeTranslation: "",
            width: 30,
            hideable: false,
            renderer: fn_featureShowOnMapRenderer
        },
        {
            _attributeName: "_featureId",
            _attributeSortable: false,
            _attributeType: "string",
            _attributeTranslation: "",
            width: 30,
            hidden: true,
            hideable: false,
            renderer: fn_featureHighlightRenderer
        },
        {
            _attributeName: "_featureId",
            _attributeSortable: false,
            _attributeType: "string",
            _attributeTranslation: "",
            width: 30,
            hidden: true,
            hideable: true,
            renderer: fn_featureAddToSelectedRenderer
        },
        {
            _attributeName: "_featureId",
            _attributeSortable: false,
            _attributeType: "string",
            _attributeTranslation: "",
            width: 30,
            hideable: false,
            renderer: fn_featureInfoWindowRenderer
        },
        {
            _attributeName: "_featureId",
            _attributeSortable: false,
            _attributeType: "string",
            _attributeTranslation: "",
            width: 30,
            hideable: false,
            hidden: false,
            renderer: fn_featureDownloadRenderer
        },
        {
            _attributeName: "_layerId",
            _attributeSortable: false,
            _attributeType: "string",
            _attributeTranslation: "",
            hidden: !admin,
            width: 30,
            hideable: false,
            renderer: fn_featureEditRenderer
        }];

    if (typeof _appendColumns != "undefined") {
        output.push.apply(output, _appendColumns);
    }

    return output;
}

var fetureGridTopBarRightBtns = [];

var fetureGridTopBarLeftBtns = [];

function fn_createFetureGridTopBar() {
    var tbar = [
        '->',
        {
            xtype: 'button',
            tooltip: _feature_gridicons_qtip_showOnMap,
            iconCls: 'features_toolbar_showonmap',
            hidden: true,
            handler: function () {

            }
        },
        {
            xtype: 'button',
            tooltip: _feature_gridicons_qtip_highlight,
            iconCls: 'features_toolbar_highlight',
            hidden: true,
            handler: function () {

            }
        },
        {
            xtype: 'button',
            tooltip: _feature_gridicons_qtip_featureInfoWindow,
            iconCls: 'features_toolbar_showinfow',
            handler: function () {
                var selected = Ext.getCmp(this.findParentByType("grid").id).getSelectionModel().getSelection();

                infowindowoffsetposition = -200;

                Ext.each(selected, function (item) {
                    infowindowoffsetposition = infowindowoffsetposition + 10;

                    fn_callFeatureFnFromGrid(item.get("_featureId"), item.get("_layerId"), item.get("_srsName"), item.get("_featureUrl"), item.get("_featureGeomFormat"), 'getInfo');
                });
            }
        },
        {
            xtype: 'button',
            tooltip: _feature_gridicons_qtip_download,
            iconCls: 'features_toolbar_download',
            handler: function () {
                featureDownloadArray = [];

                var selected = Ext.getCmp(this.findParentByType("grid").id).getSelectionModel().getSelection();

                Ext.each(selected, function (item) {
                    var _feature = {
                        _featureId: item.get("_featureId"),
                        _layerId: item.get("_layerId"),
                        _srsName: item.get("_srsName"),
                        _featureUrl: item.get("_featureUrl"),
                        _featureGeomFormat: item.get("_featureGeomFormat")
                    };

                    featureDownloadArray.push(_feature);

                });

                var _w = fn_featureDonwloadWindow();

                _w.show();
            }
        },
        {
            xtype: 'button',
            tooltip: _feature_gridicons_qtip_addtoselected,
            iconCls: 'features_toolbar_addtoselected',
            handler: function () {
                var selected = Ext.getCmp(this.findParentByType("grid").id).getSelectionModel().getSelection();

                Ext.each(selected, function (item) {
                    maptab_west_selection_panel_grid_add_record(item.get("_featureId"), item.get("_layerId"), item.get("_featureUrl"), item.get("_srsName"), item.get("_featureGeomFormat"));

                });
            }
        },
        {
            xtype: 'button',
            tooltip: _feature_gridicons_qtip_PDF,
            iconCls: 'pdf',
            hidden: false,
            handler: function () {
                var grid = Ext.getCmp(this.findParentByType("grid").id);
                var colums = Ext.getCmp(this.findParentByType("grid").id).columns;
                var selected = Ext.getCmp(this.findParentByType("grid").id).getSelectionModel().getSelection();
                var dt = [];
                var tt = [];
                var i = 0;
                var j = 0;
                selected.forEach(function (item, index) {
                    delete item.raw['_featureGeomFormat'];
                    delete item.raw['_featureId'];
                    delete item.raw['_featureUrl'];
                    delete item.raw['_layerId'];
                    delete item.raw['_srsName'];
                    dt.push(item.raw);

                    var keyNames = Object.keys(item.raw);
                    if (j <= keyNames.length) {
                        i = index
                    }
                    j = keyNames.length;
                });
                colums.forEach(function (col) {
                    var keyNames = Object.keys(selected[i].raw);
                    keyNames.forEach(function (key) {
                        if (key === col['dataIndex']) {
                            var tmp = {
                                id: key,
                                translate: col.text
                            };
                            var index = tt.findIndex(function (s) {
                                if (s.id === key) {
                                    return true
                                }
                            });
                            if (index === -1) {
                                tt.push(tmp)
                            }
                        }
                    });

                });
                var tableRows = [];
                var tm = [];
                tt.forEach(function (item) {
                    tm.push(item.translate);
                });
                tableRows.push(tm);
                dt.forEach(function (raw) {
                    var tmp = [];
                    tt.forEach(function (item) {
                        if (typeof raw[item.id] === 'undefined') {
                            tmp.push('');
                        } else {
                            var keyNames = Object.keys(raw);
                            keyNames.forEach(function (key) {
                                if (item.id === key) {
                                    tmp.push(raw[key]);
                                }
                            })
                        }
                    });
                    tableRows.push(tmp);
                });
                var page = '';
                if (tt.length <= 6) {
                    page = 'A4'
                } else if (tt.length > 6 && tt.length <= 10) {
                    page = 'A3'
                } else if (tt.length > 10) {
                    page = 'A2'
                }
                var docDefinition = {
                    pageSize: page,
                    pageOrientation: 'landscape',
                    content: [
                        { text: grid.title, style: 'header' },
                        {
                            style: 'table',
                            table: {
                                body: tableRows
                            }
                        }
                    ],
                    styles: {
                        header: {
                            fontSize: 18,
                            bold: true,
                            margin: [0, 0, 0, 10]
                        },
                        subheader: {
                            fontSize: 16,
                            bold: true,
                            margin: [0, 10, 0, 5]
                        },
                        table: {
                            margin: [0, 5, 0, 15]
                        },
                        tableHeader: {
                            bold: true,
                            fontSize: 13,
                            color: 'black'
                        }
                    },
                    defaultStyle: {
                        fontSize: 8
                    }
                };
                window.pdfMake.createPdf(docDefinition).download();
            }
        },
        {
            xtype: 'button',
            tooltip: _feature_gridicons_qtip_edit,
            iconCls: 'features_toolbar_edit',
            hidden: !admin,
            handler: function () {
                var selected = Ext.getCmp(this.findParentByType("grid").id).getSelectionModel().getSelection();
                var _features = [];
                var _layerId = "";

                Ext.each(selected, function (item) {
                    _layerId = item.get("_layerId");

                    _features.push(item.get("_featureId"));

                });


                fn_maptab_edit_init_edit_from_grid(_layerId, _features);

            }
        }

    ];

    tbar.push.apply(fetureGridTopBarLeftBtns, tbar);

    tbar.push.apply(tbar, fetureGridTopBarRightBtns);

    return tbar;

}

var featureDownloadArray = new Array();

function fn_featureDonwloadWindow() {
    var _projection_systems = new Array();

    var _config = new _config_init_map();

    for (var i = 0; i < _config._mapProjections.length; i++) {
        var _proj = _config._mapProjections[i];

        _projection_systems.push([_proj._title, _proj._epsg]);
    }

    var _w = new Ext.Window({
        width: 380,
        height: 240,
        modal: true,
        resizable: false,
        plain: true,
        layout: 'border',
        listeners:
        {
            show: function (cmp) {
                if (featureDownloadArray.length > 1) {
                    Ext.getCmp("featuredownload_separately_id").show();
                } else {
                    Ext.getCmp("featuredownload_separately_id").hide();
                }

            },
            hide: function () {


            }
        },
        items: [{
            xtype: 'form',
            region: 'center',
            items: [
                {
                    xtype: 'combo',
                    loadMask: true,
                    autoScroll: true,
                    autoShow: true,
                    id: 'featuredownload_outputformat_id',
                    fieldLabel: _featuredownload_outputformat,
                    store: new Ext.data.SimpleStore({
                        fields: ['title', 'value'],
                        data: [
                            ["DXF", "DXF"],
                            ["GML2", "GML2"],
                            ["GML3", "GML3"],
                            ["Shapefile", "shape-zip"],
                            ["JSON", "application/json"],
                            // ["JSONP", "text/javascript"],
                            ["KML", "kml"],
                            ["CSV", "csv"]
                        ]
                    }),
                    displayField: 'title',
                    valueField: 'value',
                    emptyText: "Shapefile",
                    value: "shape-zip",
                    forceSelection: true,
                    triggerAction: 'all',
                    selectOnFocus: false,
                    mode: 'local',
                    editable: false
                },
                {
                    xtype: 'combo',
                    loadMask: true,
                    autoScroll: true,
                    autoShow: true,
                    id: 'featuredownload_charset_id',
                    fieldLabel: _featuredownload_charset,
                    store: new Ext.data.SimpleStore({
                        fields: ['title', 'value'],
                        data: _config._charsets
                    }),
                    displayField: 'title',
                    valueField: 'value',
                    emptyText: "UTF-8",
                    value: "UTF-8",
                    forceSelection: true,
                    triggerAction: 'all',
                    selectOnFocus: false,
                    mode: 'local',
                    editable: false
                },
                {
                    xtype: 'combo',
                    loadMask: true,
                    autoScroll: true,
                    autoShow: true,
                    id: 'featuredownload_srs_id',
                    fieldLabel: _featuredownload_srs,
                    store: new Ext.data.SimpleStore({
                        fields: ['title', 'value'],
                        data: _projection_systems
                    }),
                    displayField: 'title',
                    valueField: 'value',
                    emptyText: _config._mapProjections[0]._title,
                    value: _config._mapProjections[0]._epsg,
                    forceSelection: true,
                    triggerAction: 'all',
                    selectOnFocus: false,
                    mode: 'local',
                    editable: false
                },
                {
                    xtype: 'checkbox',
                    checked: false,
                    id: 'featuredownload_separately_id',
                    labelStyle: 'width:200px',
                    fieldLabel: _featuredownload_download_separately
                }],
            bbar: ['->', {
                xtype: 'button',
                text: _featuredownload_downloadbtn,
                iconCls: 'features_toolbar_download',
                handler: function () {
                    var _outputFormat = Ext.getCmp("featuredownload_outputformat_id").getValue();

                    var _charset = Ext.getCmp("featuredownload_charset_id").getValue();

                    var _srs = Ext.getCmp("featuredownload_srs_id").getValue();

                    var _seperated = Ext.getCmp("featuredownload_separately_id").getValue();

                    if (_seperated) {
                        Ext.each(featureDownloadArray, function (item) {
                            if (_outputFormat === 'kml') {
                                var _url = fn_featureDonwloadCreateFeatureLink(item._layerId, [item._featureId], _outputFormat, _charset, _srs);
                                fn_downloadoptions(item._layerName + '.kml', _url)
                            } else {
                                window.open(fn_featureDonwloadCreateFeatureLink(item._layerId, [item._featureId], _outputFormat, _charset, _srs));
                            }
                        });
                    }
                    else {
                        var _featureId = [];

                        Ext.each(featureDownloadArray, function (item) {
                            _featureId.push(item._featureId);
                        });

                        if (_outputFormat === 'kml') {
                            var _url = fn_featureDonwloadCreateFeatureLink(featureDownloadArray[0]._layerId, _featureId, _outputFormat, _charset, _srs);
                            fn_downloadoptions(featureDownloadArray[0]._featureId.split('.')[0] + '.kml', _url)
                        } else if (_outputFormat === 'shape-zip') {
                            fn_downloadoptions(featureDownloadArray[0]._featureId.split('.')[0] + '.zip', fn_featureDonwloadCreateFeatureLink(featureDownloadArray[0]._layerId, _featureId, _outputFormat, _charset, _srs));
                        } else if (_outputFormat === 'GML2' || _outputFormat === 'GML3') {
                            fn_downloadoptions(featureDownloadArray[0]._featureId.split('.')[0] + '.gml', fn_featureDonwloadCreateFeatureLink(featureDownloadArray[0]._layerId, _featureId, _outputFormat, _charset, _srs));
                        } else if (_outputFormat === 'application/json') {
                            fn_downloadoptions(featureDownloadArray[0]._featureId.split('.')[0] + '.json', fn_featureDonwloadCreateFeatureLink(featureDownloadArray[0]._layerId, _featureId, _outputFormat, _charset, _srs));
                        } else if (_outputFormat === 'text/javascript') {
                            fn_downloadoptions(featureDownloadArray[0]._featureId.split('.')[0] + '.txt', fn_featureDonwloadCreateFeatureLink(featureDownloadArray[0]._layerId, _featureId, _outputFormat, _charset, _srs));
                        } else if (_outputFormat === 'csv') {
                            fn_downloadoptions(featureDownloadArray[0]._featureId.split('.')[0] + '.csv', fn_featureDonwloadCreateFeatureLink(featureDownloadArray[0]._layerId, _featureId, _outputFormat, _charset, _srs));
                        } else if (_outputFormat === 'DXF') {
                            fn_downloadoptions(featureDownloadArray[0]._featureId.split('.')[0] + '.dxf', fn_featureDonwloadCreateFeatureLink(featureDownloadArray[0]._layerId, _featureId, _outputFormat, _charset, _srs));
                        }
                    }
                }
            }]
        }]
    });

    return _w;

}

function fn_featureDonwloadCreateFeatureLink(_layerId, _featureId, _outputFormat, _charset, _srs) {

    if (_outputFormat === 'kml') {

        var _layerObject = mapFindLayerById(_layerId)._layerObject;

        var _serviceObject = mapFindLayerById(_layerId)._serviceObject;

        var _format = 'kml';

        var _content_type = 'application/vnd.google-earth.kml+xml kml';

        var _charset = "";

        var _epsg = "";

        var _bbox = new layerDownloadBBOX(_layerObject);

        var _width = _bbox.getWidth();

        var _height = _bbox.getHeight();

        var _newWidth = 800;

        var _ratio = (_height / _width);

        var _newHeight = Math.floor(_newWidth * _ratio);

        var lTIME = '';

        var lSTYLE = '';

        if (typeof _layerObject._layer.params['TIME'] !== 'undefined') {
            lTIME = _layerObject._layer.params['TIME'];
        }

        if (typeof _layerObject._layer.params['STYLES'] !== 'undefined') {
            lSTYLE = _layerObject._layer.params['STYLES'];
        }

        var _url = Ext.urlAppend(_serviceObject._serviceUrl, "REQUEST=GetMap&SERVICE=WMS&VERSION=1.1.1&LAYERS=" + _layerObject._layerName + "&FORMAT=" + _format + "&TRANSPARENT=TRUE&SRS=EPSG:4326&BBOX=" + _bbox.toString() + "&WIDTH=" + _newWidth + "&HEIGHT=" + _newHeight
            + "&TIME=" + lTIME
            + "&STYLE=" + lSTYLE
        );

        if (_charset != "") {
            _url = Ext.urlAppend(_url, "FORMAT_OPTIONS=CHARSET:" + _charset);
        }

        if (_epsg != "") {
            _url = Ext.urlAppend(_url, "SRSNAME=" + _epsg);
        }

        _url = Ext.urlAppend(_url, "FEATUREID=" + _featureId.join(','));

        if (_serviceObject._isSecure) {
            _url = _proxy_url + "?proxy=raw&contentype=" + _content_type + "&url=" + _url;
        }

        return _url;

    } else {

        var url = mapFindLayerById(_layerId)._serviceObject._serviceUrl;

        var parser = document.createElement('a');

        parser.href = url;

        var queries = parser.search.replace(/^\?/, '').split('&');

        var q = [];

        for (i = 0; i < queries.length; i++) {

            var split = queries[i].split('=');

            var key = split[0];

            var value = split[1];

            if ((key.toLowerCase() != "service") && (key.toLowerCase() != "version") && (key != null) && (key != "")) {
                q.push(key + "=" + value);
            }
        }

        q.push("FEATUREID=" + _featureId.join(','));
        q.push("OUTPUTFORMAT=" + _outputFormat);
        q.push("SRSNAME=" + _srs);
        q.push("REQUEST=GETFEATURE");
        q.push("TYPENAMES=" + mapFindLayerById(_layerId)._layerObject._layerName);
        q.push("SERVICE=WFS");
        q.push("VERSION=1.1.0");

        if (_charset != "") {
            q.push("FORMAT_OPTIONS=CHARSET:" + _charset);
        }

        var _scheme = parser.protocol;

        var _host = parser.host;

        var _path = parser.pathname;

        var _security = "";

        if (((mapFindLayerById(_layerId)._serviceObject._username) != null) &&
            ((mapFindLayerById(_layerId)._serviceObject._username) != "") &&
            ((mapFindLayerById(_layerId)._serviceObject._password) != "") &&
            ((mapFindLayerById(_layerId)._serviceObject._password) != null)) {
            _security = mapFindLayerById(_layerId)._serviceObject._username + ":" + mapFindLayerById(_layerId)._serviceObject._password + "@";
        }

        var host = _scheme + "//" + _security + _host + _path + "?" + q.join('&');

        // return host;

        _url = _proxy_url + "?proxy=raw&contentype=" + _content_type + "&url=" + host;

        return _url;

    }

}


function fn_createDateAttribute(value, metaData, record, row, col, store, gridView) {
    if (value != "") {
        value = value.replace('Z', '');

        //value = Ext.Date.format(value,'d/m/Y');

    }

    return value;
}

function fn_featureEditRenderer(value, metaData, record, row, col, store, gridView) {
    var _layerId = record.get("_layerId");

    var _feature = fn_featureObject(record);

    if (mapFindLayerById(_layerId)._layerObject._isEditable) {
        return "<img src=\"" + host + "images/edit.png\" data-qtip=\"" + _feature_gridicons_qtip_edit + "\" onClick=\"fn_maptab_edit_init_edit_from_grid('" + _layerId + "',['" + _feature._featureId + "']);\">";
    }
    return "";
}

function fn_featureShowOnMapRenderer(value, metaData, record, row, col, store, gridView) {
    var _feature = fn_featureObject(record);

    return "<img src=\"" + host + "images/show.png\" class=\"column_grid_images\" data-qtip=\"" + _feature_gridicons_qtip_showOnMap + "\" onClick=\"fn_featureShowOnMap('" + _feature._featureId + "','" + _feature._layerId + "','" + _feature._srsName + "','" + _feature._featureUrl + "','" + _feature._featureGeomFormat + "','');\">";
}

function fn_featureShowOnMap(_featureId, _layerId, _srsName, _featureUrl, _featureGeomFormat, fn_param) {
    if (mapGetFeatureByFid(_layerId, _featureId) != null) {
        var _fetaure_Extent = mapGetFeatureByFid(_layerId, _featureId).geometry.getBounds();

        map.zoomToExtent(_fetaure_Extent);
    }
    else {

        switch (_featureGeomFormat) {
            case "gml":
                var p = new fn_get();

                p._async = false;

                p._url = fn_surl(_featureUrl, mapFindLayerById(_layerId)._serviceObject._username, mapFindLayerById(_layerId)._serviceObject._password, "getfeatures&method=get");

                p._timeout = 5000;

                var url = p._url;

                var _xy = mapFindLayerById(_layerId)._layerObject._xy;

                if (url.indexOf("GETFEATUREINFO") >= 0) {
                    _xy = true;
                }

                p._url += '&srsName=' + mapGetCurrentProjection();

                p._success = function (_response, _opts) {

                    // var gmlReader = new OpenLayers.Format.GML({
                    //     extractAttributes: true,
                    //     internalProjection: new OpenLayers.Projection(mapGetCurrentProjection()),
                    //     externalProjection: new OpenLayers.Projection(mapFindLayerById(_layerId)._layerObject._nativeSRS),
                    //     xy: _xy
                    // });

                    var gmlReader = new OpenLayers.Format.GML();

                    var features = gmlReader.read(_response.responseText);

                    setTimeout(function () {
                        map.zoomToExtent(features[0].geometry.getBounds());
                    }, 500);
                };

                p.get();
                break;

            case "esriJSON":

                var feature = {
                    _featureId: _featureId,
                    _layerId: _layerId,
                    _srsName: _srsName,
                    _featureUrl: _featureUrl,
                    _featureGeomFormat: _featureGeomFormat,
                    _featureAttributes: ""
                };

                arcgis93resFetchESRIJSON(feature, "showonmap");

                break;

        }
    }
}

function fn_featureHighlightRenderer(value, metaData, record, row, col, store, gridView) {
    var _feature = fn_featureObject(record);

    return "<img src=\"" + host + "images/highlight.png\" class=\"column_grid_images\" onClick=\"fn_featureHighlight('" + _feature._featureId + "','" + _feature._layerId + "','" + _feature._srsName + "','" + _feature._featureUrl + "','" + _feature._featureGeomFormat + "','');\" data-qtip=\"" + _feature_gridicons_qtip_highlight + "\">";
}

function fn_featureIsHiglighted(_featureId, _layerId) {
    if (mapGetFeatureByFid(map_highlightLayer.id, _featureId)) {
        return true;
    }
    else {
        return false;
    }
}

function fn_featureUnHiglighted(_featureId, _layerId) {
    if (mapGetFeatureByFid(map_highlightLayer.id, _featureId)) {
        map_highlightLayer.removeFeatures([mapGetFeatureByFid(map_highlightLayer.id, _featureId)]);

    }
}

function fn_toggleHightlightFromAllResultsGrids(_featureId, _layerId, _gridId) {
    Ext.each(fn_grid_results_ids_array, function (item) {
        if (item != _gridId) {
            Ext.getCmp(_gridId).getStore().each(function (record) {

                var _r = Ext.getCmp(item).getStore().findRecord('_featureId', record.get("_featureId"));

                if (mapGetFeatureByFid(map_highlightLayer.id, record.get("_featureId"))) {
                    if (_r) {
                        Ext.getCmp(item).getSelectionModel().select(_r, true, true);
                    }
                }
                else {
                    if (_r) {
                        Ext.getCmp(item).getSelectionModel().deselect(_r, true);
                    }
                }

            });
        }
    });
}


function fn_featureHighlight(_featureId, _layerId, _srsName, _featureUrl, _featureGeomFormat, fn_param) {
    if (mapGetFeatureByFid(map_highlightLayer.id, _featureId) == null) {
        if (mapGetFeatureByFid(_layerId, _featureId)) {
            var _cloneFeature = mapGetFeatureByFid(_layerId, _featureId).clone();

            _cloneFeature.fid = _featureId;

            _cloneFeature.attributes = mapGetFeatureByFid(_layerId, _featureId).attributes;

            map_highlightLayer.addFeatures(_cloneFeature);
        }
        else {

            switch (_featureGeomFormat) {

                case "gml":
                    var p = new fn_get();

                    p._async = false;

                    p._url = fn_surl(_featureUrl, mapFindLayerById(_layerId)._serviceObject._username, mapFindLayerById(_layerId)._serviceObject._password, "getfeatures&method=get");

                    p._timeout = 5000;

                    var url = p._url;

                    var _xy = mapFindLayerById(_layerId)._layerObject._xy;

                    if (url.indexOf("GETFEATUREINFO") >= 0) {
                        _xy = true;
                    }

                    p._url += '&srsName=' + mapGetCurrentProjection();

                    p._success = function (_response, _opts) {

                        // var gmlReader = new OpenLayers.Format.GML({
                        //     extractAttributes: true,
                        //     internalProjection: new OpenLayers.Projection(mapGetCurrentProjection()),
                        //     externalProjection: new OpenLayers.Projection(mapFindLayerById(_layerId)._layerObject._nativeSRS),
                        //     xy: _xy
                        // });

                        var gmlReader = new OpenLayers.Format.GML();

                        var features = gmlReader.read(_response.responseText);

                        map_highlightLayer.addFeatures(features);
                    };

                    p.get();

                    break;

                case "esriJSON":

                    var feature = {
                        _featureId: _featureId,
                        _layerId: _layerId,
                        _srsName: _srsName,
                        _featureUrl: _featureUrl,
                        _featureGeomFormat: _featureGeomFormat,
                        _featureAttributes: ""
                    };

                    arcgis93resFetchESRIJSON(feature, "highlight");

                    break;

            }
        }

        if (fn_param != "") {
            fn_param(_featureId, _layerId, _featureUrl, _featureGeomFormat);
        }
    }
}

function fn_featureInfoWindowRenderer(value, metaData, record, row, col, store, gridView) {
    var _feature = fn_featureObject(record);

    return "<img src=\"" + host + "images/featureInfoWindow.png\" class=\"column_grid_images\" onClick=\"fn_callFeatureFnFromGrid('" + _feature._featureId + "','" + _feature._layerId + "','" + _feature._srsName + "','" + _feature._featureUrl + "','" + _feature._featureGeomFormat + "','getInfo');\" data-qtip=\"" + _feature_gridicons_qtip_featureInfoWindow + "\">";
}

function fn_callFeatureFnFromGrid(_featureId, _layerId, _srsName, _featureUrl, _featureGeomFormat, fn_param) {

    var feature = {
        _featureId: _featureId,
        _layerId: _layerId,
        _srsName: _srsName,
        _featureUrl: _featureUrl,
        _featureGeomFormat: _featureGeomFormat
    };

    switch (fn_param) {
        case "getInfo":
            var _infowin = fn_featureInfoWindow(feature);
            _infowin.show();
            _infowin.alignTo(Ext.getCmp('maptab_center'), "c", [infowindowoffsetposition, infowindowoffsetposition]);
            break;
    }
}

function fn_featureDownloadRenderer(value, metaData, record, row, col, store, gridView) {
    var _feature = fn_featureObject(record);

    if (mapFindLayerById(_feature._layerId)._serviceObject._isService) {
        return "<img src=\"" + host + "images/download.png\" class=\"column_grid_images\"  onClick=\"fn_featureDownload('" + _feature._featureId + "','" + _feature._layerId + "','" + _feature._srsName + "','" + _feature._featureUrl + "','" + _feature._featureGeomFormat + "');\" data-qtip=\"" + _feature_gridicons_qtip_download + "\">";
    }

    return "";
}

function fn_featureDownload(_featureId, _layerId, _srsName, _featureUrl, _featureGeomFormat) {
    featureDownloadArray = [];

    var _feature = {
        _featureId: _featureId,
        _layerId: _layerId,
        _srsName: _srsName,
        _featureUrl: _featureUrl,
        _featureGeomFormat: _featureGeomFormat
    };

    featureDownloadArray.push(_feature);

    var _w = new fn_featureDonwloadWindow();

    _w.show();
}

function fn_featurehowOnlySelectedOnMap(_feature) {

}

function fn_featureAddToSelectedRenderer(value, metaData, record, row, col, store, gridView) {
    var _feature = fn_featureObject(record);

    return "<img src=\"" + host + "images/addToSelected.png\" class=\"column_grid_images\" onClick=\"fn_featureAddToSelected('" + _feature._featureId + "','" + _feature._layerId + "','" + _feature._featureUrl + "','" + _feature._srsName + "','" + _feature._featureGeomFormat + "');\" data-qtip=\"" + _feature_gridicons_qtip_addtoselected + "\">";
}

function fn_featureAddToSelected(_featureId, _layerId, _featureUrl, _srsName, _featureGeomFormat) {
    maptab_west_selection_panel_grid_add_record(_featureId, _layerId, _featureUrl, _srsName, _featureGeomFormat);
}


function fn_createAttributePanel(_feature) {
    var a = "";

    if (mapGetFeatureByFid(_feature._layerId, _feature._featureId) != null) {
        a = fn_createAttributesPivotGrid(_feature);

        if (_feature._featureGeomFormat == "CUSTOM") {
            var _attributesFields = new Array();

            for (var k in mapGetFeatureByFid(_feature._layerId, _feature._featureId).attributes) {
                _attributesFields.push({
                    "_attributeName": k.toString(),
                    "_attributeType": "string",
                    "_attributeTranslation": null,
                    "_attributeValue": null,
                    "_attributeEditor": null,
                    "_attributeIsSortable": true,
                    "_attributeIsEditable": true,
                    "_attributeOrder": 0,
                    "_attributeIsVisible": true,
                    "_attributeIsSearchable": true,
                    "_attributeIsGeometry": false,
                    "_attributeVisible": true,
                    "_geometryIsMulti": false,
                    "_attributeShowOnSummary": false
                });

            }

            var _attributes = fn_createAttributesRecords(mapGetFeatureByFid(_feature._layerId, _feature._featureId).attributes, _attributesFields);

            a.getStore().loadData(_attributes);

        } else {

            var _attributes = fn_createAttributesRecords(mapGetFeatureByFid(_feature._layerId, _feature._featureId).attributes, mapFindLayerById(_feature._layerId)._layerObject._attributesFields);

            a.getStore().loadData(_attributes);


            ///////// new for edit /////////////////////////////////////////////////////////////////////////////////////////////////

            var _store = a.getStore();

            var _dirty = false;

            var editid = Ext.id();

            var formid = Ext.id();

            if (mapFindLayerById(_feature._layerId)._layerObject._isEdited) {

                var formitems = [];

                _store.each(function (item) {

                    var formitem = null;

                    if (postgresql_field_domains.length > 0 && _config_field_domains_database === 'postgres') {

                        postgresql_field_domains.forEach(function (domain) {

                            if (mapFindLayerById(_feature._layerId)._layerObject._layerName === domain._layer_name &&
                                mapFindLayerById(_feature._layerId)._serviceObject._serviceUrl === domain._service_url &&
                                item.get("_attributeName") === domain._field_name) {

                                var domainvalues = Ext.create('Ext.data.Store', {
                                    fields: ['name', 'value'],
                                    data: domain._field_domain
                                });

                                formitem = Ext.create('Ext.form.ComboBox', {
                                    fieldLabel: item.get("_attributeTranslation"),
                                    name: item.get("_attributeName"),
                                    store: domainvalues,
                                    queryMode: 'local',
                                    displayField: 'name',
                                    valueField: 'value',
                                    value: item.get("_attributeValue"),
                                    editable: false,
                                    listeners: {
                                        change: function () {
                                            _dirty = true;
                                            Ext.getCmp(editid).enable();
                                        }
                                    }
                                });

                                if (containsObject(formitem, formitems) === false) {
                                    formitems.push(formitem);
                                }
                            }

                        });

                    }

                    if (sqlite_field_domains.length > 0 && _config_field_domains_database === 'sqlite') {

                        sqlite_field_domains.forEach(function (domain) {

                            if (mapFindLayerById(_feature._layerId)._layerObject._layerName === domain._layer_name &&
                                mapFindLayerById(_feature._layerId)._serviceObject._serviceUrl === domain._service_url &&
                                item.get("_attributeName") === domain._field_name) {

                                var domainvalues = Ext.create('Ext.data.Store', {
                                    fields: ['name', 'value'],
                                    data: domain._field_domain
                                });

                                formitem = Ext.create('Ext.form.ComboBox', {
                                    fieldLabel: item.get("_attributeTranslation"),
                                    name: item.get("_attributeName"),
                                    store: domainvalues,
                                    queryMode: 'local',
                                    displayField: 'name',
                                    valueField: 'value',
                                    value: item.get("_attributeValue"),
                                    editable: false,
                                    listeners: {
                                        change: function () {
                                            _dirty = true;
                                            Ext.getCmp(editid).enable();
                                        }
                                    }
                                });

                                if (containsObject(formitem, formitems) === false) {
                                    formitems.push(formitem);
                                }
                            }

                        });

                    }

                    if (_config_field_domains.length > 0) {

                        _config_field_domains.forEach(function (domain) {

                            if (mapFindLayerById(_feature._layerId)._layerObject._layerName === domain._layer_name &&
                                mapFindLayerById(_feature._layerId)._serviceObject._serviceUrl === domain._service_url &&
                                item.get("_attributeName") === domain._field_name) {

                                var domainvalues = Ext.create('Ext.data.Store', {
                                    fields: ['name', 'value'],
                                    data: domain._field_domain
                                });

                                formitem = Ext.create('Ext.form.ComboBox', {
                                    fieldLabel: item.get("_attributeTranslation"),
                                    name: item.get("_attributeName"),
                                    store: domainvalues,
                                    queryMode: 'local',
                                    displayField: 'name',
                                    valueField: 'value',
                                    value: item.get("_attributeValue"),
                                    editable: false,
                                    listeners: {
                                        change: function () {
                                            _dirty = true;
                                            Ext.getCmp(editid).enable();
                                        }
                                    }
                                });

                                if (containsObject(formitem, formitems) === false) {
                                    formitems.push(formitem);
                                } else {
                                    formitems.splice(formitems.indexOf(formitem), 1);
                                    formitems.push(formitem);
                                }
                            }

                        });
                    }

                });

                var sort_order = [];
                _store.each(function (item) {
                    sort_order.push(item.data._attributeName);
                    var formitem = fn_create_edit_field(mapFindLayerById(_feature._layerId)._layerObject, item, editid, _dirty);
                    if (containsObject(formitem, formitems) === false) {
                        formitems.push(formitem);
                    }
                });

                formitems.sort(function (a, b) {
                    return sort_order.indexOf(a.name) < sort_order.indexOf(b.name) ? -1 : 1;
                });

                var _editBbar = [
                    '->',
                    {
                        xtype: 'button',
                        id: editid,
                        iconCls: 'features_toolbar_save',
                        disabled: true,
                        tooltip: _maptab_edit_windowinfo_save_attributes_button,
                        handler: function (cmp, e) {

                            if (Ext.getCmp(formid).isValid()) {

                                var _newAttributes = [];

                                _store.each(function (item) {

                                    formitems.forEach(function (newitem) {

                                        if (newitem.componentCls == 'x-panel' && Ext.getCmp(newitem.id).name === item.get("_attributeName") && Ext.getCmp(newitem.id).filetoupload !== item.get("_attributeValue")) {
                                            _newAttributes.push({
                                                _attributeName: Ext.getCmp(newitem.id).name,
                                                _attributeValue: newitem.filetoupload
                                            });
                                        }

                                        else if (newitem.componentCls == 'x-panel') {

                                        }

                                        else if (Ext.getCmp(newitem.id).name === item.get("_attributeName") && Ext.getCmp(newitem.id).getValue() !== item.get("_attributeValue")) {

                                            var val_new = null;

                                            if (item.get("_attributeType") === 'date') {
                                                val_new = moment(Ext.getCmp(newitem.id).getValue()).add(-1, 'day').format("YYYY-MM-DD");
                                                if (val_new == 'Invalid date') {
                                                    val_new = null;
                                                }
                                            }
                                            else if (item.get("_attributeType") === 'dateTime') {
                                                val_new = moment(Ext.getCmp(newitem.id).getValue()).format("YYYY-MM-DD");
                                                if (val_new == 'Invalid date') {
                                                    val_new = null;
                                                }
                                            }
                                            else {
                                                val_new = Ext.getCmp(newitem.id).getValue();
                                            }

                                            _newAttributes.push({
                                                _attributeName: Ext.getCmp(newitem.id).name,
                                                _attributeValue: val_new
                                            });
                                        }
                                    });
                                });

                                maptab_edit_change_attributes(_feature, _newAttributes);
                            }
                        }
                    },
                    {
                        xtype: 'button',
                        iconCls: 'features_toolbar_cancel',
                        tooltip: _maptab_edit_windowinfo_cancel_attributes_button,
                        handler: function (cmp, e) {
                            Ext.getCmp(this.findParentByType("window").id).destroy();
                        }
                    }
                ];

                a = Ext.create('Ext.form.Panel', {
                    id: formid,
                    height: 350,
                    width: 300,
                    bodyPadding: 10,
                    defaultType: 'textfield',
                    autoScroll: true,
                    items: formitems,
                    bbar: _editBbar
                });
            }

            ///////// new for edit /////////////////////////////////////////////////////////////////////////////////////////////////


        }

    }
  else {
        a = fn_createAttributesPivotGrid(_feature);
        var p = new fn_get();
        p._async = true;
        var _servicePort = "";

        if (typeof mapFindLayerById(_feature._layerId)._serviceObject._servicePort !== "undefined") {
            _servicePort = mapFindLayerById(_feature._layerId)._serviceObject._servicePort;
        }

        p._data = [{
            _layerId: _feature._layerId,
            _serviceType: mapFindLayerById(_feature._layerId)._serviceObject._serviceType,
            _serviceName: mapFindLayerById(_feature._layerId)._serviceObject._serviceName,
            _servicePort: _servicePort,
            _username: mapFindLayerById(_feature._layerId)._serviceObject._username,
            _serviceUrl: mapFindLayerById(_feature._layerId)._serviceObject._serviceUrl,
            _password: mapFindLayerById(_feature._layerId)._serviceObject._password,
            _layerName: mapFindLayerById(_feature._layerId)._layerObject._layerName,
            _version: mapFindLayerById(_feature._layerId)._serviceObject._version,
            _isService: mapFindLayerById(_feature._layerId)._serviceObject._isService,
            _featureType: mapFindLayerById(_feature._layerId)._layerObject._featureType,
            _cqlFilter: mapFindLayerById(_feature._layerId)._layerObject._cqlFilter,
            _featureInfoFormat: mapFindLayerById(_feature._layerId)._serviceObject._featureInfoFormat,
            _featureUrl: _feature._featureUrl,
            _request: "getAttributes"
        }]

        p._timeout = 5000;
    if (["815a434a567cddcef4f19b6e1fbb82acb0b6e81c9f2de090be0e0b612b827817", "815a434a567cddcef4f19b6e1fbb82ac0cf39c00301f606f538c63abf898f29b",
    "815a434a567cddcef4f19b6e1fbb82aca2bf4f1238d6f458d21a93572fe8f72e",
    "815a434a567cddcef4f19b6e1fbb82ac229ba27c135415c502e344d80217a33b",
    "815a434a567cddcef4f19b6e1fbb82ac5455ddd53ae84b811122b207f135129c"].includes(_feature._layerId)) {
      return;
    }
    /*
if (_feature._layerId === '815a434a567cddcef4f19b6e1fbb82acf41da801728a69b525e253fff951790d') {
          return;
        }*/

        p._success = function (_response, _opts) {
            var _response = Ext.JSON.decode(_response.responseText)[0];
            var t_attributes = _response._response._attributes[0][0];
            var _attributes = fn_createAttributesRecords(t_attributes, mapFindLayerById(_feature._layerId)._layerObject._attributesFields);

            a.getStore().loadData(_attributes);
        };

        p.get();
    }

    return a;
}


function fn_fetchGML(_feature) {

    var _output;

    if (mapGetFeatureByFid(_feature._layerId, _feature._featureId) != null) {
        _output = mapGetFeatureByFid(_feature._layerId, _feature._featureId);
    }
    else {

        switch (_feature._featureGeomFormat) {

            case "gml":

                var p = new fn_get();

                p._async = false;

                p._url = fn_surl(_feature._featureUrl, mapFindLayerById(_feature._layerId)._serviceObject._username, mapFindLayerById(_feature._layerId)._serviceObject._password, "getfeatures&method=get");

                p._timeout = 5000;

                var url = p._url;

                var _xy = mapFindLayerById(_feature._layerId)._layerObject._xy;

                if (url.indexOf("GETFEATUREINFO") >= 0) {
                    _xy = true;
                }

                p._url += '&srsName=' + mapGetCurrentProjection();

                p._success = function (_response, _opts) {

                    // var gmlReader = new OpenLayers.Format.GML({
                    //     extractAttributes: true,
                    //     internalProjection: new OpenLayers.Projection(mapGetCurrentProjection()),
                    //     externalProjection: new OpenLayers.Projection(mapFindLayerById(_feature._layerId)._layerObject._nativeSRS),
                    //     xy: _xy
                    // });

                    var gmlReader = new OpenLayers.Format.GML();

                    _output = gmlReader.read(_response.responseText)[0];

                };

                p.get();

                break;

            case "esriJSON":

                _output = arcgis93resFetchESRIJSON(_feature, "");

                break;

        }

    }

    return _output;
}

function fn_featureCreateMiniMap(_feature, _mapId, _layerId) {
    var mini_map = new OpenLayers.Map(_mapId, { controls: [] });

    mini_map.addControl(new OpenLayers.Control.Navigation());

    var _map_config_object = new _config_init_map();

    for (var k = 0; k < _map_config_object._basemapLayers.length; k++) {
        mini_map.addLayer(_map_config_object._basemapLayers[k]._layer);
    }

    var featurelayer = new OpenLayers.Layer.Vector("featureLayer", {
        displayInLayerSwitcher: false,
        styleMap: new OpenLayers.StyleMap({
            "default": new OpenLayers.Style({
                pointRadius: 5,
                fillColor: "#FFCB50",
                fillOpacity: 0.4,
                strokeColor: "#FF9428",
                strokeWidth: 1,
                strokeOpacity: 0.8
            })
        })
    });

    mini_map.addLayer(featurelayer);

    mini_map.addControl(new OpenLayers.Control.LayerSwitcher());

    var mini_map_previousMapExtent;

    var mini_map_previousMapProjection = mini_map.getProjectionObject().toString();

    var mini_map_map_currentMapProjection = mini_map.getProjectionObject().toString();

    var _f = _feature.clone();

    if (mapGetProjectionCode(mapGetCurrentProjection()) != mapGetProjectionCode(mini_map_map_currentMapProjection)) {
        _f.geometry.transform(new OpenLayers.Projection(mapGetCurrentProjection()), new OpenLayers.Projection(mapGetProjectionCode(mini_map.getProjectionObject().toString())));
    }

    mini_map.events.on({
        "changebaselayer": function (evtObj) {
            mini_map_map_currentMapProjection = mini_map.getProjectionObject().toString();

            if (mapGetProjectionCode(mini_map_previousMapProjection) != mapGetProjectionCode(mini_map_map_currentMapProjection)) {
                _f.geometry.transform(new OpenLayers.Projection(mini_map_previousMapProjection), new OpenLayers.Projection(mapGetProjectionCode(mini_map_map_currentMapProjection)));
            }

            featurelayer.refresh();

            mini_map.zoomIn();

            mini_map.zoomOut();

            mini_map_previousMapProjection = mini_map.getProjectionObject().toString();

            mini_map.zoomToExtent(featurelayer.getDataExtent());

        }
    });


    featurelayer.addFeatures(_f);

    setTimeout(function () {
        mini_map.zoomToExtent(_f.geometry.getBounds());

        if (mini_map.getZoom() > 20) {
            mini_map.zoomTo(18);
        }

    }, 500);

}

function fn_createGeometryPanel(_theFeature, _feature) {
    var _g = "";

    if (_theFeature) {
        var _data = [];

        var i = 1;

        var _theFeatureClone = _theFeature.clone();

        var _theGeometry = _theFeatureClone.geometry;

        if (_theGeometry != null) {
            if (mapGetProjectionCode(mapFindLayerById(_feature._layerId)._layerObject._nativeSRS) != mapGetCurrentProjection()) {
                _theGeometry = _theGeometry.transform(new OpenLayers.Projection(mapGetCurrentProjection()), new OpenLayers.Projection(mapGetProjectionCode(mapFindLayerById(_feature._layerId)._layerObject._nativeSRS)));
            }


            var _config = new _config_init_map();

            var _numDigitsIndex = fn_objIndexOf(_config._mapProjections, "_epsg", mapGetProjectionCode(mapFindLayerById(_feature._layerId)._layerObject._nativeSRS));

            var _numDigits;

            if (_numDigitsIndex >= 0) {
                _numDigits = _config._mapProjections[_numDigitsIndex]._numDigits;
            }

            if (typeof _theGeometry.components == "undefined") {
                if (typeof _numDigits !== "undefined") {
                    var x = _theGeometry.x;
                    var y = _theGeometry.y;

                    _data.push([x.toFixed(_numDigits), y.toFixed(_numDigits), 0]);

                } else {
                    _data.push([_theGeometry.x, _theGeometry.y, 0]);
                }
            }
            else {
                Ext.each(_theGeometry.components, function (item) {
                    var _vertices = item.getVertices();

                    for (var a = 0; a < _vertices.length; a++) {

                        var x = _vertices[a].x;
                        var y = _vertices[a].y;

                        if (typeof _numDigits !== "undefined") {
                            _data.push([x.toFixed(_numDigits), y.toFixed(_numDigits), i]);
                        } else {
                            _data.push([x, y, i]);
                        }
                    }

                    i++;

                });
            }

            var _s = new Ext.data.SimpleStore({
                fields: ['lon', 'lat', 'componentNum'],
                data: _data
            });

            _s.group("componentNum");

            _g = Ext.create('Ext.grid.Panel',
                {
                    border: true,
                    columnLines: true,
                    split: true,
                    store: _s,
                    _feature: _feature,
                    columns: [{
                        header: _feature_geometry_lon,
                        dataIndex: 'lon',
                        hidden: false,
                        sortable: false,
                        flex: 2,
                        hideable: false
                    },
                    {
                        header: _feature_geometry_lat,
                        dataIndex: 'lat',
                        flex: 2,
                        hidden: false,
                        sortable: false,
                        hideable: false
                    },
                    {
                        header: '',
                        dataIndex: 'componentNum',
                        hidden: true,
                        hideable: false
                    }],
                    tbar: [
                        {
                            xtype: 'label',
                            text: _feature_projection_system + ": " + mapGetProjectionCode(mapFindLayerById(_feature._layerId)._layerObject._nativeSRS)
                        }
                    ],
                    features: [{
                        ftype: 'grouping',
                        groupHeaderTpl: [
                            '{name:this.formatName}',
                            {
                                formatName: function (name) {
                                    return _feature_geometry_component + ":" + name;
                                }
                            }
                        ]
                    }],
                    bbar: ['->', {
                        xtype: 'exporterbutton',
                        iconCls: 'features_toolbar_download',
                        text: 'CSV'
                    }]
                });
        }
    }

    return _g;
}

function fn_createDetailsPanel(_feature) {
    var d;

    return d;
}

var init_featureInfoWindow_tabs = new Array();
var init_featureInfoWindow_bbar = new Array();
var init_featureInfoWindow_tbar = new Array();
var init_featureInfoWindow_btns = new Array();
var featureInfoWindow_isMinimized = false;

function fn_featureInfoWindow(_feature) {
    var infolayertitle = mapFindLayerById(_feature._layerId)._layerObject._layerTitle;
    var _w_id = Ext.id();
    var attributes = "";
    var geometry = "";
    var _theFeature = "";
    var _tabsItems = [];
    var ly = mapFindLayerById(_feature._layerId);

    if (!_feature._featureUrl.includes('sentinel')) {
        _feature._featureUrl = ly._serviceObject._serviceUrl + "?REQUEST=GETFEATURE&SERVICE=WFS&VERSION=2.0.0&OUTPUTFORMAT=GML2&TYPENAME=" + ly._layerObject._layerName + "&FEATUREID=" + _feature._featureId;

    }

    attributes = fn_createAttributePanel(_feature);
    _theFeature = fn_fetchGML(_feature);
    geometry = fn_createGeometryPanel(_theFeature, _feature);
    console.debug('feature info: ', attributes);

    var a = Ext.create('Ext.Panel',
        {
            title: _maptab_featureInfoWindow_Attributes_Tab_title,
            border: false,
            id: "attributes_panel_" + _w_id,
            layout: 'fit',
            items: [
                attributes
            ]
        });
    if (_feature._layerId === 'da3386bf44588b37a7ff447ae374582f18340009637aa630afaa963a41d3650d') {
      _tabsItems.push(a);
    }
    var mapid = Ext.id();
    var m = "";

    // MINIMAP tab
    /*
    if (geometry != "") {
        m = Ext.create('Ext.Panel',
            {
                title: _maptab_featureInfoWindow_Map_Tab_title,
                border: false,
                id: "minimap_panel_" + _w_id,
                _isFirstTime: true,
                layout: 'fit',
                listeners: {
                    boxready: function () {
                        if (this._isFirstTime) {
                            fn_featureCreateMiniMap(_theFeature, mapid, _feature._layerId);
                            this._isFirstTime = false;
                        }
                    }
                },
                items: [{
                    xtype: 'panel',
                    html: "<div id=\"" + mapid + "\" style=\"width:100%;height:100% !important;\"></div>"
                }]
            });
        _tabsItems.push(m);
    }
    */
    var g = "";

    // GEOMETRY tab
    /*
    if (geometry != "") {
        g = Ext.create('Ext.Panel',
            {
                title: _maptab_featureInfoWindow_Geometry_Tab_title,
                border: false,
                id: "geometry_panel_" + _w_id,
                layout: 'fit',
                items: [
                    geometry
                ]
            });

        _tabsItems.push(g);
    }
    */

    var details = fn_createDetailsPanel(_feature);
    var d = Ext.create('Ext.Panel',
        {
            title: _maptab_featureInfoWindow_Details_Tab_title,
            border: false,
            layout: 'fit',
            items: [
                details
            ]
        });


    var _tabs = {
        xtype: 'tabpanel',
        region: 'center',
        layout: 'fit',
        _feature: _feature,
        border: false,
        items: _tabsItems
    };


    var i = new Ext.Window({
        width: 440,
        height: 405,
        id: _w_id,
        title: _maptab_featureInfoWindow_title + ': ' + infolayertitle,
        plain: true,
        bbar: init_featureInfoWindow_bbar,
        tbar: init_featureInfoWindow_tbar,
        _feature: _feature,
        shim: true,
        layout: 'border',
        closeAction: 'destroy',
        minimizable: true,
        constrain: true,
        resizable: {
            listeners: {
                resize: function () {
                    Ext.getCmp('maptab_mapPanel').getEl().unmask();
                },
                beforeresize: function () {
                    Ext.getCmp('maptab_mapPanel').getEl().mask().dom.style.zIndex = Ext.getCmp(_w_id).getEl().dom.style.zIndex;
                }
            }
        },
        listeners: {
            destroy: function () {
                Ext.getCmp('maptab_mapPanel').getEl().unmask();
            },
            show: function (window, eOpts) {
                window.tools.restore.hide();
                Ext.getCmp('maptab_mapPanel').getEl().unmask();
            },
            "minimize": function (window, opts) {
                window.tools.restore.show();
                window.tools.minimize.hide();
                window.collapse();
                Ext.getCmp('maptab_mapPanel').getEl().unmask();
            },
            render: function (w) {
                Ext.each(init_featureInfoWindow_tabs, function (item) {
                    if (item) {
                        var _t = item(w);

                        if ((_t != null) && (_t != "")) {

                            w.items.items[0].items.items[0].add(_t);
                        }
                    }
                });
            }
        },
        tools: [{
            type: 'restore',
            handler: function (evt, toolEl, owner, tool) {
                var window = owner.up('window');
                window.tools.restore.hide();
                window.tools.minimize.show();
                window.expand('', false);
                Ext.getCmp('maptab_mapPanel').getEl().unmask();
            }
        }],
        items: [{
            xtype: 'panel',
            region: 'center',
            layout: 'border',
            items: [_tabs]
        }]
    });

    return i;
}

function fn_createPhotoAttribute(value, metaData, record, row, col, store, gridView) {
    if (value != "") {
        if (value != null) {
            if (value.indexOf("http") >= 0) {
                value = "<a href=\"" + value + "\" target=\"_blank\"><img src=\"" + value + "\" style=\"width:100%;\"></a>";
            } else {
                value = "<a href=\"" + host + value + "\" target=\"_blank\"><img src=\"" + host + value + "\" style=\"width:100%;\"></a>";
            }
        }
    }

    return value;
}

function fn_createMultiPhotoAttribute(value, metaData, record, row, col, store, gridView) {
    if (value != "") {
        if ((value != null) && (value != "(Null)")) {
            var valueArr = value.replaceAll('%7C', '|').split('|');

            value = "";

            for (var i = 0; i < valueArr.length; i++) {
                if (valueArr[i].indexOf("http") >= 0) {
                    value += "<a href=\"" + valueArr[i] + "\" target=\"_blank\"><img src=\"" + valueArr[i] + "\" style=\"width:100%;\"></a><br/>";
                } else {
                    value += "<a href=\"" + host + valueArr[i] + "\" target=\"_blank\"><img src=\"" + host + valueArr[i] + "\" style=\"width:100%;\"></a><br/>";
                }
            }
        }
    }

    return value;
}

function fn_createSensor(value, metaData, record, row, col, store, gridView) {
    if (value != "") {
        if (value != null) {
            value = '<a onclick="func(value)">value</a>';
        }
    }

    return value;
}

function fn_link_to_tab(value, metaData, record, row, col, store, gridView) {
    return value + ' <a href="#" onclick="goToSensorTab(' + value + ')">Προβολή</a>';
}

function goToSensorTab(value) {
    Ext.WindowMgr.each(
        function (win) {
            if (win.isVisible()) {
                win.close();
            }
        }
    );
}

function fn_createLinkAttribute(value, metaData, record, row, col, store, gridView) {
    if (value != "") {

        if (value != null) {
            var valueArr = value.split(', ');

            value = "";

            for (var i = 0; i < valueArr.length; i++) {
                value += "<a href=\"" + valueArr[i] + "\" target=\"_blank\">" + valueArr[i] + "</a>";
            }
        }
    }

    return value;
}

function fn_createDownloadDXF(value, metaData, record, row, col, store, gridView) {
    if (value != "") {

        if (value != null) {
            var valueArr = value.split('|');

            value = "";

            for (var i = 0; i < valueArr.length; i++) {
                value += valueArr[i] + "<br><a href=\"javascript:fn_downloadDXF('" + valueArr[i] + "');\" >([+] " + _feature_gridicons_qtip_download + ")</a><br><br>";
            }
        }
    }

    return value;
}

function fn_downloadDXF(url) {
    var p = new fn_get();

    p._async = true;
    p._url = _proxy_url + "?proxy=raw&contenttype=application/dxf&url=" + url;
    p._timeout = 5000;
    p._success = function (_response, _opts) {
        var data = _response.responseText;
        var filename = url.substring(url.lastIndexOf('/') + 1);
        var element = document.createElement('a');
        element.setAttribute('href', 'data:application/dxf,' + encodeURIComponent(data));
        element.setAttribute('download', filename);

        element.style.display = 'none';
        document.body.appendChild(element);

        element.click();

        document.body.removeChild(element);
    };

    p.get();
}

function fn_createMailAttribute(value, metaData, record, row, col, store, gridView) {
    if (value != "") {
        if (value != null) {
            var valueArr = value.split(', ');

            value = "";

            for (var i = 0; i < valueArr.length; i++) {
                value += "<a href=\"mailto:" + valueArr[i] + "\" target=\"_blank\">" + valueArr[i] + "</a>";
            }
        }
    }

    return value;
}

function fn_createBreakLinksAttribute(value, metaData, record, row, col, store, gridView) {
    if (value != "") {
        if ((value != null) && (value != "(Null)")) {
            var valueArr = value.split('|');

            value = "";

            for (var i = 0; i < valueArr.length; i++) {
                value += "<a href=\"" + valueArr[i] + "\" target=\"_blank\">" + valueArr[i] + "</a><br><br>";
            }
        }
    }

    return value;
}

function fn_createAddDiagramAttribute(value, metaData, record, row, col, store, gridView) {
    if (value != "") {
        if ((value != null) && (value != "(Null)")) {
            var valueArr = value.split('|');

            value = "";

            for (var i = 0; i < valueArr.length; i++) {
                value += valueArr[i] + "<br><a href=\"javascript:poleodomia_addDiagToMap('" + valueArr[i] + "');\" >([+] " + poleodomia_translations[language].add_diag_tomap + ")</a><br><br>";
            }
        }
    }

    return value;
}

function fn_createBreakAttribute(value, metaData, record, row, col, store, gridView) {
    if (value != "") {
        if ((value != null) && (value != "(Null)")) {
            var valueArr = value.split('|');
            value = "";

            for (var i = 0; i < valueArr.length; i++) {
                value += "- " + valueArr[i] + "<br>";
            }
        }
    }

    return value;
}

function fn_goToFiles(value, metaData, record, row, col, store, gridView) {
    var path = "";

    if (value != "") {
        if ((value != null) && (value != "(Null)")) {
            path = "<a href=\"javascript:goToFilesTab('" + value + "');\">Μετάβαση στον φάκελο</a>";
        }
    }

    return path;
}

function goToFilesTab(folder) {
    // Ext.getCmp('viewport_center').setActiveTab('viewport_filestab');
    // filestree_store.getRootNode().expand();
    // var record = filestree_store.getNodeById('files/' + folder);
    // record.expand();
    // filestree.getSelectionModel().select(record);

    Ext.getCmp('viewport_center').setActiveTab('viewport_filestab');
    filestree_store.load();

    var record = filestree_store.getNodeById('files');
    record.expand();

    setTimeout(() => {
        var item = filestree_store.getNodeById('files/' + folder.split('/')[0]);
        item.expand();

        setTimeout(() => {
            var item = filestree_store.getNodeById('files/' + folder.split('/')[0] + '/' + folder.split('/')[1]);
            item.expand();

            setTimeout(() => {
                var item = filestree_store.getNodeById('files/' + folder.split('/')[0] + '/' + folder.split('/')[1] + '/' + folder.split('/')[2]);
                item.expand();

                setTimeout(() => {
                    var item = filestree_store.getNodeById('files/' + folder.split('/')[0] + '/' + folder.split('/')[1] + '/' + folder.split('/')[2] + '/' + folder.split('/')[3]);
                    item.expand();

                    setTimeout(() => {
                        filestree.getSelectionModel().select(item);
                    }, 500);

                }, 500);

            }, 500);

        }, 500);

    }, 500);

}

function fn_goToRestrictFiles(value, metaData, record, row, col, store, gridView) {
    var path = "";

    if (value != "") {
        if ((value != null) && (value != "(Null)")) {
            path = "<a href=\"javascript:goToRestrictFilesTab('" + value + "');\">Μετάβαση στον φάκελο</a>";
        }
    }

    return path;
}

function goToRestrictFilesTab(folder) {
    Ext.getCmp('viewport_center').setActiveTab('viewport_restrictfilestab');
    restrictfiles_filestree_store.getRootNode().expand();
    var record = restrictfiles_filestree_store.getNodeById('files/' + folder);
    record.expand();
    restrictfiles_filestree.getSelectionModel().select(record);
}

function containsObject(obj, list) {
    var i;
    for (i = 0; i < list.length; i++) {
        if (list[i].name === obj.name) {
            return true;
        }
    }

    return false;
}


function fn_create_edit_field(layerObject, item, editid, _dirty) {

    var formitem = null;

    var formitemid = Ext.id();

    var blank = true;

    Ext.each(layerObject._attributesFields, function (fieldproperties) {
        if (typeof fieldproperties._attributeBlank !== 'undefined' && fieldproperties._attributeName === item.get("_attributeName")) {
            blank = fieldproperties._attributeBlank;
        }
    });

    if (item.get("_attributeType") === 'string') {

        var vtxt = item.get("_attributeValue");

        if (item.get("_attributeValue").startsWith('<a href=')) {
            var inittxt = item.get("_attributeValue").split(">")[1];
            var fntxt = inittxt.split("<")[0];
            vtxt = fntxt;
        }

        formitem = {
            xtype: "textfield",
            allowBlank: blank,
            disabled: !item.get("_attributeIsEditable"),
            id: formitemid,
            name: item.get("_attributeName"),
            fieldLabel: item.get("_attributeTranslation"),
            value: vtxt,
            listeners: {
                change: function () {
                    if (Ext.getCmp(formitemid).getValue().length == 0) {
                        Ext.Msg.alert(_maptab_edit_form_field_valid, _maptab_edit_form_field_valid_title_0 + item.get("_attributeTranslation") + _maptab_edit_form_field_valid_title_1);
                        Ext.getCmp(editid).disable(true);
                    } else {
                        _dirty = true;
                        Ext.getCmp(editid).enable();
                    }
                }
            }
        };
    }
    else if (item.get("_attributeType") === 'long') {
        formitem = {
            xtype: "numberfield",
            allowBlank: blank,
            disabled: !item.get("_attributeIsEditable"),
            id: formitemid,
            name: item.get("_attributeName"),
            fieldLabel: item.get("_attributeTranslation"),
            value: item.get("_attributeValue"),
            listeners: {
                change: function () {
                    if (Ext.getCmp(formitemid).getValue().length == 0) {
                        Ext.Msg.alert(_maptab_edit_form_field_valid, _maptab_edit_form_field_valid_title_0 + item.get("_attributeTranslation") + _maptab_edit_form_field_valid_title_1);
                        Ext.getCmp(editid).disable(true);
                    } else {
                        _dirty = true;
                        Ext.getCmp(editid).enable();
                    }
                }
            }
        };
    }
    else if (item.get("_attributeType") === 'double') {
        formitem = {
            xtype: "numberfield",
            allowBlank: blank,
            disabled: !item.get("_attributeIsEditable"),
            id: formitemid,
            name: item.get("_attributeName"),
            fieldLabel: item.get("_attributeTranslation"),
            value: item.get("_attributeValue"),
            forcePrecision: true,
            decimalPrecision: 3,
            listeners: {
                change: function () {
                    if (Ext.getCmp(formitemid).getValue().length == 0) {
                        Ext.Msg.alert(_maptab_edit_form_field_valid, _maptab_edit_form_field_valid_title_0 + item.get("_attributeTranslation") + _maptab_edit_form_field_valid_title_1);
                        Ext.getCmp(editid).disable(true);
                    } else {
                        _dirty = true;
                        Ext.getCmp(editid).enable();
                    }
                }
            }
        };
    }
    else if (item.get("_attributeType") === 'decimal') {
        formitem = {
            xtype: "numberfield",
            allowBlank: blank,
            disabled: !item.get("_attributeIsEditable"),
            id: formitemid,
            name: item.get("_attributeName"),
            fieldLabel: item.get("_attributeTranslation"),
            value: item.get("_attributeValue"),
            forcePrecision: true,
            decimalPrecision: 3,
            listeners: {
                change: function () {
                    if (Ext.getCmp(formitemid).getValue().length == 0) {
                        Ext.Msg.alert(_maptab_edit_form_field_valid, _maptab_edit_form_field_valid_title_0 + item.get("_attributeTranslation") + _maptab_edit_form_field_valid_title_1);
                        Ext.getCmp(editid).disable(true);
                    } else {
                        _dirty = true;
                        Ext.getCmp(editid).enable();
                    }
                }
            }
        };
    }
    else if (item.get("_attributeType") === 'int') {
        formitem = {
            xtype: "numberfield",
            allowBlank: blank,
            disabled: !item.get("_attributeIsEditable"),
            id: formitemid,
            name: item.get("_attributeName"),
            fieldLabel: item.get("_attributeTranslation"),
            value: item.get("_attributeValue"),
            forcePrecision: true,
            decimalPrecision: 0,
            listeners: {
                change: function () {
                    if (Ext.getCmp(formitemid).getValue().length == 0) {
                        Ext.Msg.alert('Προσοχή!', 'Το πεδίο "' + item.get("_attributeTranslation") + '" δεν πρέπει να είναι κενό!');
                        Ext.getCmp(editid).disable(true);
                    } else {
                        _dirty = true;
                        Ext.getCmp(editid).enable();
                    }
                }
            }
        };
    }
    else if (item.get("_attributeType") === 'date') {

        var vl = null;

        if (item.get("_attributeValue").length == 11) {
            vl = moment(item.get("_attributeValue").replace('Z', '')).add(1, 'day').toDate();
        } else {
            vl = moment(item.get("_attributeValue")).toDate();
        }

        if (vl == 'Invalid Date') {
            vl = null;
        }

        formitem = {
            xtype: "datefield",
            allowBlank: blank,
            disabled: !item.get("_attributeIsEditable"),
            id: formitemid,
            name: item.get("_attributeName"),
            fieldLabel: item.get("_attributeTranslation"),
            value: vl,
            format: 'Y-m-d',
            listeners: {
                change: function () {
                    if (Ext.getCmp(formitemid).getValue().length == 0) {
                        Ext.Msg.alert(_maptab_edit_form_field_valid, _maptab_edit_form_field_valid_title_0 + item.get("_attributeTranslation") + _maptab_edit_form_field_valid_title_1);
                        Ext.getCmp(editid).disable(true);
                    } else {
                        _dirty = true;
                        Ext.getCmp(editid).enable();
                    }
                }
            }
        };
    }
    else if (item.get("_attributeType") === 'dateTime') {

        var vl = moment(item.get("_attributeValue")).toDate();

        if (vl == 'Invalid Date') {
            vl = null;
        }

        formitem = {
            xtype: "datefield",
            allowBlank: blank,
            disabled: !item.get("_attributeIsEditable"),
            id: formitemid,
            name: item.get("_attributeName"),
            fieldLabel: item.get("_attributeTranslation"),
            value: vl,
            format: 'Y-m-d',
            listeners: {
                change: function () {
                    if (Ext.getCmp(formitemid).getValue().length == 0) {
                        Ext.Msg.alert(_maptab_edit_form_field_valid, _maptab_edit_form_field_valid_title_0 + item.get("_attributeTranslation") + _maptab_edit_form_field_valid_title_1);
                        Ext.getCmp(editid).disable(true);
                    } else {
                        _dirty = true;
                        Ext.getCmp(editid).enable();
                    }
                }
            }
        };
    }

    if (item.get("_attributeName").startsWith('uploadfile')) {

        var folders = Ext.create('Ext.data.Store', {
            fields: ['name', 'value'],
            data: [
                { "name": "public", "value": "public" },
                { "name": "secure", "value": "secure" }
            ]
        });

        var combofolder = Ext.create('Ext.form.ComboBox', {
            fieldLabel: "Folder",
            name: 'folder',
            store: folders,
            queryMode: 'local',
            displayField: 'name',
            valueField: 'value',
            value: '',
            editable: false,
            labelWidth: 50,
            anchor: '80%'
        });

        var formid = Ext.id();
        formitem = Ext.create('Ext.form.Panel', {
            id: formid,
            disabled: !item.get("_attributeIsEditable"),
            name: item.get("_attributeName"),
            title: item.get("_attributeTranslation"),
            width: 385,
            bodyPadding: 5,
            frame: true,
            style: { 'margin-top': '10px;' },
            renderTo: Ext.getBody(),
            filetoupload: item.get("_attributeValue"),
            items: [
                {
                    xtype: 'fileuploadfield',
                    id: formitemid,
                    name: 'file',
                    fieldLabel: 'File',
                    labelWidth: 50,
                    msgTarget: 'side',
                    allowBlank: true,
                    anchor: '100%',
                    buttonText: 'Select File...',
                    listeners: {
                        change: function (fld, value) {
                            var newValue = value.replace(/C:\\fakepath\\/g, '');
                            fld.setRawValue(newValue);
                            Ext.getCmp(editid).enable();
                        },
                        afterrender: function (fld, value) {
                            // console.log(item.get("_attributeValue"));
                            var inittxt = item.get("_attributeValue").split(">")[1];
                            var fntxt = inittxt.split("<")[0];
                            fld.setRawValue(fntxt);
                        }
                    }
                },
                combofolder
            ],

            buttons: [{
                text: 'Upload',
                handler: function () {
                    var form = this.up('form').getForm();
                    if (form.isValid()) {
                        form.submit({
                            url: 'upload.php?path=../data/pinakes/',
                            waitMsg: 'Uploading your file...',
                            success: function (form, action) {
                                Ext.Msg.alert('Success', 'Your file "' + action.result.file + '" has been uploaded.');
                                Ext.getCmp(formitemid).setRawValue(action.result.file);
                                Ext.getCmp(formid).filetoupload = action.result.file;
                            },
                            failure: function (form, action) {
                                Ext.Msg.alert('Failed', action.result ? action.result.message : 'No response');
                            }
                        });
                    }
                }
            }]
        });

    }

  /*
    if (layerObject._layerName === "maroussi:mar_ot_pl_geom_moved_clipped" && ['ped_pdf'].includes(item.get("_attributeName"))) {

        var formid = Ext.id();
        formitem = Ext.create('Ext.form.Panel', {
            id: formid,
            disabled: !item.get("_attributeIsEditable"),
            name: item.get("_attributeName"),
            title: item.get("_attributeTranslation"),
            width: 385,
            bodyPadding: 5,
            frame: true,
            style: { 'margin-top': '10px;' },
            renderTo: Ext.getBody(),
            filetoupload: item.get("_attributeValue"),
            items: [
                {
                    xtype: 'filefield',
                    id: formitemid,
                    name: 'files[]',
                    fieldLabel: 'Αρχείαο',
                    labelWidth: 50,
                    msgTarget: 'side',
                    allowBlank: true,
                    anchor: '100%',
                    buttonText: 'Επιλέξτε αρχεία...',
                    listeners: {
                        change: function (fld, value) {
                            //var newValue = value.replace(/C:\\fakepath\\/g, '');
                            //fld.setRawValue(newValue);
                            //Ext.getCmp(editid).enable();

                            var upload = fld.fileInputEl.dom;
                            var files = upload.files;
                            var names = [];
                            var names2 = [];

                            if (files) {
                                for (var i = 0; i < files.length; i++) {
                                    names.push(files[i].name);
                                    names2.push({ archivo: files[i].name })
                                    value = names.join(', ');
                                }
                            }
                            fld.setRawValue(value);
                            Ext.getCmp(editid).enable();

                        },
                        afterrender: function (cmp) {
                            cmp.fileInputEl.set({
                                multiple: 'multiple'
                            });
                        }
                    }
                }
            ],

            buttons: [{
                text: 'Μεταφόρτωση',
                handler: function () {
                    var form = this.up('form').getForm();
                    if (form.isValid()) {
                        form.submit({
                            url: 'uploads.php?path=../data/pped/',
                            waitMsg: 'Μεταφόρτωση αρχείων...',
                            success: function (form, action) {
                                Ext.Msg.alert('Success', 'Τα αρχεία έχουν μεταφορτωθεί.');
                                Ext.getCmp(formitemid).setRawValue(action.result.file.join('|'));
                                Ext.getCmp(formid).filetoupload = action.result.file.join('|');
                            },
                            failure: function (form, action) {
                                Ext.Msg.alert('Failed', action.result ? action.result.message : 'No response');
                            }
                        });
                    }
                }
            }]
        });

    } */

    return formitem;
}