PageRenderTime 116ms CodeModel.GetById 45ms RepoModel.GetById 7ms app.codeStats 1ms

/class.xmodmap.inc

https://github.com/jcplat/console-seolan
PHP | 1229 lines | 1059 code | 30 blank | 140 comment | 175 complexity | 480be8dd2bb96280afb49a91f1380da8 MD5 | raw file
Possible License(s): LGPL-2.0, LGPL-2.1, GPL-3.0, Apache-2.0, BSD-3-Clause 
    

  1. <?php
    2. 

  2. /**
    3. 

  3. module geocodage et 'cartographie' 
    4. 

  4. l'EF contient les paramètres de gestion des EF utilisant des points geographiques
    5. 

  5. fonction d'aide a la saisie via la carte
    6. 

  6. fonctions de geocodage
    7. 

  7. fonctions de restitution google map
    8. 

  8. */
    9. 

  9. define('EARTHRAY',6378.137);
    10. 

  10. class XModMap extends XModTable{
    11. 

  11.   static $defaultSRS = 'MAPSRS:EPSG4326'; 
    12. 

  12.   var $googleGeoCodeUrl = 'http://maps.google.fr/maps/geo?';
    13. 

  13.   var $googleGeoCodeEncoding = 'UTF-8 ? a voir ';
    14. 

  14.   /* la pertinence d'une adresse */
    15. 

  15.   var $googleGeoAccuracy = array('0'=>array(0, 'Unknown location.'),
    16. 

  16. 				 '1'=>array(1, 'Country level accuracy'),
    17. 

  17. 				 '2'=>array(2, 'Region (state, province, prefecture, etc.) level accuracy'),
    18. 

  18. 				 '3'=>array(3, 'Sub-region (county, municipality, etc.) level accuracy.e'),
    19. 

  19. 				 '4'=>array(4, 'Town (city, village) level accuracy'),
    20. 

  20. 				 '5'=>array(5, 'Post code (zip code) level accuracy'),
    21. 

  21. 				 '6'=>array(6, 'Street level accuracy'),
    22. 

  22. 				 '7'=>array(7, 'Intersection level accuracy'),
    23. 

  23. 				 '8'=>array(8, 'Address level accuracy'),
    24. 

  24. 				 '9'=>array(9, 'Permise level accuracy')
    25. 

  25. 				 );
    26. 

  26. 				 
    27. 

  27.   /* les status http geocodage google */
    28. 

  28.   var $googleGeoStatus = array('200'=>array(200, 'G_GEO_SUCCESS (200)', 'No errors occurred; the address was successfully parsed and its geocode has been returned. (Since 2.55)'),
    29. 

  29. 			       '400'=>array(400, 'G_GEO_BAD_REQUEST (400)', 'A directions request could not be successfully parsed. (Since 2.81)'),
    30. 

  30. 			       '500'=>array(500, 'G_GEO_SERVER_ERROR (500)', 'A geocoding or directions request could not be successfully processed, yet the exact reason for the failure is not known. (Since 2.55)'),
    31. 

  31. 			       '601'=>array(601, 'G_GEO_MISSING_QUERY (601)', 'The HTTP q parameter was either missing or had no value. For geocoding requests, this means that an empty address was specified as input. For directions requests, this means that no query was specified in the input. (Since 2.81)'),
    32. 

  32. 			       '602'=>array(602, 'GEO_UNKNOWN_ADDRESS (602)', 'No corresponding geographic location could be found for the specified address. This may be due to the fact that the address is relatively new, or it may be incorrect. (Since 2.55)'),
    33. 

  33. 			       '603'=>array(603, 'G_GEO_UNAVAILABLE_ADDRESS (603)', 'The geocode for the given address or the route for the given directions query cannot be returned due to legal or contractual reasons. (Since 2.55)'),
    34. 

  34. 			       '604'=>array(604, 'G_GEO_UNKNOWN_DIRECTIONS (604)', 'The GDirections object could not compute directions between the points mentioned in the query. This is usually because there is no route available between the two points, or because we do not have data for routing in that region. (Since 2.81)'),
    35. 

  35. 			       '610'=>array(610, 'G_GEO_BAD_KEY (610)', 'The given key is either invalid or does not match the domain for which it was given. (Since 2.55)'),
    36. 

  36. 			       '620'=>array(620, 'G_GEO_TOO_MANY_QUERIES (620)', '')
    37. 

  37. 			       );
    38. 

  38. 

  39. 

  40.   function __contruct($ar=NULL){
    41. 

  41.     parent::__construct($ar);
    42. 

  42.     XLabels::loadLabels('xmodmap');
    43. 

  43.   }
    44. 

  44.   /// securite des fonctions accessibles par le web
    45. 

  45.   function secGroups($function, $group=NULL) {
    46. 

  46.     $g=array();
    47. 

  47.     $g['preConvertCoords']=array('ro', 'rw', 'rwv', 'admin');
    48. 

  48.     $g['procConvertCoords']=array('ro', 'rw', 'rwv', 'admin');
    49. 

  49.     $g['convertCoords']=array('none', 'ro', 'rw', 'rwv', 'admin');
    50. 

  50.     $g['geoSearch']=array('ro', 'rw','rwv','admin');
    51. 

  51.     $g['simpleLayerKML']=array('none', 'list', 'ro', 'rw', 'rwv', 'admin');
    52. 

  52.     $g['rawLayer']=array('none', 'list', 'ro', 'rw', 'rwv', 'admin');
    53. 

  53.     $g['geoCodeAuto']=array('admin');
    54. 

  54.     $g['procStat']=array('ro', 'rw', 'rwv', 'admin');
    55. 

  55.     $g['simpleMap'] = array('none', 'list', 'ro', 'rw', 'rwv', 'admin');
    56. 

  56.     $g['simpleMap2'] = array('none', 'list', 'ro', 'rw', 'rwv', 'admin');
    57. 

  57.     $g['xPoiList'] = array('ro', 'rw', 'rwv', 'admin');
    58. 

  58.     $g['xDisplayMarker'] = array('none', 'ro', 'rw', 'rwv', 'admin');
    59. 

  59.     if(isset($g[$function])) {
    60. 

  60.       if(!empty($group)) return in_array($group, $g[$function]);
    61. 

  61.       return $g[$function];
    62. 

  62.     }
    63. 

  63.     return parent::secGroups($function,$group);
    64. 

  64.   }
    65. 

  65.   // paramètres pour une carte simple
    66. 

  66.   //
    67. 

  67.   function simpleMap($ar){
    68. 

  68.     $p = new XParam($ar, array());
    69. 

  69.     $tpl = $p->get('tplentry');
    70. 

  70.     $nocache = $p->get('nocache');
    71. 

  71.     if (isset($nocache)){
    72. 

  72.       $nocache = '&nocache='.$nocache;
    73. 

  73.     }
    74. 

  74.     $layeroid = $p->get('layeroid'); // peut être un tableau ?
    75. 

  75.     
    76. 

  76.     if (!is_array($layeroid)){
    77. 

  77.       $layeroid = array($layeroid);
    78. 

  78.     }
    79. 

  79.     $jslayeroid = '[';
    80. 

  80.     $sep = '';
    81. 

  81.     foreach($layeroid as $il=>$oidl){
    82. 

  82.       $jslayeroid .= $sep.'\''.$oidl.'\'';
    83. 

  83.       if ($sep == '')
    84. 

  84. 	$sep = ',';
    85. 

  85.     }
    86. 

  86.     $jslayeroid .= ']';
    87. 

  87.     $modmap = $this->xset->rdisplay($layeroid[0]);
    88. 

  88.     $jsstyles = '';
    89. 

  89.     if ($loadstyles){
    90. 

  90.       $styles = array();
    91. 

  91.       if (isset($modmap['oricon1']->raw)){
    92. 

  92. 	$styles[$modmap['oid']] = array('icon'=>array('size'=>$modmap['oricon1']->getImageSize('fullwidth').'X'.$modmap['oricon1']->getImageSize('fullheight'),
    93. 

  93. 						      'url'=>$fullself.$modmap['oricon1']->url.'?foo=.png')
    94. 

  94. 					);
    95. 

  95. 	if ($modmap['orshad1']->html){
    96. 

  96. 	  $styles[$modmap['oid']]['shadow'] = array('size'=>$modmap['orshad1']->getImageSize('fullwidth').'X'.$modmap['orshad1']->getImageSize('fullheight'),
    97. 

  97. 						    'url'=>$fullself.$modmap['orshad1']->url.'?foo=.png');
    98. 

  98. 	}
    99. 

  99.       }
    100. 

  100.       for($is=1; $is < count($layeroid); $is++){
    101. 

  101. 	$modmapi = $this->xset->rdisplay($layeroid[$is]);
    102. 

  102. 	if (isset($modmapi['oricon1']->raw)){
    103. 

  103. 	  $styles[$modmapi['oid']] = array('icon'=>array('size'=>$modmapi['oricon1']->getImageSize('fullwidth').'X'.$modmapi['oricon1']->getImageSize('fullheight'),
    104. 

  104. 							 'url'=>$fullself.$modmapi['oricon1']->url.'?foo=.png')
    105. 

  105. 					   );
    106. 

  106. 	  if ($modmapi['orshad1']->html){
    107. 

  107. 	    $styles[$modmapi['oid']]['shadow'] = array('size'=>$modmapi['orshad1']->getImageSize('fullwidth').'X'.$modmapi['orshad1']->getImageSize('fullheight'),
    108. 

  108. 						       'url'=>$fullself.$modmapi['orshad']->url.'?foo=.png');
    109. 

  109. 	  }
    110. 

  110. 	}
    111. 

  111.       }
    112. 

  112.       $jsstyles .="styles:["; $sep = '';
    113. 

  113.       foreach($styles as $sid=>$style){
    114. 

  114. 	$jsstyles .= "\n{$sep}{id:'{$sid}', icon:{url:'{$style['icon']['url']}', size:'{$style['icon']['size']}'}";
    115. 

  115. 	$sep = ',';
    116. 

  116. 	if (isset($style['shadow'])){
    117. 

  117. 	  $jsstyles .= ", shadow:{url:'{$style['shadow']['url']}', size:'{$style['shadow']['size']}'}";
    118. 

  118. 	}
    119. 

  119. 	$jsstyles .= "}";
    120. 

  120.       }
    121. 

  121.       $jsstyles .="],";
    122. 

  122.     }
    123. 

  123.     list($initialLat, $initialLng) = explode(';', $modmap['oelatlng']->raw);
    124. 

  124.     $initialZoom = $modmap['oezoom']->raw;
    125. 

  125.     if (empty($modmap['orcicon']->url)){
    126. 

  126.       $clusterIco =  TZR_SHARE_URL.'xmodmap/cluster.png';
    127. 

  127.       $clusterIcoShadow =  TZR_SHARE_URL.'xmodmap/cluster_shadow.png';
    128. 

  128.       $clusterIcoSize = 'width : 30, height : 51';
    129. 

  129.     } else {
    130. 

  130.       $clusterIco = $modmap['orcicon']->url.'?foo=.png';
    131. 

  131.       $clusterIcoSize = "width : {$modmap['orcicon']->getImageSize('fullwidth')}, height : {$modmap['orcicon']->getImageSize('fullheight')}";
    132. 

  132.       if (!empty($modmap['orshad']->url)){
    133. 

  133. 	$clusterIcoShadow =  $modmap['orshad']->url;
    134. 

  134.       }else{
    135. 

  135. 	$clusterIcoShadow =  '';
    136. 

  136.       }
    137. 

  137.     }
    138. 

  138.     $glang = $this->getGLang();
    139. 

  139.     $fullself = $GLOBALS['TZR_SESSION_MANAGER']::complete_self(true, true);
    140. 

  140.     $kmlurl = "{$fullself}&moid={$this->_moid}&function=simpleLayerKML{$nocache}&kml=0&_silent=1";
    141. 

  141.     $js = '<script src="http://maps.google.com/maps?file=api&amp;v=2&amp;hl='.$glang.'&amp;oe=utf-8&amp;key='.$this->key.'" language="javascript" type="text/javascript"></script>';
    142. 

  142.     $js .= '<script src="/tzr/templates/xmodmap/Clusterer2.js" type="text/javascript"></script>';
    143. 

  143.     $js .= '<script src="/tzr/templates/xmodmap/mapmanager.js" type="text/javascript"></script>';
    144. 

  144.     $js .= "<script type=\"text/javascript\">
    145. 

  145.          mapmngt.setOptions({defaultlayeroid:'{$layeroid[0]}',layeroids:{$jslayeroid},
    146. 

  146.                initialLat:{$initialLat},
    147. 

  147.                initialLng:{$initialLng},
    148. 

  148.                initialZoom:{$initialZoom},
    149. 

  149.                gridSize:20,
    150. 

  150. 	       kmlurl:'{$kmlurl}',
    151. 

  151. 	       clusterIco:{url:'{$clusterIco}', {$clusterIcoSize}},
    152. 

  152.                clusterIcoShadow:{url:'{$clusterIcoShadow}',width:56, height:51}
    153. 

  153.                });
    154. 

  154.          </script>";
    155. 

    156. 

  156.     $res = array('js'=>$js,
    157. 

  157. 		 'key'=>$this->key,
    158. 

  158. 		 'kmlurl'=>$kmlurl,
    159. 

  159. 		 'onload'=>'pageLoad()',
    160. 

  160. 		 'onunload'=>'GUnload()');
    161. 

  161.     return XShell::toScreen1($tpl, $res);
    162. 

  162.   }
    163. 

  163.   // paramètres pour une carte simple
    164. 

  164.   //
    165. 

  165.   function simpleMap2($ar){
    166. 

  166.     $p = new XParam($ar, array('loadstyles'=>0));
    167. 

  167.     $tpl = $p->get('tplentry');
    168. 

  168.     $nocache = $p->get('nocache');
    169. 

  169.     $loadstyles = $p->get('loadstyles');
    170. 

  170.     if (isset($nocache)){
    171. 

  171.       $nocache = '&nocache='.$nocache;
    172. 

  172.     }
    173. 

  173.     $layeroid = $p->get('layeroid'); // peut être un tableau ?
    174. 

  174.     
    175. 

  175.     if (!is_array($layeroid)){
    176. 

  176.       $layeroid = array($layeroid);
    177. 

  177.     }
    178. 

  178.     $jslayeroid = '[';
    179. 

  179.     $sep = '';
    180. 

  180.     foreach($layeroid as $il=>$oidl){
    181. 

  181.       $jslayeroid .= $sep.'\''.$oidl.'\'';
    182. 

  182.       if ($sep == '')
    183. 

  183. 	$sep = ',';
    184. 

  184.     }
    185. 

  185.     $jslayeroid .= ']';
    186. 

  186.     $modmap = $this->xset->rdisplay($layeroid[0]);
    187. 

  187.     // on lit les informations de styles
    188. 

  188.     if ($loadstyles){
    189. 

  189.       $styles = array();
    190. 

  190.       if (isset($modmap['oricon1']->raw)){
    191. 

  191.         $styles[$modmap['oid']] = array('icon'=>array('size'=>$modmap['oricon1']->getImageSize('fullwidth').'X'.$modmap['oricon1']->getImageSize('fullheight'),
    192. 

  192.                                                       'url'=>$fullself.$modmap['oricon1']->url.'?foo=.png')
    193. 

  193.                                         );
    194. 

  194.         if ($modmap['orshad1']->html){
    195. 

  195.           $styles[$modmap['oid']]['shadow'] = array('size'=>$modmap['orshad1']->getImageSize('fullwidth').'X'.$modmap['orshad1']->getImageSize('fullheight'),
    196. 

  196.                                                     'url'=>$fullself.$modmap['orshad1']->url.'?foo=.png');
    197. 

  197.         }
    198. 

  198.       }
    199. 

  199.       for($is=1; $is < count($layeroid); $is++){
    200. 

  200.         $modmapi = $this->xset->rdisplay($layeroid[$is]);
    201. 

  201.         if (isset($modmapi['oricon1']->raw)){
    202. 

  202.           $styles[$modmapi['oid']] = array('icon'=>array('size'=>$modmapi['oricon1']->getImageSize('fullwidth').'X'.$modmapi['oricon1']->getImageSize('fullheight'),
    203. 

  203.                                                          'url'=>$fullself.$modmapi['oricon1']->url.'?foo=.png')
    204. 

  204.                                            );
    205. 

  205.           if ($modmapi['orshad1']->html){
    206. 

  206.             $styles[$modmapi['oid']]['shadow'] = array('size'=>$modmapi['orshad1']->getImageSize('fullwidth').'X'.$modmapi['orshad1']->getImageSize('fullheight'),
    207. 

  207.                                                        'url'=>$fullself.$modmapi['orshad']->url.'?foo=.png');
    208. 

  208.           }
    209. 

  209.         }
    210. 

  210.       }
    211. 

  211.       $jsstyles .="styles:["; $sep = '';
    212. 

  212.       foreach($styles as $sid=>$style){
    213. 

  213.         $jsstyles .= "\n{$sep}{id:'{$sid}', icon:{url:'{$style['icon']['url']}', size:'{$style['icon']['size']}'}";
    214. 

  214.         $sep = ',';
    215. 

  215.         if (isset($style['shadow'])){
    216. 

  216.           $jsstyles .= ", shadow:{url:'{$style['shadow']['url']}', size:'{$style['shadow']['size']}'}";
    217. 

  217.         }
    218. 

  218.         $jsstyles .= "}";
    219. 

  219.       }
    220. 

  220.       $jsstyles .="],"; 
    221. 

  221.     }
    222. 

  222.     list($initialLat, $initialLng) = explode(';', $modmap['oelatlng']->raw);
    223. 

  223.     $initialZoom = $modmap['oezoom']->raw;
    224. 

  224.     if (empty($modmap['orcicon']->url)){
    225. 

  225.       $clusterIco =  TZR_SHARE_URL.'xmodmap/cluster.png';
    226. 

  226.       $clusterIcoShadow =  TZR_SHARE_URL.'xmodmap/cluster_shadow.png';
    227. 

  227.       $clusterIcoSize = 'width : 30, height : 51';
    228. 

  228.     } else {
    229. 

  229.       $clusterIco = $modmap['orcicon']->url.'?foo=.png';
    230. 

  230.       $clusterIcoSize = "width : {$modmap['orcicon']->getImageSize('fullwidth')}, height : {$modmap['orcicon']->getImageSize('fullheight')}";
    231. 

  231.       if (!empty($modmap['orshad']->url)){
    232. 

  232. 	$clusterIcoShadow =  $modmap['orshad']->url;
    233. 

  233.       }else{
    234. 

  234. 	$clusterIcoShadow =  '';//TZR_SHARE_URL.'xmodmap/cluster_shadow.png';
    235. 

  235.       }
    236. 

  236.     }
    237. 

  237.     $glang = $this->getGLang();
    238. 

  238.     $fullself = $GLOBALS['TZR_SESSION_MANAGER']::complete_self(true, true);
    239. 

  239.     $kmlurl = "{$fullself}&moid={$this->_moid}&function=simpleLayerKML{$nocache}&kml=1";
    240. 

  240.     $layerurl = "{$fullself}&moid={$this->_moid}&function=rawLayer&_silent=1&placestemplate=xmodmap/markerlist.xml{$nocache}";
    241. 

  241.     $displayurl = "{$fullself}&moid={$this->_moid}&function=xDisplayMarker{$nocache}";
    242. 

  242.     $js = '<script src="http://maps.google.com/maps?file=api&amp;v=2&amp;hl='.$glang.'&amp;oe=utf-8&amp;key='.$this->key.'" language="javascript" type="text/javascript"></script>';
    243. 

  243.     $js .= '<script src="/tzr/templates/xmodmap/Clusterer2.js" type="text/javascript"></script>';
    244. 

  244.     $js .= '<script src="/tzr/templates/xmodmap/mapmanager2.js" type="text/javascript"></script>';
    245. 

  245.     $js .= "<script type=\"text/javascript\">
    246. 

  246.          mapmngt.setOptions(
    247. 

  247.               {defaultlayeroid:'{$layeroid[0]}',layeroids:{$jslayeroid},
    248. 

  248.               {$jsstyles}
    249. 

  249.                initialLat:{$initialLat},
    250. 

  250.                initialLng:{$initialLng},
    251. 

  251.                initialZoom:{$initialZoom},
    252. 

  252.                gridSize:20,
    253. 

  253.                infoWindowWidth:200,
    254. 

  254.                infoWindowHeight:200,
    255. 

  255.                minMarkersPerCluster:5,
    256. 

  256.                maxVisibleMarkers:1,
    257. 

  257.                defaultMaxLinesPerInfoBox:5,
    258. 

  258.                maxLinesPerInfoBox:5,
    259. 

  259.                displayurl:'{$displayurl}',
    260. 

  260. 	       kmlurl:'{$kmlurl}',
    261. 

  261.                layerurl:'{$layerurl}',
    262. 

  262.                clusterAction:'zoom', // zoom | pop
    263. 

  263. 	       clusterIco:{url:'{$clusterIco}', {$clusterIcoSize}},
    264. 

  264.                clusterIcoShadow:{url:'{$clusterIcoShadow}',width:56, height:51}
    265. 

  265.                });
    266. 

  266.          </script>";
    267. 

  267.     $res = array('js'=>$js,
    268. 

  268. 		 'key'=>$this->key,
    269. 

  269. 		 'kmlurl'=>$kmlurl,
    270. 

  270. 		 'onload'=>'pageLoad()',
    271. 

  271. 		 'onunload'=>'GUnload()');
    272. 

  272.     return XShell::toScreen1($tpl, $res);
    273. 

  273.   }
    274. 

  274.   // lecture d'un point d'une carte
    275. 

  275.   //
    276. 

  276.   function xDisplayMarker($ar){
    277. 

  277.     $p = new XParam($ar, array('tplentry'=>'br', 'markertemplate'=>'xmodmap/displaymarker.xml'));;
    278. 

  278.     $layeroid = $p->get('layeroid');
    279. 

  279.     $oid = $p->get('oid');
    280. 

  280.     $template = $p->get('markertemplate');
    281. 

  281.     $tpl = $p->get('tplentry');
    282. 

  282.     $modmap = $this->xset->rdisplay($layeroid);
    283. 

  283.     if (!is_array($modmap)){
    284. 

  284.       XLogs::critical(get_class($this), get_class($this)."::simpleLayerKML layer not found {$layeroid}");
    285. 

  285.       die('Could not find layeroid '.$layeroid);
    286. 

  286.     }
    287. 

  287.     $mod = XModule::objectFactory($modmap['ormoid']->raw);
    288. 

  288.     if (!empty($modmap['orfilter']->raw)){
    289. 

  289.       $select = $mod->xset->select_query().' and '.$modmap['orfilter']->raw;
    290. 

  290.     } else {
    291. 

  291.       $select = $mod->xset->select_query();
    292. 

  292.     }
    293. 

  293.     if (!is_array($oid)){
    294. 

  294.       $select .= ' and '.$mod->table.'.KOID = \''.$oid.'\'';
    295. 

  295.     }  else {
    296. 

  296.       foreach($oid as $foo=>&$aoid){
    297. 

  297. 	$aoid = '\''.$aoid.'\'';
    298. 

  298.       }
    299. 

  299.       $select .= ' and '.$mod->table.'.KOID in (' . implode(",", $oid) . ')';
    300. 

  300.     }
    301. 

  301. 

  302.     $br = $mod->browse(array('_options'=>array(),
    303. 

  303. 			     'tplentry'=>TZR_RETURN_DATA,
    304. 

  304. 			     'selectedfields'=>'all',
    305. 

  305. 			     'first'=>0,
    306. 

  306. 			     'select'=>$select,
    307. 

  307. 			     'pagesize'=>9999));
    308. 

  308.     $places = array();
    309. 

  309.     $fname = $modmap['ofname']->raw;
    310. 

  310.     foreach($br['lines_oid'] as $i=>$lineoid){
    311. 

  311.       $coords = $br['lines_o'.$fname][$i]->raw;
    312. 

  312.       list($lat, $lng, $type, $acc, $upd) = explode(';', $coords);
    313. 

  313.       $aplace = $this->getPlace($i, $mod, $br, $modmap);
    314. 

  314.       if (!empty($lat) && !empty($lng)){
    315. 

  315. 	$aplace['valid'] = true;
    316. 

  316.       } else {
    317. 

  317. 	$aplace['valid'] = false;
    318. 

  318.       }
    319. 

  319.       $places[] = array('oid'=>$lineoid,
    320. 

  320. 			'latlng'=>$lng.','.$lat,
    321. 

  321. 			'name'=>$aplace['name'],
    322. 

  322. 			'valid'=>$aplace['valid'],
    323. 

  323. 			'description'=>$aplace['descr']);
    324. 

  324.       unset($aplace);
    325. 

  325.     }
    326. 

  326.     $ret = array('places'=>$places,
    327. 

  327. 		 'browse'=>$br,
    328. 

  328. 		 'modmap'=>$modmap);
    329. 

  329.     $xt = new XTemplate('file://'.TZR_SHARE_DIR.$template);
    330. 

  330.     if (file_exists(TZR_SHARE_DIR.$template)){
    331. 

  331.       $xt = new XTemplate('file://'.TZR_SHARE_DIR.$template);
    332. 

  332.     } else if (file_exists($GLOBALS['TEMPLATES_DIR'].$template)){
    333. 

  333.       $xt = new XTemplate('file://'.$GLOBALS['TEMPLATES_DIR'].$template);
    334. 

  334.     } else {
    335. 

  335.       echo('-');
    336. 

  336.       exit(0);
    337. 

  337.     }
    338. 

  338.     $labels=&$GLOBALS['XSHELL']->labels->get_labels(array('selectors'=>array('global'),'local'=>true));
    339. 

  339.     $xt->set_glob(array('labels'=>&$labels));
    340. 

  340.     $r3=array();
    341. 

  341.     // avoir vide ...    die($tpl);
    342. 

  342.     $tpldata['br']=$ret;
    343. 

  343.     $content=$xt->parse($tpldata,$r3,NULL);
    344. 

  344.     header('Content-type: text/xml');
    345. 

  345.     header('Content-disposition: inline');
    346. 

  346.     echo($content);
    347. 

  347.     exit(0);          
    348. 

  348.   }
    349. 

  349.   // initialisation des propriétés
    350. 

  350.   // -> ! table est _MODMAP
    351. 

  351.   //
    352. 

  352.   public function initOptions() {
    353. 

  353.     parent::initOptions();
    354. 

  354.     $alabel = XLabels::getSysLabel('xmodmap.modulename');
    355. 

  355.     $this->_options->setOpt(XLabels::getSysLabel('xmodmap','key'), 'key', 'text',             NULL,NULL,$alabel);
    356. 

  356.     $this->_options->setOpt(XLabels::getSysLabel('xmodmap','geocodeurl'), 'geocodeurl', 'text',     NULL,NULL,$alabel);
    357. 

  357.   }
    358. 

  358.   protected function _actionlist(&$my) {
    359. 

  359.     parent::_actionlist($my);
    360. 

  360.     $myclass=get_class($this);
    361. 

  361.     $moid=$this->_moid;
    362. 

  362.     $myoid=@$_REQUEST['oid'];
    363. 

  363.     $user = &XUser::get_user();
    364. 

  364.     if (XShell::_function() == 'edit' || XShell::_function() == 'display'){
    365. 

  365.       $o1=new XModuleAction($this,'procStat', XLabels::getSysLabel('xmodmap','statistics'),
    366. 

  366. 			    'class='.$myclass.'&amp;moid='.$moid.'&_function=procStat&template=xmodmap/statistics.html&tplentry=br&oid='.$myoid);
    367. 

  367.       $o1->homepageable=$o1->quicklinkable=$o1->menuable=true;
    368. 

  368.       $o1->group='edit';
    369. 

  369.       $my['procstats']=$o1;
    370. 

  370.     }
    371. 

  371.     if (XShell::_function() == 'procStat'){
    372. 

  372.       $br=&XShell::from_screen('br');
    373. 

  373.       $o1=new XModuleAction($this,'display',XLabels::getSysLabel('general','display','text'),
    374. 

  374. 			    'class='.$myclass.'&amp;moid='.$moid.
    375. 

  375. 			    '&_function=display&template=xmodtable/view.html&tplentry=br&oid='.$myoid);
    376. 

  376.       $o1->homepageable=$o1->quicklinkable=$o1->menuable=true;
    377. 

  377.       $o1->setToolbar('general','display');
    378. 

  378.       $my['display'] = $o1;
    379. 

  379.     }
    380. 

  380.     if (defined('TZR_GDAL_PATH') && file_exists(TZR_GDAL_PATH.'gdaltransform')){
    381. 

  381.       $o1=new XModuleAction($this,'convertCoords', 'Convertions',
    382. 

  382. 			    'class='.$myclass.'&amp;moid='.$moid.'&_function=preConvertCoords&template=xmodmap/convert.html&tplentry=br');
    383. 

  383.       $o1->homepageable=$o1->quicklinkable=$o1->menuable=true;
    384. 

  384.       $o1->group='more';
    385. 

  385.       $my['convert']=$o1;
    386. 

  386.     }
    387. 

  387.   }
    388. 

  388.   // liste de points selon certains critères
    389. 

  389.   //
    390. 

  390.   function xPoiList($ar){
    391. 

  391.     $p = new XParam($ar, array());
    392. 

  392.     XLogs::notice(get_class($this), get_class($this)."::xPoiList");
    393. 

  393.     $layeroid = $p->get('layeroid');
    394. 

  394.     $query = $p->get('query');
    395. 

  395.     $value = $p->get('value');
    396. 

  396.     $modmap = $this->xset->rdisplay($layeroid);
    397. 

  397.     $mod = XModule::objectFactory($modmap['ormoid']->raw);
    398. 

  398.     switch($query){
    399. 

  399.     case 'manual':
    400. 

  400.       $select = $mod->xset->select_query(array('cond'=>array($modmap['ofname']->raw=>array('like', '%;%;M;%;%'))));
    401. 

  401.       $select2 = str_replace($mod->xset->table.'.*', $mod->xset->table.'.KOID ', $select);
    402. 

  402.       break;
    403. 

  403.     case 'auto':
    404. 

  404.       $select = $mod->xset->select_query(array('cond'=>array($modmap['ofname']->raw=>array('like', '%;%;A;%;%'))));
    405. 

  405.       $select2 = str_replace($mod->xset->table.'.*', $mod->xset->table.'.KOID ', $select);
    406. 

  406.       break;
    407. 

  407.     case 'accuracy':
    408. 

  408.       $select = $mod->xset->select_query(array('cond'=>array($modmap['ofname']->raw=>array('like', '%;%;A;'.$value.';%'))));
    409. 

  409.       $select2 = str_replace($mod->xset->table.'.*', $mod->xset->table.'.KOID ', $select);
    410. 

  410.       break;
    411. 

  411.       break;
    412. 

  412.     }
    413. 

  413.     if (!empty($modmap['orfilter']->raw)){
    414. 

  414.       $select2 .= ' and '.$modmap['orfilter']->raw;
    415. 

  415.     }
    416. 

  416.     XLogs::notice(get_class($this), get_class($this)."::xPoiList $select2");
    417. 

  417.     $rs = selectQuery($select2);
    418. 

  418.     $ret = array();
    419. 

  419.     while($ors = $rs->fetch()){
    420. 

  420.       $ret[] = $ors['KOID'];
    421. 

  421.     }
    422. 

  422.     die(json_encode($ret));
    423. 

  423.   }
    424. 

  424.   // statistiques sur le geocodage
    425. 

  425.   //
    426. 

  426.   function procStat($ar){
    427. 

  427.     $p = new XParam($ar, array());
    428. 

  428.     $tpl = $p->get('tplentry');
    429. 

  429.     $layeroid = $p->get('oid');
    430. 

  430.     $stats = array('total'=>0, 'empty'=>0, 'types'=>array('A'=>0, 'M'=>0), 'accuracy'=>array());
    431. 

  431.     $modmap = $this->xset->rdisplay($layeroid);
    432. 

  432.     // total
    433. 

  433.     if (empty($modmap['ormoid']->raw)){
    434. 

  434.       $xset = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$modmap['oftable']->raw);
    435. 

  435.       $select = $xset->select_query();
    436. 

  436.     } else {
    437. 

  437.       $mod = XModule::objectFactory($modmap['ormoid']->raw);
    438. 

  438.       $xset = $mod->xset;
    439. 

  439.       if (!empty($modmap['orfilter']->raw)){
    440. 

  440. 	$select = $mod->xset->select_query().' and '.$modmap['orfilter']->raw;
    441. 

  441.       } else {
    442. 

  442. 	$select = $mod->xset->select_query();
    443. 

  443.       }
    444. 

  444.     }
    445. 

  445.     $select2 = str_replace($xset->getTable().'.*', 'ifnull(count(*), 0) as count', $select);
    446. 

  446.     $rs = selectQuery($select2);
    447. 

  447.     $ors = $rs->fetch();
    448. 

  448.     $stats['total'] = $ors['count'];
    449. 

  449.     $accuraciesLevels = XLabels::getSysLabel('xmodmap', 'accuracieslevels');
    450. 

  450.     foreach($accuraciesLevels as $ac=>$al){
    451. 

  451.       $stats['accuracy'][$ac] = array('label'=>$al, 'count'=>0);
    452. 

  452.     }
    453. 

  453.     // par type, accuracy, un peu brutal ...
    454. 

  454.     $fname = $modmap['ofname']->raw;
    455. 

  455.     $select2 = str_replace($xset->getTable().'.*', $xset->getTable().'.'.$fname.' as rawcoords', $select);
    456. 

  456.     $rs = selectQuery($select2);
    457. 

  457.     while($rs && $ors=$rs->fetch()){
    458. 

  458.       if (empty($ors['rawcoords'])){
    459. 

  459. 	$stats['empty']+=1;
    460. 

  460.       } else {
    461. 

  461. 	list($lat, $lng, $type, $accuracy, $upd) = XGeodesicCoordinatesDef::explode($ors['rawcoords']);
    462. 

  462. 	if (empty($lat) || empty($lng)){
    463. 

  463. 	  $stats['empty']+=1;
    464. 

  464. 	} 
    465. 

  465. 	if ($type == 'M'){
    466. 

  466. 	  $stats['types']['M']+=1;
    467. 

  467. 	} else {
    468. 

  468. 	  if (empty($accuracy)){
    469. 

  469. 	    $accuracy = 'N/A';
    470. 

  470. 	  }
    471. 

  471. 	  $stats['types']['A']+=1;
    472. 

  472. 	  if (!isset($stats['accuracy'][$accuracy])){
    473. 

  473. 	      $stats['accuracy'][$accuracy] = array('label'=>$this->accuracyLabel($accuracy), 'count'=>0);
    474. 

  474. 	  }
    475. 

  475. 	  $stats['accuracy'][$accuracy]['count']+=1;
    476. 

  476. 	}
    477. 

  477.       }
    478. 

  478.     }
    479. 

  479.     // fin pour le moment
    480. 

  480.     $res = array();
    481. 

  481.     $res['modmap'] = $modmap;
    482. 

  482.     $res['statistics'] = $stats; 
    483. 

  483.     XShell::toScreen1($tpl, $res);
    484. 

  484.   }
    485. 

  485.   // generation d'une couche en KML
    486. 

  486.   // -> icone des marker de la couche
    487. 

  487.   // -> champ titre de la couche
    488. 

  488.   // -> champs de description 
    489. 

  489.   //
    490. 

  490.   function simpleLayerKML($ar){
    491. 

  491.     $p = new XParam($ar, array('tplentry'=>'br', 'kml'=>0));
    492. 

  492.     $tpl = $p->get('tplentry');
    493. 

  493.     $layeroid = $p->get('layeroid');
    494. 

  494.     $template = $p->get('template');
    495. 

  495.     $kml = $p->get('kml');
    496. 

  496.     // lecture de la description de la carte
    497. 

  497.     $modmap = $this->xset->rdisplay($layeroid);
    498. 

  498.     if (!is_array($modmap)){
    499. 

  499.       XLogs::critical(get_class($this), get_class($this)."::simpleLayerKML layer not found {$layeroid}");
    500. 

  500.       return array('Could not find layeroid '.$layeroid);
    501. 

  501.     }
    502. 

  502.     // browse sur le module associé avec la clause where specifiée
    503. 

  503.     //
    504. 

  504.     $mod = XModule::objectFactory($modmap['ormoid']->raw);
    505. 

  505.     if (!empty($modmap['orfilter']->raw)){
    506. 

  506.       $select = $mod->xset->select_query().' and '.$modmap['orfilter']->raw;
    507. 

  507.     } else {
    508. 

  508.       $select = '';
    509. 

  509.     }
    510. 

  510.     $br = $mod->browse(array('_options'=>array(),
    511. 

  511. 			     'tplentry'=>TZR_RETURN_DATA,
    512. 

  512. 			     'selectedfields'=>'all',
    513. 

  513. 			     'first'=>0,
    514. 

  514. 			     'select'=>$select,
    515. 

  515. 			     'pagesize'=>9999));
    516. 

  516.     $places = array();
    517. 

  517.     $fname = $modmap['ofname']->raw;
    518. 

  518.     foreach($br['lines_oid'] as $i=>$lineoid){
    519. 

  519.       $coords = $br['lines_o'.$fname][$i]->raw;
    520. 

  520.       list($lat, $lng, $type, $acc, $upd) = explode(';', $coords);
    521. 

  521.       $aplace = $this->getPlace($i, $mod, $br, $modmap);
    522. 

  522.       if (!empty($lat) && !empty($lng)){
    523. 

  523. 	$aplace['valid'] = true;
    524. 

  524.       } else {
    525. 

  525. 	$aplace['valid'] = false;
    526. 

  526.       }
    527. 

  527.       $places[] = array('oid'=>$lineoid,
    528. 

  528. 			'latlng'=>$lng.','.$lat,
    529. 

  529. 			'name'=>$aplace['name'],
    530. 

  530. 			'valid'=>$aplace['valid'],
    531. 

  531. 			'description'=>$aplace['descr']);
    532. 

  532.       unset($aplace);
    533. 

  533.     }
    534. 

  534.     $ret = array('places'=>$places,
    535. 

  535. 		 'browse'=>$br,
    536. 

  536. 		 'modmap'=>$modmap);
    537. 

  537.     if (!empty($kml)){
    538. 

  538.       $xt = new XTemplate('file://'.TZR_SHARE_DIR.'xmodmap/simplekml.xml');
    539. 

  539.       $r3=array();
    540. 

  540.       $tpldata['br']=$ret;
    541. 

  541.       $content=$xt->parse($tpldata,$r3,NULL);
    542. 

  542.       $filename = cleanFileName($modmap['name'].'.kml');
    543. 

  543.       header('Content-Name: '.$filename);
    544. 

  544.       header('Content-type: application/vnd.google-earth.kml+xml');
    545. 

  545.       header('Content-disposition: attachment; filename='.$filename);
    546. 

  546.       echo($content);
    547. 

  547.       exit(0);      
    548. 

  548.     } else if ($tpl == TZR_RETURN_DATA){
    549. 

  549.       return $ret;
    550. 

  550.     } else if (empty($template)){
    551. 

  551.       // on genere le kml avec xmodmap/simplelayerkml.xml
    552. 

  552.       $xt = new XTemplate('file://'.TZR_SHARE_DIR.'xmodmap/simplelayerkml.xml');
    553. 

  553.       $r3=array();
    554. 

  554.       $tpldata['br']=$ret;
    555. 

  555.       $content=$xt->parse($tpldata,$r3,NULL);
    556. 

  556.       header('Content-type: text/xml');
    557. 

  557.       header('Content-disposition: inline');
    558. 

  558.       echo($content);
    559. 

  559.       exit(0);      
    560. 

  560.     } else {
    561. 

  561.       XShell::toScreen1('br', $ret);
    562. 

  562.     }
    563. 

  563.   }
    564. 

  564.   // generation d'une couche en tzr kml
    565. 

  565.   // -> icone des marker de la couche
    566. 

  566.   // -> champ titre de la couche
    567. 

  567.   // -> options
    568. 

  568.   //
    569. 

  569.   function rawLayer($ar){
    570. 

  570.     $p = new XParam($ar, array('tplentry'=>'br'));
    571. 

  571.     $tpl = $p->get('tplentry');
    572. 

  572.     $layeroid = $p->get('layeroid');
    573. 

  573.     $placestemplate = $p->get('placestemplate');
    574. 

  574.     // lecture de la description de la carte
    575. 

  575.     $modmap = $this->xset->rdisplay($layeroid);
    576. 

  576.     if (!is_array($modmap)){
    577. 

  577.       XLogs::critical(get_class($this), get_class($this)."::simpleLayerKML layer not found {$layeroid}");
    578. 

  578.       return  array(
    579. 

  579. 		    'places'=>NULL,
    580. 

  580. 		    'modmap'=>NULL
    581. 

  581. 		    );
    582. 

  582.     }
    583. 

  583.     // select sur le module associé avec la clause where specifiée
    584. 

  584.     //
    585. 

  585.     if (empty($modmap['ormoid']->raw)){
    586. 

  586.       XLogs::critical(get_class($this), '::rawLayer empty display module, layeroid : '.$layeroid);
    587. 

  587.       return  array(
    588. 

  588. 		    'places'=>NULL,
    589. 

  589. 		    'modmap'=>NULL
    590. 

  590. 		    );
    591. 

  591.     }
    592. 

  592.     $mod = XModule::objectFactory($modmap['ormoid']->raw);
    593. 

  593.     if (!empty($modmap['orfilter']->raw)){
    594. 

  594.       $select = $mod->xset->select_query().' and '.$modmap['orfilter']->raw;
    595. 

  595.     } else {
    596. 

  596.       $select = $mod->xset->select_query();
    597. 

  597.     }
    598. 

  598.     $places = array();
    599. 

  599.     $fname = $modmap['ofname']->raw;
    600. 

  600.     $ftitle = $modmap['ortitlef']->raw;
    601. 

  601.     $lrs = selectQuery($select);
    602. 

  602.     $i = 0;
    603. 

  603.     while($lrs && $lors = $lrs->fetch()){
    604. 

  604.       $coords = $lors[$fname];
    605. 

  605.       list($lat, $lng, $type, $acc, $upd) = explode(';', $coords);
    606. 

  606.       if (!empty($lat) && !empty($lng)){
    607. 

  607. 	$valid = true;
    608. 

  608.       } else {
    609. 

  609. 	$valid = false;
    610. 

  610.       }
    611. 

  611.       $places[] = array('oid'=>$lors['KOID'],
    612. 

  612. 			'latlng'=>$lng.','.$lat,
    613. 

  613. 			'name'=>$lors[$ftitle],
    614. 

  614. 			'valid'=>$valid,
    615. 

  615. 			'ors'=>$lors
    616. 

  616. 			);
    617. 

  617.       unset($lors);
    618. 

  618.     }
    619. 

  619.     $ret = array(
    620. 

  620. 		 'places'=>$places,
    621. 

  621. 		 'modmap'=>$modmap
    622. 

  622. 		 );
    623. 

  623.     if (!empty($placestemplate)){
    624. 

  624.       // on genere le kml avec xmodmap/simplelayerkml.xml
    625. 

  625.       $xt = new XTemplate('file://'.TZR_SHARE_DIR.$placestemplate);
    626. 

  626.       $r3=array();
    627. 

  627.       $tpldata['br']=$ret;
    628. 

  628.       $content=$xt->parse($tpldata,$r3,NULL);
    629. 

  629.       header('Content-type: text/xml');
    630. 

  630.       header('Content-disposition: inline');
    631. 

  631.       echo($content);
    632. 

  632.       exit(0);      
    633. 

  633.     } else if ($tpl == TZR_RETURN_DATA){
    634. 

  634.       return $ret;
    635. 

  635.     } else {
    636. 

  636.       // on genere le kml avec xmodmap/simplelayerkml.xml
    637. 

  637.       $xt = new XTemplate('file://'.TZR_SHARE_DIR.'xmodmap/simplelayerkml.xml');
    638. 

  638.       $r3=array();
    639. 

  639.       $tpldata['br']=$ret;
    640. 

  640.       $content=$xt->parse($tpldata,$r3,NULL);
    641. 

  641.       header('Content-type: text/xml');
    642. 

  642.       header('Content-disposition: inline');
    643. 

  643.       echo($content);
    644. 

  644.       exit(0);      
    645. 

  645.     }
    646. 

  646.   }
    647. 

  647.   // retourne le nom et la description d'un point
    648. 

  648.   // -> par defaut
    649. 

  649.   //
    650. 

  650.   protected function &getPlace($i, &$mod, &$br, &$modmap){
    651. 

  651.     // titre 
    652. 

  652.     $title = $br['lines_o'.$modmap['ortitlef']->raw][$i]->html;
    653. 

  653.     $desc = '';
    654. 

  654.     $df = explode(' ', $modmap['ordescrf']->raw);
    655. 

  655.     $iurl = $GLOBALS['TZR_SESSION_MANAGER']::makeDomainName();
    656. 

  656.     foreach($df as $foo=>$fn){
    657. 

  657.       
    658. 

  658.       $o = $br['lines_o'.$fn][$i];
    659. 

  659.       $v = trim($o->html);
    660. 

  660.       if (!empty($v)){
    661. 

  661. 	if ($o->fielddef->ftype == 'XImageDef'){
    662. 

  662. 	  $desc .= "<br><img src='{$iurl}{$o->resizer}&geometry=X100%3E'/>";
    663. 

  663. 	}else{
    664. 

  664. 	  $desc .= $v.'<br>';
    665. 

  665. 	}
    666. 

  666.       }
    667. 

  667.     }
    668. 

  668.     // description
    669. 

  669.     return array('name'=>$title,
    670. 

  670. 		 'descr'=>$desc
    671. 

  671. 		 );
    672. 

  672.   }
    673. 

  673.   //enregistrement d'une valeur
    674. 

  674.   //-> verifier les champs
    675. 

  675.   //-> mettre a jour le champ 
    676. 

  676.   //
    677. 

  677.   function procEdit($ar){
    678. 

  678.     $p = new XParam($ar, array());
    679. 

  679.     $ftable = $p->get('ftable');
    680. 

  680.     $fname = $p->get('fname');
    681. 

  681.     $fgcaddr = $p->get('fgcaddr');
    682. 

  682.     $fgccntr = $p->get('fgccntr');
    683. 

  683.     $fgctown = $p->get('fgctown');
    684. 

  684.     $fgcauto_HID = $p->get('fgcauto_HID');
    685. 

  685.     // si module, trouver la table 
    686. 

  686. 

  687.     // verifier que fname, fgcaddr (liste), fgccntr et fgctown existent bien pour la table
    688. 

  688.     // mettre a jour les informations dans le champs ftable fname (si il est du bon type)
    689. 

  689.     $xset = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$ftable);
    690. 

  690.     $fd = $xset->getField($fname);
    691. 

  691.     if ($fd->ftype != 'XGeodesicCoordinatesDef'){
    692. 

  692.       XLogs::critical(get_class($this), get_class($this)."procEdit error $fname not XGeodesic type");
    693. 

  693.       return; // message etc ...
    694. 

  694.     }
    695. 

  695.     // vérifier les champs passes
    696. 

  696. 

  697.     if (!$xset->fieldExists($fname)){
    698. 

  698.       XLogs::critical(get_class($this), get_class($this)."procEdit error $fname not exists");
    699. 

  699.       return; // message etc ...
    700. 

  700.     }
    701. 

  701.     if (isset($fgcauto_HID['val'])){
    702. 

  702.       if((!empty($fgccntr) && !$xset->fieldExists($fgccntr))||
    703. 

  703. 	 (!empty($fgctown) && !$xset->fieldExists($fgctown))){
    704. 

  704. 	XLogs::critical(get_class($this), get_class($this)."procEdit error some fields do not exists in table");
    705. 

  705. 	return; // message etc
    706. 

  706.       }
    707. 

  707.       // les champs addresse
    708. 

  708.       $fsaddr = explode(' ', $fgcaddr);
    709. 

  709.       foreach($fsaddr as $foo=>$faddr){
    710. 

  710. 	if (!empty($faddr)){
    711. 

  711. 	  if (!$xset->fieldExists($faddr)){
    712. 

  712. 	    XLogs::critical(get_class($this), get_class($this)."procEdit error ");
    713. 

  713. 	    return; // message etc ...
    714. 

  714. 	  }
    715. 

  715. 	}
    716. 

  716.       }
    717. 

  717.     }
    718. 

  718.     // procEdit
    719. 

  719.     parent::procEdit($ar);
    720. 

  720.     // mettre a jour les options du champ avec l'oid de ce module map
    721. 

  721.     $xseta=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$ftable);
    722. 

  722.     $xseta->procEditField(array('field'=>$fname, 'tplentry'=>TZR_RETURN_DATA, '_todo'=>'save', 'options'=>array('gmoid'=>$this->_moid)));
    723. 

  723.   }
    724. 

  724.   // retourne une url pour ouvrir une page de visualisation 
    725. 

  725.   //
    726. 

  726.   function getGeoViewUrl($ar){
    727. 

  727.     $p = new XParam($ar, array());
    728. 

  728.     $table = $p->get('table');
    729. 

  729.     $fieldname = $p->get('fieldname');
    730. 

  730.     $moid = $this->_moid;
    731. 

  731.     $templates = 'googlesearch.html';
    732. 

  732.     return $GLOBALS['TZR_SESSION_MANAGER']::complete_self(true, true)."skip=1&moid={$moid}&class=XModMap&table={$table}&field={$fieldname}&provider=google&function=geoSearch&template=xmodmap/geosearch.html&readonly=readonly&tplentry=br";
    733. 

  733.   }
    734. 

  734.   // retourne une url pour ouvrir une page de recherche pour ce champ
    735. 

  735.   //
    736. 

  736.   function getGeoSearchUrl($ar){
    737. 

  737.     $p = new XParam($ar, array());
    738. 

  738.     $table = $p->get('table');
    739. 

  739.     $fieldname = $p->get('fieldname');
    740. 

  740.     $moid = $this->_moid;
    741. 

  741.     $templates = 'googlesearch.html';
    742. 

  742.     return $GLOBALS['TZR_SESSION_MANAGER']::complete_self(true, true)."skip=1&&moid={$moid}&class=XModMap&table={$table}&field={$fieldname}&provider=google&function=geoSearch&template=xmodmap/geosearch.html&tplentry=br";
    743. 

  743.   }
    744. 

  744.   // recherche une entree pour cette table et ce champ
    745. 

  745.   // -> si plusieurs couches, on suppose que la fonc en edition est commune
    746. 

  746.   //
    747. 

  747.   function &getFieldSetup($ar){
    748. 

  748.     $p = new XParam($ar, array());
    749. 

  749.     $ftable = $p->get('ftable');
    750. 

  750.     $fieldname = $p->get('fname');
    751. 

  751.     $rs = selectQuery("select * from {$this->table} where fname='{$fieldname}' and ftable='{$ftable}'");
    752. 

  752.     if ($ors = $rs->fetch()){
    753. 

  753.       list ($lat, $lng) = explode(';', $ors['elatlng']);
    754. 

  754.       $ors['elat']=$lat;
    755. 

  755.       $ors['elng']=$lng;
    756. 

  756.       $ors['autogc']=($ors['fgcauto']==2)?false:true;
    757. 

  757.       $ors['layerscount'] = $rs->rowCount();
    758. 

  758.       $ors['minaccuracy'] = 4;
    759. 

  759.       return $ors;
    760. 

  760.     } else {
    761. 

  761.       // XShell print2log ....
    762. 

  762.       return array();
    763. 

  763.     }
    764. 

  764.   }
    765. 

  765.   function geoSearch($ar){
    766. 

  766.     $p = new XParam($ar, array('tplentry'=>'br'));
    767. 

  767.     $tpl = $p->get('tplentry');
    768. 

  768.     $fs = $this->getFieldSetup($ar);
    769. 

  769.     $ar['fs'] = $fs;
    770. 

  770.     // affichage des couches (?)
    771. 

  771.     $provider = $p->get('provider');
    772. 

  772.     if ($provider == 'google')
    773. 

  773.       $res = $this->googleSearch($ar);
    774. 

  774.     else 
    775. 

  775.       $res = NULL;
    776. 

  776.     $res['fs'] = $fs;
    777. 

  777.     return XShell::toScreen1($tpl, $res);
    778. 

  778.   }
    779. 

  779.   // affiche uen carte de recherche pour la table et le champ donne
    780. 

  780.   // -> google ici
    781. 

  781.   //
    782. 

  782.   function googleSearch($ar){
    783. 

  783.     $p = new XParam($ar, array('tplentry'=>'br'));
    784. 

  784.     $fs = $p->get('fs');
    785. 

  785.     $tpl = $p->get('tplentry');
    786. 

  786.     $ftable = $p->get('ftable');
    787. 

  787.     $fname = $p->get('fname');
    788. 

  788.     $fid = $p->get('fid');
    789. 

  789.     $flatlng = $p->get('flatlng');
    790. 

  790.     $flatlng = trim($flatlng);
    791. 

  791.     $foptions = $p->get('foptions');
    792. 

  792.     $readonly = $p->get('readonly');
    793. 

  793.     $oid = $p->get('oid');
    794. 

  794.     // recherche des infos table/champ dans l'EF
    795. 

  795.     //    $fs = $this->getFieldSetupEdit($ar);
    796. 

  796.     // position initiale reçue sinon defaut
    797. 

  797.     if (!empty($flatlng) && $flatlng!=';'){
    798. 

  798.       list($plat, $plng) = explode(';', $flatlng);
    799. 

  799.       $mlat = $fs['elat'];
    800. 

  800.       $mlng = $fs['elng'];
    801. 

  801.       $newpoint = false;
    802. 

  802.     } elseif (!empty($oid)) {
    803. 

  803.       /* to do editer l'occurence ? */
    804. 

  804.     } else {
    805. 

  805.       $plat = $mlat = $fs['elat'];
    806. 

  806.       $plng = $mlng = $fs['elng'];
    807. 

  807.       $newpoint = true;
    808. 

  808.     }
    809. 

  809.     // lire le champ ? ... la cle etc
    810. 

  810.     $res = array('google'=>array('key'=>$this->key),
    811. 

  811. 		 'map'=>array('zoom'=>$fs['ezoom'], 
    812. 

  812. 			      'readonly'=>$readonly,
    813. 

  813. 			      'lng'=>$mlat, 
    814. 

  814. 			      'lat'=>$mlng),
    815. 

  815. 		 'point'=>array('newpoint'=>$newpoint,
    816. 

  816. 				'lat'=>$plat,
    817. 

  817. 				'lng'=>$plng,
    818. 

  818. 				'ftable'=>$ftable,
    819. 

  819. 				'fid'=>$fid,
    820. 

  820. 				'fname'=>$fname,
    821. 

  821. 				'foptions'=>$foptions
    822. 

  822. 				),
    823. 

  823. 		 'maplabels'=>array('normalview'=>XLabels::getSysLabel('xmodmap','normalview', 'text'),
    824. 

  824. 				    'physicalview'=>XLabels::getSysLabel('xmodmap','physicalview', 'text'),
    825. 

  825. 				    'satelliteview'=>XLabels::getSysLabel('xmodmap','sattelitview', 'text'),
    826. 

  826. 				    'hybridview'=>XLabels::getSysLabel('xmodmap','hybridview', 'text'),
    827. 

  827. 				    'search'=>XLabels::getSysLabel('general', 'query', 'text'),
    828. 

  828. 				    'validate'=>XLabels::getSysLabel('general', 'save', 'text'),
    829. 

  829. 				    'quit'=>XLabels::getSysLabel('general', 'close', 'text'),
    830. 

  830. 				    'notfound'=>XLabels::getSysLabel('xmodmap', 'unknownaddress', 'text'),
    831. 

  831. 				    'centerview'=>XLabels::getSysLabel('xmodmap', 'centerview', 'text')
    832. 

  832. 				    )
    833. 

  833. 		 );
    834. 

  834.     return $res;
    835. 

  835.   }
    836. 

  836.   // deamon
    837. 

  837.   // -> faire le geocodage auto
    838. 

  838.   protected function _daemon($period='any') {
    839. 

  839.     return true;
    840. 

  840.   }  
    841. 

  841.   // traitement des geocodages automatiques
    842. 

  842.   // -> pour chaque carte, si geocodeauto, faire les recherches
    843. 

  843.   //
    844. 

  844.   function geoCodeAuto($ar){
    845. 

  845.     $p = new XParam($ar, array());
    846. 

  846.     $done = array();
    847. 

  847.     $cr ="";
    848. 

  848.     XLogs::notice(get_class($this),get_class($this)."::geoCodeAuto start");
    849. 

  849.     $rs = selectQuery("select ftable, fname, KOID from {$this->table} where fgcauto=1");
    850. 

  850.     $cr .= "{$rs->rowCount()} map(s) to scan";
    851. 

  851.     XLogs::update('geocoding', NULL, 'start '.$cr);
    852. 

  852.     while($rs && $ors = $rs->fetch()){
    853. 

  853.       if (!isset($done[$ors['ftable'].$ors['fname']])){
    854. 

  854. 	$cr = "scanning : {$ors['ftable']} {$ors['fname']}\n";
    855. 

  855. 	$done[$ors['ftable'].$ors['fname']] = array();
    856. 

  856. 	$modmap = $this->xset->rdisplay($ors['KOID']);
    857. 

  857. 	$r = $this->geoCodeXSet($modmap);
    858. 

  858. 	$cr .= "\t rows : {$r['nt']} querie(s) : {$r['nq']} omitted : {$r['nqn']}\n";
    859. 

  859. 	XLogs::update('geocoding', NULL, $cr);
    860. 

  860.       }
    861. 

  861.     }
    862. 

  862.     XLogs::notice(get_class($this),get_class($this)."::geoCodeAuto end");
    863. 

  863.     // compte rendu ?
    864. 

  864.     XLogs::update('geocoding', NULL, 'end');
    865. 

  865.   }
    866. 

  866.   // traitement de geocodage d'une table donnee
    867. 

  867.   // -> si fiche modifiee, refaire le geocodage
    868. 

  868.   //
    869. 

  869.   function geoCodeXSet($modmap){
    870. 

  870.     // Cas ou l'on passe directement un oid
    871. 

  871.     if(!is_array($modmap)) $modmap=$this->xset->rdisplay($modmap);
    872. 

  872.     $nq = 0; $nqn = 0;
    873. 

  873.     $fname = $modmap['ofname']->raw;
    874. 

  874.     $ftable = $modmap['oftable']->raw;
    875. 

  875.     XLogs::notice(get_class($this),get_class($this)."::geoCodeAutoXSet start");
    876. 

  876.     $xset = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$ftable);
    877. 

  877.     $rs = selectQuery($xset->select_query(array()));
    878. 

  878.     $tests = 0;
    879. 

  879.     $delay = 0;
    880. 

  880.     while($rs && ($ors = $rs->fetch())){
    881. 

  881.       
    882. 

  882.       $pending = true;
    883. 

  883.       
    884. 

  884.       while($pending){
    885. 

  885. 	$foo = array();
    886. 

  886. 	$ofc = $xset->getField($fname);
    887. 

  887. 	$fv = $ofc->edit($ors[$fname], $foo);
    888. 

  888. 	if($fv->type == 'A' && ($fv->accuracy == '' || $fv->accuracy == 'N/A' || empty($fv->upd) || $ors['UPD'] > $fv->upd || 
    889. 

  889. 				$modmap['oUPD']->raw > $fv->upd)){
    890. 

  890. 	  $gar = array();
    891. 

  891. 	  $addressfields = explode(' ', $modmap['ofgcaddr']->raw);
    892. 

  892. 	  foreach($addressfields as $foo=>$afn){
    893. 

  893. 	    $afv = trim($ors[$afn]);
    894. 

  894. 	    if (!empty($afv))
    895. 

  895. 	      $gar['address'][] = array('value'=>$afv, 'retry'=>true, 'default'=>NULL);
    896. 

  896. 	  }
    897. 

  897. 	  $gar['city'] = array('value'=>$ors[$modmap['ofgctown']->raw], 'retry'=>true, 'default'=>NULL);
    898. 

  898. 	  $gar['zipcode'] = array('value'=>$ors[$modmap['ofgczipc']->raw], 'retry'=>false, 'default'=>NULL);
    899. 

  899. 	  $gar['country'] = array('value'=>$ors[$modmap['ofgccntr']->raw], 'retry'=>false, 'default'=>NULL);
    900. 

  900. 	  $nq += 1;
    901. 

  901. 	  $rg = $this->googleGeoCode($gar, 0, $ors['KOID']);
    902. 

  902. 	  list ($ok, $mess, $accuracy, $coords, $maddress, $retry, $query) = $rg;
    903. 

  903. 	  XLogs::notice(get_class($this).get_class($this)."::googleGeoCode $ok $mess $retry $query");
    904. 

  904. 	  $tests += 1;
    905. 

  905. 	  if ($ok){
    906. 

  906. 	    $pending = false;
    907. 

  907. 	    $fres = array('latlng'=>$coords[1].';'.$coords[0],
    908. 

  908. 			  'autogc'=>1,
    909. 

  909. 			  'accuracy'=>$accuracy);
    910. 

  910. 	    $xset->procEdit(array('_options'=>array('local'=>true),
    911. 

  911. 				  'tplentry'=>TZR_RETURN_DATA,
    912. 

  912. 				  $fname=>$fres,
    913. 

  913. 				  'oid'=>$ors['KOID']));
    914. 

  914. 	  } else if ($mess == 'too many query'){
    915. 

  915. 	    $delay += 100000; // pending reste a true
    916. 

  916. 	    XLogs::notice(get_class($this),get_class($this)."::geoCodeAutoXSet delaying $delay $nq");
    917. 

  917. 	    XLogs::update('geocoding', NULL, "incr delaying $delay $nq");
    918. 

  918. 	  }else{
    919. 

  919. 	    $pending =false;
    920. 

  920. 	    $fres = array('latlng'=>'',
    921. 

  921. 			  'autogc'=>1,
    922. 

  922. 			  'accuracy'=>0);
    923. 

  923. 	    $xset->procEdit(array('_options'=>array('local'=>true),
    924. 

  924. 				  'tplentry'=>TZR_RETURN_DATA,
    925. 

  925. 				  $fname=>$fres,
    926. 

  926. 				  'oid'=>$ors['KOID']));
    927. 

  927. 	    
    928. 

  928. 	  }
    929. 

  929. 	} else { 
    930. 

  930. 	  XLogs::notice(get_class($this),get_class($this)."::geCodeXSet up to date ".$ors['KOID']);
    931. 

  931. 	  $nqn += 1;
    932. 

  932. 	  $pending = false;
    933. 

  933. 	  $delay = 0;
    934. 

  934. 	}
    935. 

  935. 	usleep($delay);
    936. 

  936. 	XLogs::notice('XModMap', "geoCodeXSet query $nq ommitted $nqn of {$rs->rowCount()}");
    937. 

  937.       }
    938. 

  938.     }
    939. 

  939.     XLogs::notice(get_class($this),get_class($this)."::geoCodeAutoXSet end");
    940. 

  940.     return array('nq'=>$nq, 'nqn'=>$nqn, 'nt'=>$rs->rowCount());
    941. 

  941.   }
    942. 

  942.   // requete geocodage google
    943. 

  943.   // 
    944. 

  944.   function googleGeoCode($addressFields, $retry=0, $oid=NULL /*pour trace*/){
    945. 

  945.     $q = '';
    946. 

  946.     foreach($addressFields['address'] as $foo=>$fd){
    947. 

  947.       $this->googleAppendtoQuery($fd, $q, ' ');
    948. 

  948.     }
    949. 

  949.     $otherfields = array('zipcode', 'city', 'country');
    950. 

  950.     foreach($otherfields as $foo=>$fn){
    951. 

  951.       if (!empty($addressFields[$fn])){
    952. 

  952.       $this->googleAppendtoQuery($addressFields[$fn], $q, ',');
    953. 

  953.       }
    954. 

  954.     }
    955. 

  955.     XLogs::notice(get_class($this), get_class($this)."::googleGeoCode $retry $oid start, query : $q");
    956. 

  956. 

  957.     $url = $this->geocodeurl.'key='.$this->key.'&output=kml&q='.urlencode($q);
    958. 

  958. 

  959.     $gres = file_get_contents($url, NULL);
    960. 

  960. 

  961.     if ($this->googleGeoCodeEncoding != 'UTF-8')
    962. 

  962.       $gres = utf8_encode($gres);
    963. 

  963.     
    964. 

  964.     $r = $this->decodeGoogleGeocodeXml($gres);
    965. 

  965. 

  966.     list($ok, $mess, $accuracy, $coordinates, $matchedaddress) = $r;
    967. 

  967.     if (!$ok){
    968. 

  968.       $na = count($addressFields['address']);
    969. 

  969.       if ($na >= 1 && $mess != 'too many query'){
    970. 

  970. 	array_shift($addressFields['address']);
    971. 

  971. 	return $this->googleGeocode($addressFields, $retry+1, $oid);
    972. 

  972.       }
    973. 

  973.     } else {
    974. 

  974.       array_push($r, $retry, $q);
    975. 

  975.     }
    976. 

  976.     XLogs::notice(get_class($this).get_class($this)."::googleGeoCode $retry $oid end");
    977. 

  977.     return $r;
    978. 

  978.   }
    979. 

  979. 

  980.   /// formatage d'une requete google geocodage
    981. 

  981.   function googleAppendToQuery($fd, &$q, $sep=''){
    982. 

  982.     $f = (object)$fd;
    983. 

  983.     $fv = '';
    984. 

  984.     if (empty($f->value) && !empty($f->default))
    985. 

  985.       $fv = $f->default;
    986. 

  986.     else
    987. 

  987.       $fv = $f->value;
    988. 

  988.     if (!empty($fv)){
    989. 

  989.       $fv = preg_replace('/,/', '', $fv);
    990. 

  990.       if (empty($q))
    991. 

  991. 	$q = $fv;
    992. 

  992.       else
    993. 

  993. 	$q .= $sep.$fv;
    994. 

  994.     }
    995. 

  995.   }
    996. 

  996. 

  997.   /// decode une reponse geocode xml/kml
    998. 

  998.   function decodeGoogleGeocodeXml(&$xml){
    999. 

  999.     $d = new DOMDocument();
    1000. 

  1000.     $d->loadXML($xml); // ?
    1001. 

  1001.     $xq = new DOMXPath($d);
    1002. 

  1002.     $kmlns = 'http://earth.google.com/kml/2.0';
    1003. 

  1003.     $oasins = 'urn:oasis:names:tc:ciq:xsdschema:xAL:2.0';
    1004. 

  1004.     $xq->registerNameSpace('kml', $kmlns);
    1005. 

  1005.     $xq->registerNameSpace('oasi', $oasins);
    1006. 

  1006.     $r1 = $xq->query('/kml:kml/kml:Response/kml:Status/kml:code/text()');
    1007. 

  1007.     if ($r1->length != 1){
    1008. 

  1008.       return array(false, 'unable to decode google response');
    1009. 

  1009.     }
    1010. 

  1010.     $status = $r1->item(0)->wholeText;
    1011. 

  1011.     if (isset($this->googleGeoStatus[$status])){
    1012. 

  1012.       switch($status){
    1013. 

  1013.       case 200:
    1014. 

  1014. 	// check multiples responses and accuracy
    1015. 

  1015. 	$r2 = $xq->query('/kml:kml/kml:Response/kml:Placemark');
    1016. 

  1016. 	if ($r2->length == 0){
    1017. 

  1017. 	  return array(false, 'unable to decode google response : address');
    1018. 

  1018. 	}
    1019. 

  1019. 	if ($r2->length == 1){
    1020. 

  1020. 	  $place = $r2->item(0);
    1021. 

  1021. 	  $r3 = $xq->query('oasi:AddressDetails', $place);
    1022. 

  1022. 	  $accuracy = $r3->item(0)->getAttributeNode('Accuracy')->value;
    1023. 

  1023. 	  // check accuracy ...
    1024. 

  1024. 	  if (!isset($this->googleGeoAccuracy[$accuracy])){
    1025. 

  1025. 	    return array(false, 'unknown accuracy '.$accuracy);
    1026. 

  1026. 	  }
    1027. 

  1027. 	  if ($accuracy == 0){
    1028. 

  1028. 	    return array(false, 'null accuracy ');
    1029. 

  1029. 	  }
    1030. 

  1030. 	  unset($r3);
    1031. 

  1031. 	  $r4 = $xq->query('kml:Point/kml:coordinates/text()', $place);
    1032. 

  1032. 	  if ($r4->length == 0){
    1033. 

  1033. 	    return array(false, 'unable to decode google response Point coordinates');
    1034. 

  1034. 	  }
    1035. 

  1035. 	  $raw = $r4->item(0)->wholeText;
    1036. 

  1036. 	  list($lat, $lng) = explode(',', $raw);
    1037. 

  1037. 	  unset($r4);
    1038. 

  1038. 	  // read the exact address found
    1039. 

  1039. 	  $r5 = $xq->query('kml:address/text()', $place);
    1040. 

  1040. 	  $maddress = $r5->item(0)->wholeText;
    1041. 

  1041. 	  $ret = array(true, 'exact match', $accuracy, array($lat, $lng), $maddress);
    1042. 

  1042. 	} else {
    1043. 

  1043. 	  // multiple responses
    1044. 

  1044. 	  $ret = array(false, 'multiple matches');
    1045. 

  1045. 	}
    1046. 

  1046. 	unset($r2);
    1047. 

  1047. 	return $ret;
    1048. 

  1048. 	break;
    1049. 

  1049.       case 400:
    1050. 

  1050.       case 601:
    1051. 

  1051.       return array(false, 'invalid query');
    1052. 

  1052.       break;
    1053. 

  1053.       case 602:
    1054. 

  1054.       case 603:
    1055. 

  1055. 	return array(false, 'unknow adress/unavailable address');
    1056. 

  1056. 	break;
    1057. 

  1057.       case 610:
    1058. 

  1058. 	return array(false, 'invalid key');
    1059. 

  1059. 	break;
    1060. 

  1060.       case 620:
    1061. 

  1061. 	return array(false, 'too many query');
    1062. 

  1062. 	break;
    1063. 

  1063.       default:
    1064. 

  1064. 	return array(false, 'unknow google status'.$status);
    1065. 

  1065. 	break;
    1066. 

  1066.       }
    1067. 

  1067.     }else{
    1068. 

  1068.       return array(false, 'unknown google status '.$status);
    1069. 

  1069.     }
    1070. 

  1070.   }
    1071. 

  1071.   private function accuracyLabel($accuracy){
    1072. 

  1072.     if (!isset($this->googleGeoAccuracy[$accuracy]))
    1073. 

  1073.       return '***';
    1074. 

  1074.     return $this->googleGeoAccuracy[$accuracy][1];
    1075. 

  1075.   }
    1076. 

  1076. 

  1077.   /// Retourne les bornes d'une zone autour d'un point à une distance donnee sous forme de tableau ou de requete
    1078. 

  1078.   /// form : circle => cercle de rayon $d / in => carre interieur du cercle de rayon $d / out => carre exterieur du cercle de rayon $d
    1079. 

  1079.   static function getZoneCoord($lt,$lg,$d,$form='circle',$field=NULL){
    1080. 

  1080.     if($form=='circle'){
    1081. 

  1081.       if(empty($field)) return NULL;
    1082. 

  1082.       return " where $d >= (acos(cos(radians($lt))*cos(radians($lg))*cos(radians(SUBSTRING_INDEX($field,';',1)))*cos(radians(SUBSTRING_INDEX(SUBSTRING_INDEX($field,';',2),';',-1))) + cos(radians($lt))*sin(radians($lg))*cos(radians(SUBSTRING_INDEX($field,';',1)))*sin(radians(SUBSTRING_INDEX(SUBSTRING_INDEX($field,';',2),';',-1))) + sin(radians($lt))*sin(radians(SUBSTRING_INDEX($field,';',1)))) * ".EARTHRAY.")";
    1083. 

  1083.     }
    1084. 

  1084.     if($form=='in') $d=sqrt(2*pow($d,2));
    1085. 

  1085.     $top=$lt+($d*360)/(2*pi()*EARTHRAY);
    1086. 

  1086.     $bot=$lt-($d*360)/(2*pi()*EARTHRAY);
    1087. 

  1087.     $left=$lg-($d*360)/(cos(deg2rad($lt))*2*pi()*EARTHRAY);
    1088. 

  1088.     $right=$lg+($d*360)/(cos(deg2rad($lt))*2*pi()*EARTHRAY);
    1089. 

  1089.     if(!empty($field)){
    1090. 

  1090.       return " where SUBSTRING_INDEX($field,';',1)>$bot and SUBSTRING_INDEX($field,';',1)<$top ".
    1091. 

  1091. 	"and SUBSTRING_INDEX(SUBSTRING_INDEX($field,';',2),';',-1)>$left and SUBSTRING_INDEX(SUBSTRING_INDEX($field,';',2),';',-1)<$right";
    1092. 

  1092.     }else{
    1093. 

  1093.       return array('top'=>$top,'bot'=>$bot,'left'=>$left,'right'=>$right);
    1094. 

  1094.     }
    1095. 

  1095.   }
    1096. 

  1096.   private function getGLang(){
    1097. 

  1097.     $ulang = XShell::getLangUser();
    1098. 

  1098.     if($ulang == 'FR')
    1099. 

  1099.       $glang = 'fr';
    1100. 

  1100.     else if ($ulang == 'IT')
    1101. 

  1101.       $glang = 'it';
    1102. 

  1102.     else
    1103. 

  1103.       $glang = 'en';
    1104. 

  1104.   }
    1105. 

  1105.   /**
    1106. 

  1106.    * fonction de transformations 
    1107. 

  1107.    * \param String $fromSyst : code du système d'origine
    1108. 

  1108.    * \param String $fromSyst : code du système destination
    1109. 

  1109.    * \param array $data :
    1110. 

  1110.    * - in : fichier à traiter 
    1111. 

  1111.    * - out : fichier en sortie
    1112. 

  1112.    * \note 
    1113. 

  1113.    * voir http://spatialreference.org/
    1114. 

  1114.    *'EPSG:32600' : 'UTM WGS84 North, 32601 -> zone 1, ...',
    1115. 

  1115.    *'EPSG:32700' : 'UTM WGS84 South, 32701 -> zone 1, ...',
    1116. 

  1116.    *'EPSG:4326'  : 'WGS84',
    1117. 

  1117.    *'EPSG:6171'  : 'RGF93', // à vérifier
    1118. 

  1118.    *'EPSG:2154'  : 'Lambert 93',
    1119. 

  1119.    *'EPSG:27561' : 'Lambert carto Nord',
    1120. 

  1120.    *'EPSG:27562' : 'Lambert carto Centre',
    1121. 

  1121.    *'EPSG:2154'  : 'Lambert carto Sud',
    1122. 

  1122.    *'EPSG:27564' : 'Lambert carto Corse',
    1123. 

  1123.    *'EPSG:27571' : 'Lambert zone I',
    1124. 

  1124.    *'EPSG:27572' : 'Lambert zone II',idem zone 2 etendu
    1125. 

  1125.    *'EPSG:27573' : 'Lambert zone III',
    1126. 

  1126.    *'EPSG:27574' : 'Lambert zone IV'
    1127. 

  1127.    */
    1128. 

  1128.   public static function convertFile($fromSyst, $toSyst, $in, $out){
    1129. 

  1129.     XLogs::notice(get_class(), '::convertFile : gdaltransform -s_srs '.$fromSyst.' -t_srs '.$toSyst.' < '.$in.'  > '.$out);
    1130. 

  1130.     system(TZR_GDAL_PATH.'gdaltransform -s_srs '.$fromSyst.' -t_srs '.$toSyst.' < '.$in.'  > '.$out);
    1131. 

  1131.   }
    1132. 

  1132.   /**
    1133. 

  1133.    * \note 
    1134. 

  1134.    * idem convertFile mais à partir d'un tableau de lignes x y (z)
    1135. 

  1135.    */
    1136. 

  1136.   public static function convertArray($fromSyst, $toSyst, $in){
    1137. 

  1137.     $infilename = TZR_TMP_DIR.uniqid('xmodmapconversion_in');
    1138. 

  1138.     $outfilename = TZR_TMP_DIR.uniqid('xmodmapconversion_out');
    1139. 

  1139. 

  1140.     $fp = fopen($infilename, 'w');
    1141. 

  1141.     foreach($in as $coordline){
    1142. 

  1142.       fwrite($fp, $coordline."\n");
    1143. 

  1143.     }
    1144. 

  1144.     fclose($fp);
    1145. 

  1145. 

  1146.     self::convertFile($fromSyst, $toSyst, $infilename, $outfilename);
    1147. 

  1147. 

  1148.     $res = explode("\n", trim(file_get_contents($outfilename)));
    1149. 

  1149. 

  1150.     unlink($infilename);
    1151. 

  1151.     unlink($outfilename);
    1152. 

  1152. 

  1153.     return $res;
    1154. 

  1154.   }
    1155. 

  1155.   /**
    1156. 

  1156.    * conversion d'une liste de coordonnées
    1157. 

  1157.    */
    1158. 

  1158.   function convertCoords($ar){
    1159. 

  1159.     $p = new XParam($ar, array('insrs'=>self::$defaultSRS, 'mode'=>'ajax'));
    1160. 

  1160.     $coords = $p->get('coords');
    1161. 

  1161.     $insrs = $p->get('insrs');
    1162. 

  1162.     $tosrs = $p->get('tosrs');
    1163. 

  1163.     $tpl = $p->get('tplentry');
    1164. 

  1164.     $mode = $p->get('mode');
    1165. 

  1165.     if (!is_array($coords)){
    1166. 

  1166.       $coords = array($coords);
    1167. 

  1167.     }
    1168. 

  1168.     // lecture des systèmes
    1169. 

  1169.     $fromOrs = selectQuery('select * from MAPSRS where lang="FR" and KOID = "'.$insrs.'"')->fetch();
    1170. 

  1170.     $toOrs = selectQuery('select * from MAPSRS where lang="FR" and KOID = "'.$tosrs.'"')->fetch();
    1171. 

  1171. 

  1172.     // conversion
    1173. 

  1173.     $res = self::convertArray($fromOrs['epsgcode'], $toOrs['epsgcode'], $coords);
    1174. 

  1174.     $res2 = array();
    1175. 

  1175. 

  1176.     // mise en forme
    1177. 

  1177.     foreach($res as $ares){
    1178. 

  1178.       list($x, $y) = explode(' ', $ares);
    1179. 

  1179.       if (!empty($toOrs['dformat'])){
    1180. 

  1180. 	$res2[]  = str_replace(array('%_x', '%_y'), array(sprintf('%d', $x), sprintf('%d',$y)), $toOrs['dformat']);
    1181. 

  1181.       } else {
    1182. 

  1182. 	$res2[] = $x.' '.$y;
    1183. 

  1183.       }
    1184. 

  1184.     }
    1185. 

  1185. 

  1186.     if ($mode == 'ajax'){
    1187. 

  1187.       die(json_encode($res2));
    1188. 

  1188.     }
    1189. 

  1189. 

  1190.     return XShell::toScreen1($tpl, $res2);
    1191. 

  1191.   }
    1192. 

  1192.   /**
    1193. 

  1193.    * convertions depuis l'admin
    1194. 

  1194.    */
    1195. 

  1195.   function preConvertCoords($ar){
    1196. 

  1196.     // liste des systèmes configurés
    1197. 

  1197.     $ds = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS=MAPSRS');
    1198. 

  1198.     $ds->browse(array('tplentry'=>'br1', 'pagesize'=>9999, 'order'=>'title asc'));
    1199. 

  1199.   }
    1200. 

  1200.   function procConvertCoords($ar){
    1201. 

  1201.     $p = new XParam($ar, array());
    1202. 

  1202.     $fromSrs = $p->get('insrs');
    1203. 

  1203.     $toSrs = $p->get('tosrs');
    1204. 

  1204.     $incoords = trim($p->get('incoords'));
    1205. 

  1205.     if (empty($incoords) && (!isset($_FILES['infile']['tmp_name']) || !file_exists($_FILES['infile']['tmp_name']))){
    1206. 

  1206.       XShell::setNext($GLOBALS['TZR_SESSION_MANAGER']::complete_self().'&moid='.$this->_moid.'&function=preConvertCoords&template=xmodmap/convert.html&tplentry=br');
    1207. 

  1207.       XShell::setNextData('message', '...');
    1208. 

  1208.       return;
    1209. 

  1209.     }
    1210. 

  1210.     if (!empty($incoords)){
    1211. 

  1211.       // convertion des coordonnées saisies
    1212. 

  1212.       $ar['coords'] = explode('\n', $incoords);
    1213. 

  1213.       $ar['mode'] = 'ret';
    1214. 

  1214.       $ar['tplentry'] = TZR_RETURN_DATA;
    1215. 

  1215.       $res = $this->convertCoords($ar);
    1216. 

  1216.       setSessionVar('message', '<pre>'.implode("\n", $res)."\n".implode("\n", $ar['coords']).'</pre>');
    1217. 

  1217.     } else {
    1218. 

  1218.       // lecture des systèmes
    1219. 

  1219.       $fromOrs = selectQuery('select * from MAPSRS where lang="FR" and KOID = "'.$fromSrs.'"')->fetch();
    1220. 

  1220.       $toOrs = selectQuery('select * from MAPSRS where lang="FR" and KOID = "'.$toSrs.'"')->fetch();
    1221. 

  1221.       // convertion du fichier       
    1222. 

  1222.       $outfilename = TZR_TMP_DIR.uniqid('xmodmapconversion_out');
    1223. 

  1223.       self::convertFile($fromOrs['epsgcode'], $toOrs['epsgcode'], $_FILES['infile']['tmp_name'], $outfilename);
    1224. 

  1224.       XShell::setNextFile($outfilename, 'converted_'.$_FILES['infile']['name'], 'text/csv');      
    1225. 

  1225.     }
    1226. 

  1226.     XShell::setNext($GLOBALS['TZR_SESSION_MANAGER']::complete_self().'&moid='.$this->_moid.'&function=preConvertCoords&template=xmodmap/convert.html&tplentry=br');
    1227. 

  1227.   }
    1228. 

  1228. }
    1229. 

  1229. ?>
    1230. 

  1230.