/*
 * Copyright © 2008  Neogeo Technologies, Toulouse, France

 * This file is part of Opencarto web map publishing system project
 *
 * Opencarto is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Opencarto is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with Opencarto.  If not, see <http://www.gnu.org/licenses/>.
 */

var panel;
var oLayer; 
var timeOutInit = window.setTimeout("",100);
var timerInfoPanneau ;
var close_popup_callback = function(e) {
opencarto.vectorLayer.setZIndex(opencarto.map.Z_INDEX_BASE['Popup'] - 1);
if (opencarto.vector) {

   opencarto.vector.destroy();
   opencarto.vector = null;
}
if (opencarto.popup) {

opencarto.popup.destroy();
opencarto.popup = null;
}
OpenLayers.Event.stop(e);
};

function create_popup(point, value) {
   
    
   var lonlat = new OpenLayers.LonLat(point.x, point.y);
    var html = '<span style="font-size:small;overflow:scroll">' + value + '</span>';
   nbLignes = html.split('\n').length
   opencarto.popup = new OpenLayers.Popup.FramedCloud("popup", 
      lonlat,
      new OpenLayers.Size(250,nbLignes * 12),
      html,
      null,
      true,close_popup_callback);
      opencarto.map.addPopup(opencarto.popup);
}
function getFeatureInfo(feature) {
    
    if (opencarto.vector) {
        opencarto.vector.destroy();
        opencarto.vector = null;
   }

    opencarto.vector = feature;
    if (opencarto.popup) {
        opencarto.popup.destroy();
        opencarto.popup = null;
        
    }
    for (i=0;i<opencarto.map.popups.length;i++)
         opencarto.map.removePopup(opencarto.map.popups[i]);
    opencarto.vectorLayer.setZIndex(opencarto.map.Z_INDEX_BASE['Popup'] - 1);
    var geometry = feature.geometry;
    opencarto.actualGeometry = geometry;

    var bounds = opencarto.map.getExtent();
    BBOX = bounds.left + "," + bounds.bottom + "," + bounds.right + "," + bounds.top;
    WIDTH = opencarto.map.size.w;
    HEIGHT = opencarto.map.size.h;  
    X = (feature.geometry.x - bounds.left)/opencarto.map.resolution;
    Y = -(feature.geometry.y - bounds.top)/opencarto.map.resolution;
    var url = 'info/?X='+X+'&Y='+Y+'&BBOX='+BBOX+'&WIDTH='+WIDTH+'&HEIGHT='+HEIGHT+'&layers='
    visibleLayers = opencarto.map.getLayersBy('visibility',true);
    layersToQuery = new Array();       
    for (i=0;i<visibleLayers.length;i++)
    {
        for (j=0;j<opencarto.gisobjects.layers.length;j++)
        {
            myLayer = opencarto.gisobjects.layers[j];
            
            if (visibleLayers[i].name == myLayer.name && visibleLayers[i].calculateInRange() && myLayer.name != 'Google Layer')
                layersToQuery.push(myLayer.options.layerid);

        }
    }
    if (layersToQuery.length > 0){
     url += layersToQuery.join(',');
     OpenLayers.loadURL(url, '', this, displayInfo);
    }
    else{
     Ext.Msg.show({
            title: "ATTENTION",
            msg: "Aucune couche interrogeable n'est visible sur la carte.",
            buttons: Ext.Msg.OK,
            icon: Ext.MessageBox.ERROR
        });
      if (opencarto.vector) {
        opencarto.vector.destroy();
        opencarto.vector = null;
     }
    }
    
}


function displayInfo(request){
  
   var lonlat = new OpenLayers.LonLat(opencarto.actualGeometry.x, opencarto.actualGeometry.y); 
    var html = '<span style="font-size:small;overflow:scroll">' + request.responseText + '</span>';
   nbLignes = request.responseText.split('\n').length
   opencarto.popup = new OpenLayers.Popup.FramedCloud("popup", 
      lonlat,
      new OpenLayers.Size(250,nbLignes * 12),
      html,
      null,
      true,close_popup_callback);
      opencarto.map.addPopup(opencarto.popup);
}

function calculate_length(feature) {
   if (opencarto.vector) {
      opencarto.vector.destroy();
      opencarto.vector = null;
   }

   opencarto.vector = feature;
   if (opencarto.popup) {
      opencarto.popup.destroy();
      opencarto.popup = null;
   }
   var geometry = feature.geometry;
   var perim = Math.ceil(geometry.getLength());
  
   if (perim > 1000)
      perim = Math.ceil(perim / 10) / 100 + ' km';
   else
      perim = perim + ' m';
   var point = geometry.components[geometry.components.length - 1];
   create_popup(point, perim);
}

function calculate_area(feature) {
  
   if (opencarto.vector) {
      opencarto.vector.destroy();
      opencarto.vector = null;
   }

   opencarto.vector = feature;
   if (opencarto.popup) {
      opencarto.popup.destroy();
      opencarto.popup = null;
   }
   var geometry = feature.geometry;
   var area = Math.ceil(geometry.getArea());
   if (area > 1000000)
      area = Math.ceil(area / 10000) / 100 + ' km²';
   else
      area = area + ' m²';
   var perim = Math.ceil(geometry.getLength());
   if (perim > 1000)
      perim = Math.ceil(perim / 10) /100+ ' km';
   else
      perim = perim + ' m';
   var line = geometry.components[geometry.components.length - 1];
   var point = line.components[line.components.length - 1];
   var info = 'Périmètre : ' + perim + '<br />\nSurface : ' + area;
   create_popup(point, info);
}
 
function displayLayer(layerName,v){
   ls = opencarto.map.getLayersByName(layerName);
   for (j=0;j<ls.length;j++)
   {           
       if (ls[j].name == layerName) {                 
           ls[j].setVisibility(v); 
      }

   }
}



function loadCapabilities(request) {
      
   var format = new OpenLayers.Format.XML();
   var capa = format.read(request.responseText);
   var result = new Array();
   var parurl = document.getElementById('wmsurlcur').value ;
    
   if (capa.getElementsByTagName('Layer').length > 0) {
      layers = capa.getElementsByTagName('Layer').item(0).getElementsByTagName('Layer');
      for(i=0;i<layers.length;i++){
         result[i] = new Array();
         layer = layers.item(i);
         for(var k=0;k<layer.childNodes.length;k++){
            attr = 	layer.childNodes[k];
            if(attr.tagName && attr.firstChild){
               if(attr.tagName == 'Name' || attr.tagName == 'Title' || attr.tagName == 'SRS'){     					
                  //alert(i + " : "+attr.tagName +" ==>"+attr.firstChild.nodeValue);
                  result[i][attr.tagName]=attr.firstChild.nodeValue;
               }
            }
         } 
      }
   }
   var content = "<table>";
   content += '<tr class="infotbhd">';
   content += '<td>&nbsp;</td>';
   content += '<td>Nom </td>';
   content += '<td>Resumé </td>';
   content += '</tr>';
   nb_ligne = result.length;
   for(b=0;b<result.length;b++){   
      if(result[b]['SRS'] == result[b]['SRS']){
         content += '<tr id="element'+b+'">';
         content += '<td><img src="images/addcat.png" alt="Ajouter la couche" title="Ajouter la couche" onClick="addLayerWms(\''+result[b]['Name']+'\',\''+parurl+'\');"></td>';
         content += '<td>'+result[b]['Name']+'</td>';
         content += '<td>'+result[b]['Title']+'</td>';
         content += '</tr>';
      }
   }
   content += '</table>';				 	
   document.getElementById('liste_couche').innerHTML = content;				
   CapaTransfert = null;     
}

opencarto.showLegend = function(){
   visibleLayers = opencarto.map.getLayersBy('visibility',true);
   strHTML = '';
   for (i=0;i<visibleLayers.length;i++){
      for (j=0;j<opencarto.gisobjects.layers.length;j++){
         myLayer = opencarto.gisobjects.layers[j];
         if (visibleLayers[i].name == myLayer.name && myLayer.options.typegeo != 'RASTER' && myLayer.options.showInLegend && visibleLayers[i].calculateInRange()){
            url = 'legend/?layer=' + myLayer.name + '&extent='+opencarto.map.getExtent().toArray().join(',');
            if(visibleLayers[i].params.SLD)
            {
               url += '&sldurl='+visibleLayers[i].params.SLD
               var layerLabel = '';
               for (k=0;k<visibleLayers[i].options.sldFiles.length;k++)
               {
                  if (visibleLayers[i].options.sldFiles[k].sldurl == visibleLayers[i].params.SLD)
                     layerLabel = visibleLayers[i].options.sldFiles[k].name;
               }
               if (layerLabel=='')
                  layerLabel = myLayer.name;
               strHTML += "<font face='verdana' size='2'><b>&nbsp;"+ layerLabel + "</b></font><br />&nbsp;&nbsp;&nbsp;&nbsp;<img src='" + url +"' border='0' /><br />";
            }
            else
               strHTML += "<font face='verdana' size='2'><b>&nbsp;"+ myLayer.label + "</b></font><br />&nbsp;&nbsp;&nbsp;&nbsp;<img src='" + url +"' border='0' /><br />";
//               strHTML += "<img src='" + url +"' border='0' /><br />";
         }
      }
   }
   opencarto.legendPanel.body.update(strHTML);
}
opencarto.layerSelect = function(sm, rIdx, r) {
 
   if (opencarto.selection.toolbar.disabled)
      opencarto.selection.toolbar.enable();
   ls = opencarto.map.getLayersByName(r.get('name'));
  
   
   /*opencarto.selection.unSelectAll();
   opencarto.datagrid.grid.destroy();
   target = Ext.getCmp('dataLayer');
   target.setTitle('Données');
   target.collapse();
 */
}
opencarto.setLayerOpacity = function(item){
   // récupération de la couche sélection

   if (item.checked){
      toks = item.id.split('&');
      alphaValue = toks[1].replace('alpha','');
      layerName = toks[0];
      ls = opencarto.map.getLayersByName(layerName);
      ls[0].setOpacity(alphaValue/100);
   } 
   
}

opencarto.resizeMap = function(p){
  
   opencarto.map.updateSize();
  // opencarto.map.panTo(opencarto.map.getCenter());
   
   
}
opencarto.onContextClick = function(grid, rowindex,e){
   
   
   this.menu = new Ext.menu.Menu({
       id:'grid-ctx',
       items: []
   });
   //this.menu.on('hide', this.onContextHide, this);
   
   myRec = grid.store.getAt(rowindex);
   myOlLayers = opencarto.map.getLayersByName(myRec.get('name'));
   sldItems = null;
   if(opencarto.sld.loaded && myRec.get('options.sldFiles') && myRec.get('options.sldFiles').length > 0){
      sldItems = new Array();
      
      for (i=0;i<myRec.get('options.sldFiles').length;i++)
      {
         mySldFile = myRec.get('options.sldFiles')[i];
        
         var myItem = new Ext.menu.CheckItem({
            id:'sld'+i,
            text: mySldFile.name,
            group:'sld',
            layer:myOlLayers[0].name,
            sld:mySldFile.sldurl,
            checked: myOlLayers[0].params.SLD== mySldFile.sldurl?true:false,
            checkHandler: opencarto.onSldChange
         });
         sldItems.push(myItem);
      }
      sldItems.push('<b class="menu-title">Edition</b>');
      editItem = new Ext.menu.Item({
            id:'sldEdit',
            text: "Modifier la représentation",
            layer:myOlLayers[0].name,
            sld:myOlLayers[0].params.SLD,
            listeners:{
               click:opencarto.sld.editSLD
            }
            });
      sldItems.push(editItem);
      addItem = new Ext.menu.Item({
            id:'sldAdd',
            text: "Nouvelle représentation",
            layer:myOlLayers[0].name,
            listeners:{
               click:opencarto.sld.editSLD
            }
            });
      sldItems.push(addItem);
      if (globalParams.userAdmin){
         delItem = new Ext.menu.Item({
               id:'sldDel',
               text: "Supprimer la représentation",
               layer:myOlLayers[0].name,
               sld:myOlLayers[0].params.SLD,
               listeners:{
                  click:opencarto.sld.delSLD
               }
               });
         sldItems.push(delItem);
      }
      
   }
   else if(opencarto.sld.loaded && myRec.get('options.typegeo') != 'RASTER'){
      sldItems = new Array();
      addItem = new Ext.menu.Item({
            id:'sldAdd',
            text: "Nouvelle représentation",
            layer:myOlLayers[0].name,
            listeners:{
               click:opencarto.sld.editSLD
            }
            });
      sldItems.push(addItem); 
   }
   if (sldItems){
   sldMenu = new Ext.menu.Item({
         text : 'Représentations',
         menu :{
            items:sldItems  
         } 
      })
   }
   if(myRec.get('name') != 'Google Layer'){
      var exportItem1 = new Ext.menu.Item({
           text: 'Zoom sur la couche',
           iconCls: 'zoomToLayer',
           scope:this,
           handler: function(){
               opencarto.zoomToLayer(this.ctxRecord.get('options.layerid'));
           }
      });
      this.menu.add(exportItem1); 
   }
   else{
      var ggItem = new Ext.menu.Item({
         text: 'Choix de la couche Google',
                menu: {  
                    items: [
                        {
                            id:'G_SATELLITE_MAP',
                            text: 'Satellite',
                            group: 'gmap',
                            checked: globalParams.googlelayer == G_SATELLITE_MAP?true:false,
                            checkHandler: opencarto.setGoogleStyle
                        }, {
                           id:'G_NORMAL_MAP',
                            text: 'Fond de Plan',
                            group: 'gmap',
                            checked: globalParams.googlelayer == G_NORMAL_MAP?true:false,

                            checkHandler: opencarto.setGoogleStyle
                        }, {
                           id:'G_HYBRID_MAP',
                            text: 'Mixte',
                            group: 'gmap',
                            checked: globalParams.googlelayer == G_HYBRID_MAP?true:false,

                            checkHandler: opencarto.setGoogleStyle
                        }, {
                           id:'G_PHYSICAL_MAP',
                            text: 'Relief',
                            group: 'gmap',
                            checked: globalParams.googlelayer == G_PHYSICAL_MAP?true:false,
                            checkHandler: opencarto.setGoogleStyle
                        },
                    ]
                }
      });
      this.menu.add(ggItem);
   }
   alphaValue = myOlLayers[0].opacity *100;
   opacItems = new Array();
   for (i=10;i<=100;i=i+10){
      var newItem = new Ext.menu.CheckItem({
            id:myRec.get('name') +'&alpha' + i.toString(),
            text: i  + ' %',
            group: 'alpha',
            checked: alphaValue==i?true:false,
            checkHandler: opencarto.setLayerOpacity
        })
      opacItems.push(newItem);
      
   }
   
   var alphaItem = new Ext.menu.Item({
      text: 'Opacité',
             menu: {  
                 items: opacItems
             }

   });
   this.menu.add(alphaItem);
   if(myRec.get('options.typegeo') != 'RASTER'){
      var exportItem1 = new Ext.menu.Item({
         iconCls: 'openTable',
                  text:'Voir les données',
                  scope:this,
                  handler: function(){
                      grid.getSelectionModel().selectRow(rowindex);
                        opencarto.selection.unSelectAll();
                      opencarto.displayData(this.ctxRecord.get('options.layerid'));
                  }
      });
      this.menu.add(exportItem1); 
   }
   
   if(opencarto.search.geom != null && myRec.get('options.search') != false){
      var searchItem = new Ext.menu.Item({
         iconCls: 'search',
         text:'Rechercher...',
         scope:this,
         handler: function(){
            opencarto.search.showSearchWindow(this.ctxRecord);
         }
      });
      this.menu.add(searchItem); 
   }
   if(myRec.get('options.exporter') && myRec.get('options.typegeo') != 'RASTER'){
      var exportItem2 = new Ext.menu.Item({
         iconCls: 'exportData',
                  text:'Exporter...',
                  scope:this,
                  handler: function(){
                      grid.getSelectionModel().selectRow(rowindex);
                      opencarto.showExportWindow(this.ctxRecord);
                  }
      });
      this.menu.add(exportItem2);
   }
   if (opencarto.sld.loaded && sldItems)
      this.menu.add(sldMenu);
      
   var mdItem = new Ext.menu.Item({
         text:'Métadonnées',
         scope:this,
         handler: function(){
            opencarto.showMDWindow(this.ctxRecord);
         }
      });
   this.menu.add(mdItem);   
      
   e.stopEvent();
   if(this.ctxRow){
       Ext.fly(this.ctxRow).removeClass('x-node-ctx');
       this.ctxRow = null;
   }
   this.ctxRow = this.view.getRow(rowindex);
   this.ctxRecord = this.store.getAt(rowindex);
   Ext.fly(this.ctxRow).addClass('x-node-ctx');
   this.menu.showAt(e.getXY());
}
opencarto.setGoogleStyle = function(obj){
   globalParams.googlelayer = eval(obj.id);
   myLayer = opencarto.gisobjects.layers[0];
   myLayer.params.type = globalParams.googlelayer;
   var gl = new OpenLayers.Layer.Google(myLayer.name,myLayer.params, myLayer.options);
   var myOldLayer = opencarto.map.getLayersByName('Google Layer');
   opencarto.map.removeLayer(myOldLayer[0],false);
   gl.isBaseLayer = true
   opencarto.map.addLayer(gl);
 
   
}



function renderURL(value, p, record){
   layerID = opencarto.layerGrid.getSelectionModel().getSelected().get('name');
      return String.format(
         '<b><a href="/media/DOCS/{0}/{1}" class="pdflink" target="_blank" title="Cliquer pour télécharger le document"><img src="/media/images/export.png" border="0" />&nbsp;&nbsp;{1}</a></b>',layerID,value);
   }

opencarto.displayData = function(layerID, fieldName, fieldValue, fieldType){
   
   opencarto.Mask.show();
   
   opencarto.datagrid.grid.getSelectionModel().clearSelections();
   if (opencarto.vector) {
                opencarto.vector.destroy();
                opencarto.vector = null;
   }
  
   Ext.Ajax.request({
      url:'../layer/'+layerID+'/data_structure/',
      success:function(res,opt) {
      eval('opencarto.layerdata = ' + res.responseText);
      var  dsfields = [];
      for (i=0;i<opencarto.layerdata.fields.length;i++)
      {
         f = opencarto.layerdata.fields[i];
         dsfields[i] = f.name;
        
      }
    
      if (opencarto.selection.wkt && opencarto.selection.mode){
         if (opencarto.selection.mode == 'ST_Distance')
            opencarto.selection.mode = 'ST_Intersects'
         bp = {'selectionWKT':opencarto.selection.wkt,'proj':globalParams.projection.replace('epsg:',''),'mode':opencarto.selection.mode};
      }
      else if (fieldName && fieldValue)
         bp= {'filter[0][field]':fieldName,'filter[0][data][value]':fieldValue,'filter[0][data][type]':fieldType,'filter[0][data][comparison]':'='};
      else if (opencarto.search.geom != '' && opencarto.selection.mode){
         if (opencarto.search.queryID)
            bp={'queryID':opencarto.search.queryID,'selectionWKT':opencarto.search.geom,'proj':globalParams.projection.replace('epsg:',''),'mode':opencarto.selection.mode,'origin':'search'};
         else
            bp={'selectionWKT':opencarto.search.geom,'proj':globalParams.projection.replace('epsg:',''),'mode':opencarto.selection.mode,'origin':'search'};
      }
      else if (opencarto.search.queryID)
         bp={'queryID':opencarto.search.queryID,'proj':globalParams.projection.replace('epsg:',''),'origin':'search'}
      else
         bp = {};
      if (bp.mode && opencarto.selection.mode == 'ST_Distance'){
         bp.distance = opencarto.search.distance;
      }
      if (opencarto.search.attributeValues)
      {
         toks = opencarto.search.attributeValues.split('&');
         for (i=0;i<toks.length;i++)
         {
            fieldData = toks[i].split('=');
            if (fieldData[0].indexOf('attField')>-1)
            {
               eval("bp."+fieldData[0]+"=fieldData[1]");
            }
         }
         
      }
      
      opencarto.search.attributeValues = null;
      var ds = new Ext.data.JsonStore({
         url:url = '../layer/'+layerID+'/data/',
         baseParams:bp,
         storeId: 'gid',
         totalProperty: 'total',
         root: 'data',
         fields: dsfields,
         sortInfo: {field: dsfields[1].name, direction: 'ASC'},
         remoteSort: true,
         listeners:{
            load:opencarto.selection.selectAll
         }
       });
      
      // reconfiguration du cm
      var cmfields = [];
      var dataFilters = [];
      colWidth = parseInt(600 / opencarto.layerdata.fields.length-1);
      for (i=0;i<opencarto.layerdata.fields.length;i++)
      {
         f = opencarto.layerdata.fields[i];
         if (f.fieldtype == 'url')
         {
            cmfields[i] = {name:f.name,header:f.name.toUpperCase(),width:i>0?colWidth:15, sortable:true,dataIndex:f.name,renderer: renderURL};
            f.fieldtype = 'string'
         }
         else
         {
            cmfields[i] = {name:f.name,header:f.name.toUpperCase(),width:i>0?colWidth:15, sortable:true,dataIndex:f.name};
         }
         dataFilters[i] = {type:f.fieldtype,dataIndex:f.name};
      }
      var colModel = new Ext.grid.ColumnModel(cmfields);
      var filters = new Ext.grid.GridFilters({
            filters:dataFilters});
      if (opencarto.selection.wkt || opencarto.search.queryID || opencarto.search.geom != '')
         myPageSize = 250;
      else
         myPageSize = 10;
      var pt = new Ext.PagingToolbar({
           store:ds,
           pageSize: myPageSize,
           plugins: filters,
           items:[
               {id:'zoom',text: 'Zoom sur objet', handler: opencarto.zoomVector},
               {id:'center',text: "Centrer sur l'objet", handler: opencarto.centerVector},
               {id:'deselect',text: "Tout déselectionner", handler: opencarto.selection.unSelectAll}]
         })
      
      grid = new Ext.grid.GridPanel({
         id:'dataGrid',
         store: ds,
         cm: colModel,
         border:false,
         enableColLock: false,
         loadMask: true,
         plugins:filters,
         viewConfig: {
            forceFit: true
         },

         bbar: pt,
         sm: new Ext.grid.RowSelectionModel({singleSelect:false}),       
         autoExpandColumn: dsfields[1].name
      });
      
      opencarto.datagrid.grid.destroy();
      opencarto.datagrid.grid = grid;
      opencarto.datagrid.grid.getSelectionModel().on(
         'rowselect',
         opencarto.datagrid.prepareGeom
     );
      
      
      target = Ext.getCmp('dataLayer');
      target.add(opencarto.datagrid.grid);
      ds.load({params:{start: 0, limit: myPageSize, sort:dsfields[1].name}});
      target.doLayout();
   
      
      
      
  },
   failure: function(res,opt){
                  Ext.Msg.show({
          title: "ERREUR",
          msg: "Le flux de description des couches n'a pas pu être chargé",
          buttons: Ext.Msg.OK,
          icon: Ext.MessageBox.ERROR
      });
                  return;
          }   
  });
   
   
}
opencarto.datagrid.prepareGeom = function()
{
   if (opencarto.tm) {
      clearTimeout(opencarto.tm);
    }
   opencarto.vectorLayer.destroyFeatures(opencarto.vectorLayer.features);
   opencarto.tm = setTimeout("opencarto.datagrid.getGeom()", 50);
   
   
}
opencarto.datagrid.getGeom = function(){
  //opencarto.selectHandler.activate();
      
      if(opencarto.datagrid.grid.getSelectionModel().hasSelection())
      {
         rows = opencarto.datagrid.grid.getSelectionModel().getSelections();
         aID = new Array();
         for (i=0;i<rows.length;i++)
         {
            aID.push(rows[i].get('gid'));
         }
         try{
            layer_id = opencarto.layerGrid.getSelectionModel().getSelected().get('options.layerid');
         }
         catch(e){
            if (opencarto.search.target_id)
               layer_id = opencarto.search.target_id;
            else
               return;
            
         }
         Ext.Ajax.request({
            url:'../layer/'+layer_id+'/geom/?ids=' + aID.join(',')+'&res=' + parseInt(opencarto.map.getResolution()) + '&proj=' + globalParams.projection.replace('epsg:',''),
            success:function(res,opt) {
               eval('opencarto.vectorfeatures = ' + res.responseText);
               var format = new OpenLayers.Format.WKT();
               var error = 0
               for (i=0;i<opencarto.vectorfeatures.records.length;i++){
                  theFeature = opencarto.vectorfeatures.records[i];
                  try{
                     var feature = format.read(theFeature.geom);
                     if (feature){
                        opencarto.vectorLayer.addFeatures([feature]);
                     }
                  }
                  catch(e){
                     error = 1
                  }
               }
               if (error == 1){
                  Ext.Msg.show({
                   title: "ERREUR",
                   msg: "Certains objets n'ont pas pu être affichés car leur géométrie est invalide.",
                   buttons: Ext.Msg.OK,
                   icon: Ext.MessageBox.ERROR
                  });
               }
            },
            failure: function(res,opt){
               Ext.Msg.show({
                   title: "ERREUR",
                   msg: "Impossible de récupérer les objets demandés",
                   buttons: Ext.Msg.OK,
                   icon: Ext.MessageBox.ERROR
               });
               return;
           }
         });
      }
}

opencarto.zoomToLayer = function(layerID){

   Ext.Ajax.request({
		url:'../layer/'+layerID+'/extent/?proj=' + globalParams.projection.replace('epsg:',''),
		success:function(res,opt) {
            try{
            eval('geoextent = new OpenLayers.Bounds(' + res.responseText+')');
            opencarto.map.zoomToExtent(geoextent);
            }
            catch(e){
               Ext.Msg.show({
                title: "ERREUR",
                msg: "Le zoom sur la couche a échoué !",
                buttons: Ext.Msg.OK,
                icon: Ext.MessageBox.ERROR
            }); 
            }
        },
         failure: function(res,opt){
		   	Ext.Msg.show({
                title: "ERREUR",
                msg: "Le zoom sur la couche a échoué !",
                buttons: Ext.Msg.OK,
                icon: Ext.MessageBox.ERROR
            });
		   	return;
		}   
	});
   
   
}
opencarto.onGridCollapse = function(p){
   if (opencarto.map)
      opencarto.map.updateSize();
   
}

opencarto.adminHandler = function() {
   
   f = window.open('/opencarto/admin/','admin');
}
opencarto.toolbarHandler = function(btn,e) {
   
   
   lastBtn = null;
   for (i=0;i<opencarto.toolbar.items.length;i++)
   {
      theBtn = opencarto.toolbar.items.get(i);
      if(theBtn.pressed){
         lastBtn = theBtn;
         theBtn.toggle();
      }
   }
   btn.toggle();
   switch(btn.id){
      case 10:
         opencarto.map.zoomToMaxExtent();
         btn.toggle();
         if(lastBtn)
            lastBtn.toggle();
         return;
         break;
      case 11:
         ctlClassName = 'olControlZoomBox';
         break;
      case 12:
         opencarto.map.zoomOut();
         btn.toggle();
         if(lastBtn)
            lastBtn.toggle();
         return;
         break;
      case 13:
         ctlClassName = 'olControlNavigation';
         break;
      case 14:
         ctlClassName = 'olControlCalculateLength';
         break;
      case 15:
         ctlClassName = 'olControlCalculateArea';
         break;
      case 16:
         ctlClassName = 'getInfoControl';
         break;
      case 99:
         opencarto.selection.activateControl();
         return;
         break;
      case 17:
         opencarto.vectorLayer.destroyFeatures(opencarto.vectorLayer.features);
         btn.toggle();
         if(lastBtn)
            lastBtn.toggle();
         return;
         break;
      case 95:
         
         btn.toggle();
         if(lastBtn)
            lastBtn.toggle();
         return;
         break;
         
      case 98:
         var w = opencarto.print.selectedTemplate.width;
         var h = opencarto.print.selectedTemplate.height;
         var tplId = opencarto.print.selectedTemplate.id;
         url = 'print/?tpl='+tplId;
         win = window.open(url,'printWindow','menubar=no ,status=no, scrollbars=no, menubar=no, width=' + w + ', height='+h);
         btn.toggle();
         if(lastBtn)
            lastBtn.toggle();
         
         return;
         break;
   }
   opencarto.getMapControl(opencarto.lastControlUsed).deactivate();
   opencarto.getMapControl(ctlClassName).activate();
   opencarto.lastControlUsed = ctlClassName;
   
}
opencarto.getMapControl = function(className){
   for (i=0;i<opencarto.map.controls.length;i++)
   {
      theCtl = opencarto.map.controls[i];
      if(theCtl.displayClass == className)
      {
         return theCtl;
      }
   }
   return null;
}

opencarto.showExportWindow = function(rec){
   opencarto.projStore = new Ext.data.JsonStore({
      id: 'ps',
      autoLoad:true,
      url: '../../projections/',
      root: 'projs',
      fields: ['name', 'code']
   });

   var form = new Ext.form.FormPanel({
      baseCls: 'x-plain',
      url:'export',
      items: [{
         id:'cbformat',
         hiddenName:'format',
         xtype: 'combo',
         editable: false,
         fieldLabel: 'Format',
         displayField: 'name',
         valueField: 'code',
         forceSelection:true,
         labelWidth:150,
         emptyText:'Choisir un format...',
         store: new Ext.data.Store({
             reader: new Ext.data.ArrayReader(
                 {}, [
                     {name: 'code'},
                     {name: 'name'},
                 ]
             ),
             data: [
                 ['SHP','ESRI Shapefile'],
                 ['TAB','MapInfo TAB'],
                 ['MIF','MapInfo MIF/MID'],
                 ['GML','GML'],
                 ['KML','KML']
             ]
         }),
         mode: 'local'
         },
        {
         id:'cbprojection',
         hiddenName:'projection',
         triggerAction: 'all',
         labelWidth:150,
         xtype: 'combo',
         lazyInit: true,
         editable: false,
         fieldLabel: 'Projection',
         displayField: 'name',
         valueField: 'code',
         forceSelection:true,
         emptyText:'Choisir une projection...',
         store: opencarto.projStore,
         mode:'local'},
         {
            xtype:'fieldset',
            title: 'Etendue géographique de l\'export',
            autoHeight: true,
            items: [{
                xtype: 'radiogroup',
                fieldLabel: 'Choix de l\'étendue',
                id:'rdextent',
                items: [
                    {boxLabel: 'Tout', name: 'extent', inputValue: 1, checked: true},
                    {boxLabel: 'Fenêtre', name: 'extent', inputValue: 2},
                    {boxLabel: 'Sélection', name: 'extent', inputValue: 3}
                   
                ]
            }
         ]
      }
   ]
  });
         
   opencarto.exportWindow = new Ext.Window({
      title: 'Téléchargement des données SIG',
      width: 400,
      height:220,
      minWidth: 400,
      minHeight: 220,
      layout: 'fit',
      closeAction :'close',
      plain:true,
      bodyStyle:'padding:5px;',
      buttonAlign:'center',
      items:form,
      buttons: [{
          text: 'Télécharger',
          handler : function() {
            vals = form.getForm().getValues(false);
            opencarto.downloadLayer(rec.get('options.layerid'),vals)
          }
      },{
          text: 'Annuler',
          handler  : function(){
               opencarto.exportWindow.destroy();
               opencarto.exportWindow = null;
           }

      }]
   });
        opencarto.exportWindow.show();
 
}
opencarto.downloadLayer = function(idLayer,vals){
   if (idLayer && vals.format && vals.projection)
   {
      var myMask = new Ext.LoadMask(opencarto.exportWindow.getEl(), {
          removeMask:true,
            msg:"Préparation des données en cours..."});
            myMask.show();
   }
   extraOption = ''
   if (vals.extent == 2)
      extraOption = '&extent='+opencarto.map.getExtent().toArray().join(',')+'&projExtent='+globalParams.projection;
   else if(vals.extent == 3)
   {
      if (opencarto.datagrid.grid.getSelectionModel().hasSelection() == false)
      {
         Ext.Msg.show({
                title: "Exportation impossible",
                msg: "Il n'y a pas de sélection dans la grille",
                buttons: Ext.Msg.OK,
                icon: Ext.MessageBox.ERROR
            });
         myMask.hide();
         return;
      }
      aIds = new Array();
      rows =opencarto.datagrid.grid.getSelectionModel().getSelections();
      for (i=0;i<rows.length;i++)
      {
         aIds.push(rows[i].get('gid'));
      }
      extraOption = '&ids=' + aIds.join(',');
   }
   Ext.Ajax.request({
       timeout:120000,
        url:'../export/?objid=' + idLayer + '&f='+vals.format+'&proj=' +vals.projection+extraOption,
		success:function(res,opt) {
         opencarto.exportWindow.destroy();
         opencarto.exportWindow = null;
         this.location = '../getZipFile/?file='+res.responseText
        },
        failure: function(res,opt){
		   opencarto.exportWindow.destroy()
         opencarto.exportWindow = null;
            Ext.Msg.show({
                title: "ERREUR",
                msg: "La données n'a pas pu être téléchargée",
                buttons: Ext.Msg.OK,
                icon: Ext.MessageBox.ERROR
            });
		   	return;
		}
   });
}
opencarto.zoomVector = function(){
   bb = opencarto.getVectorExtent();
   if (bb)
      opencarto.map.zoomToExtent(bb);
   opencarto.datagrid.prepareGeom();
}
opencarto.centerVector = function(){
   bb = opencarto.getVectorExtent();
   if (bb)
   {
      var p = bb.getCenterLonLat();
      opencarto.map.panTo(p);
   }
   
}
opencarto.getVectorExtent = function(){
   var bb = null;
   for (i=0;i<opencarto.vectorLayer.features.length;i++)
   {
      f = opencarto.vectorLayer.features[i];
      if (!bb)
         bb = f.geometry.getBounds();
      else{
         var newBounds = f.geometry.getBounds();
         
         if (newBounds.left < bb.left)
            bb.left = newBounds.left;
         if (newBounds.top > bb.top)
            bb.top = newBounds.top;
         if (newBounds.right > bb.right)
            bb.right = newBounds.right;
         if (newBounds.bottom < bb.bottom)
            bb.bottom = newBounds.bottom;
            
         
      }
      
   }
   return bb;
   
   
}

opencarto.print.onSmCheck = function(item){
   if (item.checked){
         itemId = item.id.replace('printTpl','');
         for (i=0;i<opencarto.print.printTpl.length;i++){
            if (opencarto.print.printTpl[i].id == itemId)
               opencarto.print.selectedTemplate = opencarto.print.printTpl[i];
         
         }
   } 
}

opencarto.onSldChange = function(item){
    if (item.checked){
      myLayers = opencarto.map.getLayersByName(item.layer);
      myLayers[0].mergeNewParams({sld: item.sld});
      opencarto.showLegend();
    }
   
   
}

opencarto.ZoomToPosition = function(cb,rec,idx){
   
   x = rec.get('x');
   y = rec.get('y');
   z = rec.get('z');
   if (z != opencarto.map.getZoom()){
      opencarto.map.setCenter(new OpenLayers.LonLat(x,y),z);
   }
   else{
      
      opencarto.map.panTo(new OpenLayers.LonLat(x,y));
   }
   cb.reset();
   
}

opencarto.addPosition = function(){
   Ext.MessageBox.prompt('Nouvelle position', 'Nom de la nouvelle position :', opencarto.savePosition);
   
}
opencarto.savePosition = function(btn,name){
   if (btn == 'ok' && name != ''){
      xy = opencarto.map.getCenter();
      z = opencarto.map.getZoom();
      x = xy.lon;
      y = xy.lat;
      Ext.Ajax.request({
         url:'addposition/',
         params: { 
             name: name,
             x:x,
             y:y,
             z:z
         },
        method: 'GET',
         success:function(res,opt) {
            if (res.responseText == '1'){
               Ext.MessageBox.alert('Succès', 'La position a bien été ajoutée.');
               opencarto.positionStore.reload();
            }
            else
               Ext.MessageBox.alert('Erreur', "La position n'a pas pu être ajoutée");
         },
         failure:function(res,opt){
            Ext.MessageBox.alert('Erreur', "La position n'a pas pu être ajoutée");
            
         }
      });
   }
   else if(btn=='ok' && name == '')
       Ext.MessageBox.alert('Erreur', 'Vous devez renseignez le nom de la position', opencarto.addPosition);

   
}

opencarto.getLayerType = function(layerName){
   
   for (i=0;i<opencarto.gisobjects.layers.length;i++)
   {
      myLayer = opencarto.gisobjects.layers[i];
      
      if (myLayer.name == layerName)
         return myLayer.options.typegeo;
      
   }
   return null;
   
   
}
opencarto.getLayerId = function(layerName){
   
   for (i=0;i<opencarto.gisobjects.layers.length;i++)
   {
      myLayer = opencarto.gisobjects.layers[i];
      
      if (myLayer.name == layerName)
         return myLayer.options.layerid;
      
   }
   return null; 
}
opencarto.getLayerName = function(layerId){
   
   for (i=0;i<opencarto.gisobjects.layers.length;i++)
   {
      myLayer = opencarto.gisobjects.layers[i];
      
      if (myLayer.options.layerid == layerId)
         return myLayer.name;
      
   }
   return null; 
}

opencarto.showMDWindow = function(rec){
   
   opencarto.MDWindow = new Ext.Window({
      title: 'Métadonnées',
      width: 400,
      height:220,
      minWidth: 400,
      minHeight: 220,
      layout: 'fit',
      closeAction :'close',
      plain:true,
      bodyStyle:'padding:5px;',
      buttonAlign:'center',
      buttons: [{
          text: 'Fermer',
          handler  : function(){
               opencarto.MDWindow.destroy();
               opencarto.MDWindow = null;
           }

      }]
   });
   opencarto.MDWindow.show();
   
   layer_id = rec.get('options.layerid');
   opencarto.MDtpl = new Ext.Template(
   '<p><b>Format :</b> {format}</p>',
   '<p><b>Projection :</b> {projection}</p>',
   '<p><b>Description :</b> {description}</p>',
   '<p><b>Auteur :</b> {auteur}</p>',
   '<p><b>Source :</b> {source}</p>',
   '<p><b>Date de mise à jour :</b> {dmaj}</p>',
   '<p><b>Echelle :</b> {echelle}</p>'
   
   );
   Ext.Ajax.request({
        url: '../metadata/',
        method: 'GET',
        params: {
            layer_id: layer_id 
        },
        success: function(res,opt) {
		   	// affectation de la réponse à un objet global
            try {
                eval('var response = ' + res.responseText);
            } catch(e) {
               
            }
            
            // mise à jour de la description de l'itinéraire --------------------------------
            if (response) {
               opencarto.MDtpl.overwrite(opencarto.MDWindow.body, response);
               opencarto.MDWindow.body.highlight('#c3daf9', {block:true});
            }
        },
        failure: function(res,opt){
          Ext.MessageBox.alert('Erreur', "Les données n'ont pas pu être récupérées");
         
         
        }
   });  
}