PageRenderTime 60ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 1ms

/apps/_shared/functions.inc.php

https://github.com/noveopiu/dCTL
PHP | 1931 lines | 1576 code | 131 blank | 224 comment | 256 complexity | 449c515a25cac808eadcf49d10b35a13 MD5 | raw file
Possible License(s): LGPL-2.1 
    

  1. <?php
    2. 

  2.  if (!defined('_INCLUDE')) die('"'.__FILE__.'" not executable... me, i abort.');
    3. 

  3. 

  4. /* - - - - - - - - - - - - - - - - - */
    5. 

  5. function xml_character_encode($string, $trans='') {
    6. 

  6. 	$trans = (is_array($trans)) ? $trans : get_html_translation_table(HTML_ENTITIES, ENT_QUOTES);
    7. 

  7. 	foreach ($trans as $k=>$v)
    8. 

  8. 		$trans[$k]= "&#".ord($k).";";
    9. 

  9. 	return strtr($string, $trans);
    10. 

  10. };
    11. 

  11. /* - - - - - - - - - - - - - - - - - */
    12. 

  12. function fixLabel($label) {
    13. 

  13.  return trim(addslashes(preg_replace('/'.WS.'+/', ' ',$label)));
    14. 

  14. };
    15. 

  15. /* - - - - - - - - - - - - - - - - - */
    16. 

  16. function loadXML($thePath) {
    17. 

  17.  if (is_file($thePath)) {
    18. 

  18. 		forceUTF8($thePath);
    19. 

  19.   $simplexml = simplexml_load_file($thePath, 'SimpleXMLElement', DCTL_XML_LOADER);
    20. 

  20.   $namespaces = $simplexml->getDocNamespaces();
    21. 

  21.   foreach ($namespaces as $nsk=>$ns) {
    22. 

  22.    if ($nsk == '') $nsk = 'tei';
    23. 

  23.    $simplexml->registerXPathNamespace($nsk, $ns);
    24. 

  24.   };
    25. 

  25.   $xml_resource = simplexml_load_string($simplexml->asXML()); // NO => , 'SimpleXMLElement', DCTL_XML_LOADER
    26. 

  26.   //$xml_resource = str_ireplace('xml:id','id',$xml_resource);
    27. 

  27.  } else {
    28. 

  28.   die('<div class="error">! cannot SIMPLEXML load resource: '.$thePath.'</div>');
    29. 

  29.  };
    30. 

  30.  return $xml_resource;
    31. 

  31. };
    32. 

  32. /* - - - - - - - - - - - - - - - - - */
    33. 

  33. function checkUTF8Encoding ( $string, $string_encoding ) {
    34. 

  34. 	$fs = $string_encoding == 'UTF-8' ? 'UTF-32' : $string_encoding;
    35. 

  35. 	$ts = $string_encoding == 'UTF-32' ? 'UTF-8' : $string_encoding;
    36. 

  36. 	return $string === mb_convert_encoding ( mb_convert_encoding ( $string, $fs, $ts ), $ts, $fs );
    37. 

  37. };
    38. 

  38. /* - - - - - - - - - - - - - - - - - */
    39. 

  39. function encodeToUTF8($string) {
    40. 

  40.  return mb_convert_encoding($string, "UTF-8", mb_detect_encoding($string, "UTF-8, ISO-8859-1, ISO-8859-15", true));
    41. 

  41. };
    42. 

  42. /* - - - - - - - - - - - - - - - - - */
    43. 

  43. function forceUTF8 ($fullsrc, $fPath="", $dumpIt=true) {
    44. 

  44. 	if (is_file($fullsrc)) {
    45. 

  45. 	 $fPath = $fullsrc;
    46. 

  46. 	 $content = file_get_contents($fullsrc);
    47. 

  47. 	 $src = dirname($fullsrc).SYS_PATH_SEP.basename($fullsrc);
    48. 

  48. 	} else {
    49. 

  49. 		$content = $fullsrc;
    50. 

  50. 	 $src = substr($fullsrc, 0, 30);
    51. 

  51. 	};
    52. 

  52. 	$encoding = mb_detect_encoding($content, 'UTF-8, ISO-8859-1, ASCII, UTF-7', true);
    53. 

  53.  $contentUTF8 = $content;
    54. 

  54.  // TEST #1
    55. 

  55.  switch ($encoding) {
    56. 

  56. 		case 'UTF-8':
    57. 

  57. 		 break;
    58. 

  58. 		default:
    59. 

  59. 			$contentUTF8 = iconv($encoding, "UTF-8", $content);
    60. 

  60. // 			if (is_file($fullsrc)) {
    61. 

  61.    if ($dumpIt) dump('#1) UTF-8 warning in "'.$src.'" '.($fPath?('('.basename($fPath).')'):'').': seems to be '.$encoding.'... please check and fix!');
    62. 

  62. // 				$chown = fileowner($fullsrc);
    63. 

  63. // 				$chgrp = filegroup($fullsrc);
    64. 

  64. // 				$@chmod = fileperms($fullsrc);
    65. 

  65. // 				file_put_contents($fullsrc, $content);
    66. 

  66. // 				chown($fullsrc, $chown);
    67. 

  67. // 				chgrp($fullsrc, $chgrp);
    68. 

  68. // 				@chmod($fullsrc, $CHMOD);
    69. 

  69. // 			};
    70. 

  70. 			break;
    71. 

  71. 	};
    72. 

  72. // TEST #2
    73. 

  73. // 	if (! checkUTF8Encoding($content, 'UTF-8')) {
    74. 

  74. // 		dump('#2) UTF-8 warning in "'.$src.'" '.($fPath?('('.basename($fPath).')'):'').': seems to be '.$encoding.'... please check and fix!');
    75. 

  75. //  }
    76. 

  76. 

  77. 	return $contentUTF8;
    78. 

  78. };
    79. 

  79. /* - - - - - - - - - - - - - - - - - */
    80. 

  80. 

  81. /* - - - - - - - - - - - - - - - - - */
    82. 

  82. function checkEncoding ( $string, $string_encoding ) {
    83. 

  83.     $fs = $string_encoding == 'UTF-8' ? 'UTF-32' : $string_encoding;
    84. 

  84.     $ts = $string_encoding == 'UTF-32' ? 'UTF-8' : $string_encoding;
    85. 

  85.     return $string === mb_convert_encoding ( mb_convert_encoding ( $string, $fs, $ts ), $ts, $fs );
    86. 

  86. };
    87. 

  87. /* - - - - - - - - - - - - - - - - - */
    88. 

  88. 

  89. /* - - - - - - - - - - - - - - - - - */
    90. 

  90. function charset_decode_utf_8 ($string) {
    91. 

  91.       /* Only do the slow convert if there are 8-bit characters */
    92. 

  92.     /* avoid using 0xA0 (\240) in ereg ranges. RH73 does not like that */
    93. 

  93.     if (! ereg("[\200-\237]", $string) and ! ereg("[\241-\377]", $string))
    94. 

  94.         return $string;
    95. 

  95. 

  96.     // decode three byte unicode characters
    97. 

  97.     $string = preg_replace("/([\340-\357])([\200-\277])([\200-\277])/e",
    98. 

  98.     "'&#'.((ord('\\1')-224)*4096 + (ord('\\2')-128)*64 + (ord('\\3')-128)).';'",
    99. 

  99.     $string);
    100. 

  100. 

  101.     // decode two byte unicode characters
    102. 

  102.     $string = preg_replace("/([\300-\337])([\200-\277])/e",
    103. 

  103.     "'&#'.((ord('\\1')-192)*64+(ord('\\2')-128)).';'",
    104. 

  104.     $string);
    105. 

  105. 

  106.     return $string;
    107. 

  107. }
    108. 

  108. /* - - - - - - - - - - - - - - - - - */
    109. 

  109. 

  110. /* - - - - - - - - - - - - - - - - - */
    111. 

  111. function uc_first($string) {
    112. 

  112. // if (preg_match('/abitator/', $string)) dump($string);
    113. 

  113.  return strval(ucfirst($string));
    114. 

  114. };
    115. 

  115. /* - - - - - - - - - - - - - - - - - */
    116. 

  116. 

  117. /* - - - - - - - - - - - - - - - - - */
    118. 

  118. function untag($string, $tag) {
    119. 

  119. 	$tmpval = array();
    120. 

  120. 	$preg = "|<$tag( .*?)?>(.*?)</$tag>|s";
    121. 

  121. 	preg_match_all($preg, $string, $tags);
    122. 

  122. 	foreach ($tags[2] as $tmpcont){
    123. 

  123. 		$tmpval[] = $tmpcont;
    124. 

  124. 	};
    125. 

  125. 	return $tmpval;
    126. 

  126. };
    127. 

  127. /* - - - - - - - - - - - - - - - - - */
    128. 

  128. 

  129. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    130. 

  130. // * ARCHIVES *
    131. 

  131. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    132. 

  132. 

  133. /* - - - - - - - - - - - - - - - - - */
    134. 

  134. function stripNamespaces (&$theText) {
    135. 

  135. 	$theText = str_ireplace('xmlns:'.XMLDB_TEI_NS, '', $theText);
    136. 

  136. 	$theText = str_ireplace(XMLDB_TEI_NS, '', $theText);
    137. 

  137. 	$theText = str_ireplace(XMLDB_TEI_NS2, '', $theText);
    138. 

  138. 	$theText = str_ireplace('xmlns:'.XMLDB_DCTL_NS, '', $theText);
    139. 

  139. 	$theText = str_ireplace(XMLDB_DCTL_NS, '', $theText);
    140. 

  140. 	$theText = str_ireplace(XMLDB_DCTL_NS2, '', $theText);
    141. 

  141. 	$theText = str_ireplace('xmlns:'.XMLDB_DYN_NS, '', $theText);
    142. 

  142. 	$theText = str_ireplace(XMLDB_DYN_NS, '', $theText);
    143. 

  143. 	$theText = str_ireplace('xmlns:'.XMLDB_EXSLT_NS, '', $theText);
    144. 

  144. 	$theText = str_ireplace(XMLDB_EXSLT_NS, '', $theText);
    145. 

  145. 	$theText = str_ireplace('xmlns:'.XMLDB_PHP_NS, '', $theText);
    146. 

  146. 	$theText = str_ireplace(XMLDB_PHP_NS, '', $theText);
    147. 

  147. 	$theText = str_ireplace('xmlns:'.XMLDB_STR_NS, '', $theText);
    148. 

  148. 	$theText = str_ireplace(XMLDB_STR_NS, '', $theText);
    149. 

  149. };
    150. 

  150. /* - - - - - - - - - - - - - - - - - */
    151. 

  151. 

  152. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    153. 

  153. function dctl_xmldb_disconnect ($exist = FALSE, $forceClose = false) {
    154. 

  154.  if ($exist) {
    155. 

  155.   $exist->disconnect($forceClose);
    156. 

  156.  };
    157. 

  157. };
    158. 

  158. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    159. 

  159. function dctl_xmldb_connect ($mode = 'query', $persistent = false) {
    160. 

  160. //
    161. 

  161. $persistent = false; // force to check if eXist works fine without pid
    162. 

  162. //
    163. 

  163. $exist = FALSE;
    164. 

  164. require_once(str_replace(SYS_PATH_SEP_DOUBLE,SYS_PATH_SEP,dirname(__FILE__).SYS_PATH_SEP).'..'.SYS_PATH_SEP.'_shared'.SYS_PATH_SEP.'exist-api.inc.php');
    165. 

  165.  try {
    166. 

  166. 		if ($mode == 'admin') {
    167. 

  167. 			$wsdl_url=XMLDB_HOST.':'.XMLDB_PORT.'/exist/services/Admin?wsdl';
    168. 

  168. 			$u = DCTL_XMLDB_USER_ADMIN;
    169. 

  169. 			$p = DCTL_XMLDB_PSWD_ADMIN;
    170. 

  170. 		} else {
    171. 

  171. 			$wsdl_url=XMLDB_HOST.':'.XMLDB_PORT.'/exist/services/Query?wsdl';
    172. 

  172. 			$u = DCTL_XMLDB_USER;
    173. 

  173. 			$p = DCTL_XMLDB_PSWD;
    174. 

  174. 		};
    175. 

  175.   $exist = false;
    176. 

  176. 		if (url_exists($wsdl_url)) {
    177. 

  177. /* 			if ($mode == 'admin') { */
    178. 

  178. /* 				$exist = new existAdmin(DCTL_XMLDB_USER, DCTL_XMLDB_PSWD, $wsdl_url); */
    179. 

  179. /* 			} else { */
    180. 

  180.  		 $exist = new exist($u, $p, $wsdl_url, $persistent);
    181. 

  181. /* 			}; */
    182. 

  182. 			$exist->setDebug(false);
    183. 

  183. 			$exist->connect($mode);
    184. 

  184. 		} else {
    185. 

  185. 			echo('<span class="error">Can\'t find URL {'.$wsdl_url.'}</span><br />');
    186. 

  186. 		};
    187. 

  187.  } catch (Exception $e) {
    188. 

  188.   echo('<span class="error">Can\'t connect to xmldb engine... {'.$e.'}</span><br />');
    189. 

  189.  };
    190. 

  190.  return $exist;
    191. 

  191. };
    192. 

  192. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    193. 

  193. 

  194. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    195. 

  195. function url_exists($url) {
    196. 

  196. if($url == NULL) return false;
    197. 

  197.          if (function_exists('curl_init')) {
    198. 

  198. 										$ch = curl_init($url);
    199. 

  199. 										curl_setopt($ch, CURLOPT_TIMEOUT, 5);
    200. 

  200. 										curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 5);
    201. 

  201. 										curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    202. 

  202. 										$data = curl_exec($ch);
    203. 

  203. 										$httpcode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    204. 

  204. 										curl_close($ch);
    205. 

  205.          } else {
    206. 

  206.           $httpcode = 200 * (file_get_contents($url,null,null,0,10) != false);
    207. 

  207.          };
    208. 

  208.          if($httpcode>=200 && $httpcode<300){
    209. 

  209.              return true;
    210. 

  210.          } else {
    211. 

  211.              return false;
    212. 

  212.          }
    213. 

  213. };
    214. 

  214. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    215. 

  215. 

  216. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    217. 

  217. function dctl_sql_connect ($db_name, $new=true) {
    218. 

  218. 	$URL = ''; // default
    219. 

  219. 	switch($db_name) {
    220. 

  220. 		case DCTL_DB_NAME:
    221. 

  221. 		 $URL = MYSQL_HOST_PN.':'.MYSQL_PORT_PN;
    222. 

  222. 			break;
    223. 

  223. 		case DCTL_DB_ICONCLASS:
    224. 

  224. 		 $URL = MYSQL_HOST_IC.':'.MYSQL_PORT_IC;
    225. 

  225. 			break;
    226. 

  226. 	};
    227. 

  227. 	try {
    228. 

  228.   $connection = mysql_connect($URL, DCTL_SQL_USER, DCTL_SQL_PSWD, $new);
    229. 

  229.  } catch (Exception $e) {
    230. 

  230.   die('<span class="error">Can\'t connect to sql engine... {'.$e.'}</span><br />');
    231. 

  231.  };
    232. 

  232.  try {
    233. 

  233.   mysql_select_db($db_name, $connection);
    234. 

  234.  } catch (Exception $e) {
    235. 

  235.   die('<span class="error">Can\'t connect to database "'.$db_name.'"... {'.$e.'}</span><br />');
    236. 

  236.  };
    237. 

  237.  return $connection;
    238. 

  238. };
    239. 

  239. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    240. 

  240. 

  241. 

  242. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    243. 

  243. // * GENERAL PURPOSES *
    244. 

  244. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    245. 

  245. 

  246. 

  247. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    248. 

  248. function doBackup ($fPath) {
    249. 

  249.  if (is_file($fPath)) {
    250. 

  250.   $dPath = dirname($fPath).SYS_PATH_SEP.DCTL_RESERVED_PREFIX.'bkp';
    251. 

  251.   if(!is_dir($dPath)) mkdir($dPath, CHMOD);
    252. 

  252.   @chmod($dPath, CHMOD);
    253. 

  253.   $fName = basename($fPath);
    254. 

  254.   $fExt = substr($fName, -4, 4);
    255. 

  255.   $fBase = substr($fName, 0, strlen($fName)-4);
    256. 

  256.   $fPath2 = $dPath.SYS_PATH_SEP.$fBase.'.'.date('ymdhms').'.'.DCTL_USER_ID.$fExt;
    257. 

  257. 		copy($fPath, $fPath2);
    258. 

  258. 		@chmod($fPath2, CHMOD);
    259. 

  259.  };
    260. 

  260. };
    261. 

  261. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    262. 

  262. 

  263. 

  264. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    265. 

  265. function checkIfLocked ($fPath, &$who, &$content) {
    266. 

  266. 	$isLocked = FALSE;
    267. 

  267. 	$who = '';
    268. 

  268. 	$content = array();
    269. 

  269. 	$dPath = dirname($fPath);
    270. 

  270. 	$handle = opendir($dPath);
    271. 

  271. 	while ($entry = readdir($handle)) {
    272. 

  272. 		if (substr($entry, 0, 1) != '.') {
    273. 

  273. 			$content[] = $dPath.SYS_PATH_SEP.$entry;
    274. 

  274. 		};
    275. 

  275. 	};
    276. 

  276. 	$content = array_values(preg_grep('/x-.*'.basename($fPath).'/', $content));
    277. 

  277. 	$isLocked = count($content) == 1;
    278. 

  278. 	if ($isLocked) {
    279. 

  279. 		$who = preg_split('/-/', basename($content[0]));
    280. 

  280. 		$who = $who[1];
    281. 

  281. 	};
    282. 

  282. 	return $isLocked;
    283. 

  283. };
    284. 

  284. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    285. 

  285. 

  286. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    287. 

  287. function makePreview ($theLocation, $g_srcfile, $overwrite=TRUE, $forcedsize=200, $imgcomp=0) {
    288. 

  288. 	 if (file_exists($g_srcfile)) {
    289. 

  289. 			global $EXTENSION_PREVIEW;
    290. 

  290. 			$g_imgcomp = 100-$imgcomp;
    291. 

  291. 			$g_fw = $forcedsize;
    292. 

  292. 			$g_fh = $forcedsize;
    293. 

  293. 	  $g_srcpath = dirname(dirname(dirname($g_srcfile))).SYS_PATH_SEP.$theLocation;
    294. 

  294.    if(!is_dir($g_srcpath)) mkdir($g_srcpath, CHMOD);
    295. 

  295.    @chmod($g_srcpath, CHMOD);
    296. 

  296. 	  $g_srcname = basename($g_srcfile);
    297. 

  297. 			$g_dstfile = $g_srcpath.SYS_PATH_SEP.$g_srcname;
    298. 

  298. 			if ($overwrite || (!file_exists($g_dstfile))) {
    299. 

  299. 				$ext = strtolower(substr($g_srcname, -3, 3));
    300. 

  300. 				if (in_array($ext, $EXTENSION_PREVIEW)) {
    301. 

  301. 					$g_is=getimagesize($g_srcfile);
    302. 

  302. 					if (($g_is[0]>$g_fw) || ($g_is[1]>$g_fh)) {
    303. 

  303. 						if (($g_is[0]-$g_fw) >= ($g_is[1]-$g_fh)) {
    304. 

  304. 							$g_iw=$g_fw;
    305. 

  305. 							$g_ih=($g_fw/$g_is[0])*$g_is[1];
    306. 

  306. 						} else {
    307. 

  307. 							$g_ih=$g_fh;
    308. 

  308. 							$g_iw=($g_ih/$g_is[1])*$g_is[0];
    309. 

  309. 						};
    310. 

  310. 						switch ($ext) {
    311. 

  311. 							case 'jpg':
    312. 

  312. 								$img_src=imagecreatefromjpeg($g_srcfile);
    313. 

  313. 								break;
    314. 

  314. 							case 'gif':
    315. 

  315. 								$img_src=imagecreatefromgif($g_srcfile);
    316. 

  316. 								break;
    317. 

  317. 							case 'png':
    318. 

  318. 								$img_src=imagecreatefrompng($g_srcfile);
    319. 

  319. 								break;
    320. 

  320. 						};
    321. 

  321. 						$img_dst=imagecreatetruecolor($g_iw,$g_ih);
    322. 

  322. 						imagecopyresampled($img_dst, $img_src, 0, 0, 0, 0, $g_iw, $g_ih, $g_is[0], $g_is[1]);
    323. 

  323. 						imagejpeg($img_dst, $g_dstfile, $g_imgcomp);
    324. 

  324. 						imagedestroy($img_dst);
    325. 

  325. 					} else {
    326. 

  326. 						copy($g_srcfile, $g_dstfile);
    327. 

  327. 						@chmod($g_dstfile, CHMOD);
    328. 

  328. 					};
    329. 

  329. 				} else {
    330. 

  330. 					$file_icon = DCTL_IMAGES.'file-'.$ext.'.gif';
    331. 

  331. 					if (!is_file($file_icon)) $file_icon = DCTL_IMAGES.'file-unknown.gif';
    332. 

  332. 					copy($file_icon, $g_dstfile.'.gif');
    333. 

  333. 					@chmod($g_dstfile, CHMOD);
    334. 

  334. 				};
    335. 

  335. 			};
    336. 

  336.  	};
    337. 

  337. 	};
    338. 

  338. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    339. 

  339. 

  340. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    341. 

  341. function createPreview ($g_srcfile, $overwrite=TRUE, $forcedsize=200, $imgcomp=0) {
    342. 

  342. 	if (is_dir($g_srcfile)) {
    343. 

  343. 		$handle = opendir($g_srcfile);
    344. 

  344. 		while ($entry = readdir($handle)) {
    345. 

  345.  	 if (substr($entry, 0, 1) != '.') {
    346. 

  346.  	  if (($entry != basename(DCTL_MEDIA_SML)) && ($entry != basename(DCTL_MEDIA_MED))) {
    347. 

  347. 				 createPreview ($g_srcfile.SYS_PATH_SEP.$entry, $overwrite, $forcedsize, $imgcomp);
    348. 

  348. 				};
    349. 

  349. 	  };
    350. 

  350. 	 };
    351. 

  351. 	} else {
    352. 

  352. 		makePreview (DCTL_MEDIA_SML, $g_srcfile, $overwrite, $forcedsize, $imgcomp);
    353. 

  353. 		makePreview (DCTL_MEDIA_MED, $g_srcfile, $overwrite, $forcedsize*2.5, $imgcomp);
    354. 

  354. 	};
    355. 

  355. };
    356. 

  356. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    357. 

  357. 

  358. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    359. 

  359. function dircopy ($srcdir, $dstdir, &$files=array()) {
    360. 

  360. 	if(!is_dir($dstdir)) mkdir($dstdir, CHMOD);
    361. 

  361.  @chmod($dstdir, CHMOD);
    362. 

  362. 	$handle = opendir($srcdir);
    363. 

  363. 	while ($entry = readdir($handle)) {
    364. 

  364. 	 if (substr($entry, 0, 1) != '.') {
    365. 

  365. 	  $fullsrc = $srcdir.SYS_PATH_SEP.$entry;
    366. 

  366. 	  $fulldst = $dstdir.SYS_PATH_SEP.$entry;
    367. 

  367. 	  if (is_dir ($fullsrc)) {
    368. 

  368. 				if(!is_dir($fulldst)) mkdir($fulldst, CHMOD);
    369. 

  369.     @chmod($fulldst, CHMOD);
    370. 

  370. 	   dircopy ($fullsrc, $fulldst, &$files);
    371. 

  371. 	  } else {
    372. 

  372. 	   if (is_file($fullsrc)) {
    373. 

  373. 	    copy($fullsrc, $fulldst);
    374. 

  374. 					@chmod($fulldst, CHMOD);
    375. 

  375. 				};
    376. 

  376. 	   $files[] = $entry;
    377. 

  377. 	  };
    378. 

  378. 	 };
    379. 

  379. 	};
    380. 

  380. 	@chmod($dstdir, CHMOD);
    381. 

  381. };
    382. 

  382. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    383. 

  383. 

  384. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    385. 

  385. function require_here ($file) {
    386. 

  386. 	if(is_file($file)) {
    387. 

  387. 		$phpCode=implode("", file($file));
    388. 

  388. 		ob_start();
    389. 

  389. 		eval('?>'.$phpCode);
    390. 

  390. 		$returnText = ob_get_contents();
    391. 

  391. 		ob_end_clean();
    392. 

  392. 	} else {
    393. 

  393. 	 $returnText = '<span class="error">File not found: '.basename($file).'</span>';
    394. 

  394. 	};
    395. 

  395.  return $returnText;
    396. 

  396. };
    397. 

  397. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    398. 

  398. 

  399. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    400. 

  400. function hardFlush(&$text = '') {
    401. 

  401.  if ($text != '') {
    402. 

  402. 		if (strlen($text)<256) $text = str_pad($text,256);
    403. 

  403. 		// make sure output buffering is off before we start it
    404. 

  404. 		// this will ensure same effect whether or not ob is enabled already
    405. 

  405. 		while (ob_get_level()) {
    406. 

  406. 						ob_end_flush();
    407. 

  407. 		};
    408. 

  408. 		// start output buffering
    409. 

  409. 		if (ob_get_length() === false) {
    410. 

  410. 						ob_start();
    411. 

  411. 		};
    412. 

  412. 		echo '<li>'.$text.'</li>';
    413. 

  413. 		ob_flush();
    414. 

  414. 		flush();
    415. 

  415. 		$text = '';
    416. 

  416. 	};
    417. 

  417. };
    418. 

  418. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    419. 

  419. 

  420. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    421. 

  421. function cleanUpIndentation($theText) {
    422. 

  422.  $theText = preg_replace('/<(\w+)>('.WS.'*)<\/(\w+)>/', '<$1 />', $theText);
    423. 

  423.  $theText = preg_replace('/('.WS.'{2,})/', '$1', $theText);
    424. 

  424.  $theText = preg_replace('/'.WS.'*\/>/', ' />', $theText);
    425. 

  425.  $theText = preg_replace('/'.WS.'+/', ' ', $theText);
    426. 

  426.  $theText = preg_replace('/>'.WS.'*</', '> <', $theText);
    427. 

  427.  return $theText;
    428. 

  428. };
    429. 

  429. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    430. 

  430. 

  431. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    432. 

  432. function normalize($string) {
    433. 

  433.  $n_string = $string;// $n_string = strtolower($string);
    434. 

  434.  $n_string = preg_replace('/[^a-zA-Z0-9._\-]/', '', $n_string);// remove all unwanted chars
    435. 

  435. 	return trim($n_string);
    436. 

  436. };
    437. 

  437. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    438. 

  438. 

  439. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    440. 

  440. function my_strtoupper ($output)
    441. 

  441. {
    442. 

  442.  // Convert accented characters to their ASCII counterparts...
    443. 

  443. 	$output = strtr(utf8_decode($output),
    444. 

  444. 																	"\xA1\xAA\xBA\xBF".
    445. 

  445. 																	"\xC0\xC1\xC2\xC3\xC5\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF".
    446. 

  446. 																	"\xD0\xD1\xD2\xD3\xD4\xD5\xD8\xD9\xDA\xDB\xDD".
    447. 

  447. 																	"\xE0\xE1\xE2\xE3\xE5\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF".
    448. 

  448. 																	"\xF0\xF1\xF2\xF3\xF4\xF5\xF8\xF9\xFA\xFB\xFD\xFF",
    449. 

  449. 																	"!ao?AAAAACEEEEIIIIDNOOOOOUUUYaaaaaceeeeiiiidnooooouuuyy");
    450. 

  450. 	// ...and ligatures too
    451. 

  451. 	$output = makeUTF8(strtr($output, array("\xC4"=>"Ae", "\xC6"=>"AE", "\xD6"=>"Oe",
    452. 

  452. 																																												"\xDC"=>"Ue", "\xDE"=>"TH", "\xDF"=>"ss", "\xE4"=>"ae", "\xE6"=>"ae",
    453. 

  453. 																																												"\xF6"=>"oe", "\xFC"=>"ue", "\xFE"=>"th")));
    454. 

  454. 

  455. 	$output = strtoupper($output);
    456. 

  456. 

  457. 	return $output;
    458. 

  458. }
    459. 

  459. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    460. 

  460. 

  461. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    462. 

  462. function my_soundex ($WordString, $LengthOption=0)
    463. 

  463. {
    464. 

  464. 

  465. 	$SoundExLen = $LengthOption;
    466. 

  466. 

  467. 	if($SoundExLen > 10) {
    468. 

  468. 		$SoundExLen = 10;
    469. 

  469. 	}
    470. 

  470. 	if($SoundExLen < 4) {
    471. 

  471. 		$SoundExLen = 4;
    472. 

  472. 	}
    473. 

  473. 

  474. 	if(!$WordString) {
    475. 

  475. 		return "";
    476. 

  476. 	}
    477. 

  477. 

  478. # Clean and tidy
    479. 

  479. #
    480. 

  480. 	// $WordString = strtoupper($WordString);
    481. 

  481. 	$WordString = my_strtoupper($WordString);
    482. 

  482. 	$WordStr = $WordString;
    483. 

  483. 	$WordStr = preg_replace ('/[^A-Z]/si', ' ', $WordStr);   # replace non-chars with space
    484. 

  484. 		$WordStr = preg_replace ('/^'.WS.'/s', '', $WordStr);        # remove leading space
    485. 

  485. 			$WordStr = preg_replace ('/'.WS.'$/s', '', $WordStr);        # remove trailing space
    486. 

  486. 

  487. # Some of our own improvements
    488. 

  488. 				$WordStr = preg_replace ('/DG/s', '', $WordStr);          # Change DG to G
    489. 

  489. 					$WordStr = preg_replace ('/GH/s', 'H', $WordStr);          # Change GH to H
    490. 

  490. 						$WordStr = preg_replace ('/KN/s', 'N', $WordStr);          # Change KN to N
    491. 

  491. 							$WordStr = preg_replace ('/GN/s', 'N', $WordStr);          # Change GN to N
    492. 

  492. 								$WordStr = preg_replace ('/MB/s', 'M', $WordStr);          # Change MB to M
    493. 

  493. 									$WordStr = preg_replace ('/PH/s', 'F', $WordStr);          # Change PH to F
    494. 

  494.           $WordStr = preg_replace ('/TCH/s', 'CH', $WordStr);        # Change TCH to CH
    495. 

  495. 											$WordStr = preg_replace ('/MP([STZ])/s', 'M$1', $WordStr); # MP if follwd by S|T|Z
    496. 

  496. 												$WordStr = preg_replace ('/^PS/s', 'S', $WordStr);         # Change leading PS to S
    497. 

  497. 													$WordStr = preg_replace ('/^PF/s', 'F', $WordStr);         # Change leading PF to F
    498. 

  498. 

  499. # Done here because the
    500. 

  500. # above improvements could
    501. 

  501. # change this first letter
    502. 

  502. #
    503. 

  503. 														$FirstLetter = substr($WordStr,0,1);
    504. 

  504. 

  505. # in case 1st letter is
    506. 

  506. # an H or W and we're in
    507. 

  507. # CensusOption = 1
    508. 

  508. #  (add test for 'H'/'W' v1.0c djr)
    509. 

  509. #
    510. 

  510. 													if($FirstLetter == "H" | $FirstLetter == "W") {
    511. 

  511. 														$TmpStr = substr($WordStr,1);
    512. 

  512. 														$WordStr = "-$TmpStr";
    513. 

  513. 													}
    514. 

  514. 

  515. # Begin Classic SoundEx
    516. 

  516. #
    517. 

  517. 													$WordStr = preg_replace ('/[AEIOUYHW]/s', '0', $WordStr);
    518. 

  518. 													$WordStr = preg_replace ('/[BPFV]/s' ,'1', $WordStr);
    519. 

  519. 													$WordStr = preg_replace ('/[CSGJKQXZ]/s', '2', $WordStr);
    520. 

  520. 													$WordStr = preg_replace ('/[DT]/s', '3', $WordStr);
    521. 

  521. 													$WordStr = preg_replace ('/L/s', '4', $WordStr);
    522. 

  522. 													$WordStr = preg_replace ('/[MN]/s', '5', $WordStr);
    523. 

  523. 													$WordStr = preg_replace ('/R/s', '6', $WordStr);
    524. 

  524. 

  525. # Remove extra equal adjacent digits
    526. 

  526. #
    527. 

  527. 													$WSLen = strlen($WordStr);
    528. 

  528. 													$LastChar = '';
    529. 

  529. # v1.0c rmv: $TmpStr = "-";    # rplc skipped 1st char
    530. 

  530. 													$TmpStr = '';
    531. 

  531. 													for($i = 0; $i < $WSLen; $i++) { # v1.0c now org-0
    532. 

  532. 														$CurChar = substr($WordStr, $i, 1);
    533. 

  533. 														if($CurChar == $LastChar) {
    534. 

  534. 															$TmpStr .= ' ';
    535. 

  535. 														}
    536. 

  536. 														else {
    537. 

  537. 															$TmpStr .= $CurChar;
    538. 

  538. 															$LastChar = $CurChar;
    539. 

  539. 														}
    540. 

  540. 													}
    541. 

  541. 													$WordStr = $TmpStr;
    542. 

  542. 

  543. 													$WordStr = substr($WordStr,1);      # Drop first ltr code
    544. 

  544. 														$WordStr = preg_replace ('/'.WS.'/s', '', $WordStr);               # remove spaces
    545. 

  545. 															$WordStr = preg_replace ('/0/s', '', $WordStr);                # remove zeros
    546. 

  546. 																$WordStr .= "0000000000";           # pad w/0s on rght
    547. 

  547. 

  548. 																	$WordStr = "$FirstLetter$WordStr";  # Add 1st ltr of wrd
    549. 

  549. 

  550. 																		$WordStr = substr($WordStr,0,$SoundExLen);  # size to taste
    551. 

  551. 

  552. 																			return $WordStr;
    553. 

  553. 

  554. }
    555. 

  555. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    556. 

  556. 

  557. /* - - - - - - - - - - - - - - - - - */
    558. 

  558. function cleanWebString ($theMixed, $theLength=0, $theSpacer='') {
    559. 

  559.  $theResult = '';
    560. 

  560.  $theMixed = (array) $theMixed;
    561. 

  561.  foreach ($theMixed as $theString) {
    562. 

  562.   $theString = (string) $theString;
    563. 

  563.   if ($theString != '') {
    564. 

  564. 			$theString = strip_html($theString);
    565. 

  565. 			$theString = preg_replace('/'.WS.''.WS.'+/', ' ', $theString);
    566. 

  566. 

  567. 			$theString = preg_replace('/\"/', '&quot;', $theString);
    568. 

  568. 			$theString = preg_replace('/\'/', '&apos;', $theString);
    569. 

  569. 			$theString = preg_replace('/\>/', '&gt;', $theString);
    570. 

  570. 			$theString = preg_replace('/\</', '&lt;', $theString);
    571. 

  571. 			$theString = trim($theString);
    572. 

  572. 			if ($theLength > 0) {
    573. 

  573. 				$add = '';
    574. 

  574. 				if ($theLength < strlen($theString)) {
    575. 

  575. 					$add = '...';
    576. 

  576. 				};
    577. 

  577. 				$theString = substr($theString, 0, $theLength).$add;
    578. 

  578. 			};
    579. 

  579.    if ($theString != '') {
    580. 

  580. 	 		if ($theResult != '') {
    581. 

  581. 	 		 $theResult .= '. ';
    582. 

  582. 	 		};
    583. 

  583. 			 $theString = makeSafeEntities($theString);
    584. 

  584. 				//
    585. 

  585. 				// 			 $theString = str_ireplace('<','&lt;',$theString);
    586. 

  586. 				// 			 $theString = str_ireplace('>','&gt;',$theString);
    587. 

  587. 				//
    588. 

  588. 	 		$theResult .= $theString;
    589. 

  589.   	};
    590. 

  590.  	};
    591. 

  591. 	};
    592. 

  592.  return $theResult;
    593. 

  593. };
    594. 

  594. /* - - - - - - - - - - - - - - - - - */
    595. 

  595. 

  596. /* - - - - - - - - - - - - - - - - - */
    597. 

  597. function strip_html($text, $theSpacer='') {
    598. 

  598.  $search = array('@<script[^>]*?>.*?</script>@si',  // Strip out javascript
    599. 

  599.                  '@<[\/\!]*?[^<>]*?>@si',            // Strip out HTML tags
    600. 

  600.                  '@<style[^>]*?>.*?</style>@siU',    // Strip style tags properly
    601. 

  601.                  '@<!['.WS.'\S]*?--[ \t\n\r]*>@'        // Strip multi-line comments including CDATA
    602. 

  602.                  );
    603. 

  603.  $text = preg_replace($search, $theSpacer, $text);
    604. 

  604.  return $text;
    605. 

  605. };
    606. 

  606. /* - - - - - - - - - - - - - - - - - */
    607. 

  607. 

  608. /* - - - - - - - - - - - - - - - - - */
    609. 

  609. // Convert str to UTF-8 (if not already), then convert that to HTML named entities.
    610. 

  610. // and numbered references. Compare to native htmlentities() function.
    611. 

  611. // Unlike that function, this will skip any already existing entities in the string.
    612. 

  612. // mb_convert_encoding() doesn't encode ampersands, so use makeAmpersandEntities to convert those.
    613. 

  613. // mb_convert_encoding() won't usually convert to illegal numbered entities (128-159) unless
    614. 

  614. // there's a charset discrepancy, but just in case, correct them with correctIllegalEntities.
    615. 

  615. function makeSafeEntities($str, $convertTags = 0, $encoding = "") {
    616. 

  616. 	if (is_array($arrOutput = $str)) {
    617. 

  617. 		foreach (array_keys($arrOutput) as $key)
    618. 

  618. 		$arrOutput[$key] = makeSafeEntities($arrOutput[$key],$encoding);
    619. 

  619. 		return $arrOutput;
    620. 

  620. 	}
    621. 

  621. 	else if (strlen($str)>0) {
    622. 

  622. 		$str = makeUTF8($str,$encoding);
    623. 

  623. 		$str = mb_convert_encoding($str,"HTML-ENTITIES","UTF-8");
    624. 

  624. 		$str = makeAmpersandEntities($str);
    625. 

  625. 		if ($convertTags)
    626. 

  626. 			$str = makeTagEntities($str);
    627. 

  627. 		$str = correctIllegalEntities($str);
    628. 

  628. 		return $str;
    629. 

  629. 	}
    630. 

  630. }
    631. 

  631. /* - - - - - - - - - - - - - - - - - */
    632. 

  632. 

  633. /* - - - - - - - - - - - - - - - - - */
    634. 

  634. // Compare to native utf8_encode function, which will re-encode text that is already UTF-8
    635. 

  635. function makeUTF8($str,$encoding = "") {
    636. 

  636. 	if (strlen($str)>0) {
    637. 

  637. 		if (empty($encoding) && isUTF8($str))
    638. 

  638. 			$encoding = "UTF-8";
    639. 

  639. 		if (empty($encoding))
    640. 

  640. 			$encoding = mb_detect_encoding($str,'UTF-8, ISO-8859-1');
    641. 

  641. 		if (empty($encoding))
    642. 

  642. 			$encoding = "ISO-8859-1"; //  if charset can't be detected, default to ISO-8859-1
    643. 

  643. 		return $encoding == "UTF-8" ? $str : @mb_convert_encoding($str,"UTF-8",$encoding);
    644. 

  644. 	};
    645. 

  645. 	return '';
    646. 

  646. }
    647. 

  647. /* - - - - - - - - - - - - - - - - - */
    648. 

  648. 

  649. /* - - - - - - - - - - - - - - - - - */
    650. 

  650. // Much simpler UTF-8-ness checker using a regular expression created by the W3C:
    651. 

  651. // Returns true if $string is valid UTF-8 and false otherwise.
    652. 

  652. // From http://w3.org/International/questions/qa-forms-UTF-8.html
    653. 

  653. function isUTF8($str) {
    654. 

  654. 	return preg_match('%^(?:
    655. 

  655.                        [\x09\x0A\x0D\x20-\x7E]           // ASCII
    656. 

  656.                        | [\xC2-\xDF][\x80-\xBF]            // non-overlong 2-byte
    657. 

  657.                        | \xE0[\xA0-\xBF][\x80-\xBF]        // excluding overlongs
    658. 

  658.                        | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} // straight 3-byte
    659. 

  659.                        | \xED[\x80-\x9F][\x80-\xBF]        // excluding surrogates
    660. 

  660.                        | \xF0[\x90-\xBF][\x80-\xBF]{2}     // planes 1-3
    661. 

  661.                        | [\xF1-\xF3][\x80-\xBF]{3}         // planes 4-15
    662. 

  662.                        | \xF4[\x80-\x8F][\x80-\xBF]{2}     // plane 16
    663. 

  663.                        )*$%xs', $str);
    664. 

  664. }
    665. 

  665. /* - - - - - - - - - - - - - - - - - */
    666. 

  666. 

  667. /* - - - - - - - - - - - - - - - - - */
    668. 

  668. // Convert ampersands to named or numbered entities.
    669. 

  669. // Use regex to skip any that might be part of existing entities.
    670. 

  670. function makeAmpersandEntities($str, $useNamedEntities = 1) {
    671. 

  671. 	return preg_replace("/&(?![A-Za-z]{0,4}\w{2,3};|#[0-9]{2,5};)/m", $useNamedEntities ? "&amp;" : "&#38;", $str);
    672. 

  672. }
    673. 

  673. /* - - - - - - - - - - - - - - - - - */
    674. 

  674. 

  675. /* - - - - - - - - - - - - - - - - - */
    676. 

  676. // Convert illegal HTML numbered entities in the range 128 - 159 to legal couterparts
    677. 

  677. function correctIllegalEntities($str) {
    678. 

  678. 	$chars = array(
    679. 

  679.                 128 => '&#8364;',
    680. 

  680.                 130 => '&#8218;',
    681. 

  681.                 131 => '&#402;',
    682. 

  682.                 132 => '&#8222;',
    683. 

  683.                 133 => '&#8230;',
    684. 

  684.                 134 => '&#8224;',
    685. 

  685.                 135 => '&#8225;',
    686. 

  686.                 136 => '&#710;',
    687. 

  687.                 137 => '&#8240;',
    688. 

  688.                 138 => '&#352;',
    689. 

  689.                 139 => '&#8249;',
    690. 

  690.                 140 => '&#338;',
    691. 

  691.                 142 => '&#381;',
    692. 

  692.                 145 => '&#8216;',
    693. 

  693.                 146 => '&#8217;',
    694. 

  694.                 147 => '&#8220;',
    695. 

  695.                 148 => '&#8221;',
    696. 

  696.                 149 => '&#8226;',
    697. 

  697.                 150 => '&#8211;',
    698. 

  698.                 151 => '&#8212;',
    699. 

  699.                 152 => '&#732;',
    700. 

  700.                 153 => '&#8482;',
    701. 

  701.                 154 => '&#353;',
    702. 

  702.                 155 => '&#8250;',
    703. 

  703.                 156 => '&#339;',
    704. 

  704.                 158 => '&#382;',
    705. 

  705.                 159 => '&#376;');
    706. 

  706. 	foreach (array_keys($chars) as $num)
    707. 

  707. 		$str = str_replace("&#".$num.";", $chars[$num], $str);
    708. 

  708. 	return $str;
    709. 

  709. }
    710. 

  710. /* - - - - - - - - - - - - - - - - - */
    711. 

  711. 

  712. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    713. 

  713. function dump ($text='** HERE **', $class='') {
    714. 

  714.  $returnText = '';
    715. 

  715.  $returnText .= '<div style="background:white;color:red;border:1px dotted red;';
    716. 

  716.  $returnText .= 'right:1.0em;z-index:10000;width:98%;overflow:auto;';
    717. 

  717.  $returnText .= 'word-wrap:break-word;height:auto;background:transparent;';
    718. 

  718.  $returnText .= 'padding:3px;font-size:9px;position:relative;top:0;left:1.0em">';
    719. 

  719.  $backtrace = debug_backtrace();
    720. 

  720.  $text = preg_replace('/\n/', '<br />', htmlentities(((string) serialize($text)), ENT_QUOTES, "utf-8")).'<br />';//htmlentities(nl2br((string) serialize($text))); // var_export($text,true) | print_r($text,true) | serialize($text)
    721. 

  721.  if ($class != '') {
    722. 

  722.   $returnText = '<span class="'.$class.'">'.$returnText.'</span>';
    723. 

  723.  };
    724. 

  724.  $returnText .= $text;
    725. 

  725.  foreach ($backtrace as $k=>$v) {
    726. 

  726.   $file = (isset($backtrace[$k]['file'])) ? $backtrace[$k]['file']: '???';
    727. 

  727. 		$returnText .= basename(dirname($file)).SYS_PATH_SEP.basename($file).' :: ';
    728. 

  728. 		if (isset($backtrace[$k+1])) $returnText .= $backtrace[$k+1]['function'];
    729. 

  729.   $line = (isset($backtrace[$k]['line'])) ? $backtrace[$k]['line']: '???';
    730. 

  730. 		$returnText .= ' @ '.$line.'<br />';
    731. 

  731.  };
    732. 

  732.  $returnText .= '</div>';
    733. 

  733.  echo $returnText;
    734. 

  734. };
    735. 

  735. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    736. 

  736. 

  737. /* - - - - - - - - - - - - - - - - - */
    738. 

  738. function dctl_getPHPvar($theVar) {
    739. 

  739.  $thePHP = 'echo '.$theVar.';';
    740. 

  740.  ob_start();
    741. 

  741.  eval($thePHP);
    742. 

  742. 	$returnText = ob_get_contents();
    743. 

  743. 	ob_end_clean();
    744. 

  744.  return $returnText;
    745. 

  745. };
    746. 

  746. /* - - - - - - - - - - - - - - - - - */
    747. 

  747. 

  748. /* - - - - - - - - - - - - - - - - - */
    749. 

  749. function dctl_getCurrentLanguage () {
    750. 

  750. 	global $curr_lang;
    751. 

  751. 	return strval($curr_lang);
    752. 

  752. };
    753. 

  753. /* - - - - - - - - - - - - - - - - - */
    754. 

  754. 

  755. /* - - - - - - - - - - - - - - - - - */
    756. 

  756. function dctl_getLocalized($item) {
    757. 

  757. 	global $curr_lang;
    758. 

  758. 	global $string;
    759. 

  759. 	if (isset($string[$curr_lang][$item])) {
    760. 

  760. 		return strval($string[$curr_lang][$item]);
    761. 

  761. 	} else {
    762. 

  762. 	 return strval('[?'.$item.'?]');
    763. 

  763. 	};
    764. 

  764. };
    765. 

  765. /* - - - - - - - - - - - - - - - - - */
    766. 

  766. 

  767. 

  768. 

  769. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    770. 

  770. class zipfile  {
    771. 

  771. 

  772. 	var $datasec = array(); // array to store compressed data
    773. 

  773. 	var $ctrl_dir = array(); // central directory
    774. 

  774. 	var $eof_ctrl_dir = "\x50\x4b\x05\x06\x00\x00\x00\x00"; //end of Central directory record
    775. 

  775. 	var $old_offset = 0;
    776. 

  776. 

  777. 	function add_dir($name)
    778. 

  778. 

  779. 		// adds "directory" to archive - do this before putting any files in directory!
    780. 

  780. 		// $name - name of directory... like this: "path/"
    781. 

  781. 		// ...then you can add files using add_file with names like "path/file.txt"
    782. 

  782. 	{
    783. 

  783. 		$name = str_replace("\\", "/", $name);
    784. 

  784. 

  785. 		$fr = "\x50\x4b\x03\x04";
    786. 

  786. 		$fr .= "\x0a\x00";    // ver needed to extract
    787. 

  787. 		$fr .= "\x00\x00";    // gen purpose bit flag
    788. 

  788. 		$fr .= "\x00\x00";    // compression method
    789. 

  789. 		$fr .= "\x00\x00\x00\x00"; // last mod time and date
    790. 

  790. 

  791. 		$fr .= pack("V",0); // crc32
    792. 

  792. 		$fr .= pack("V",0); //compressed filesize
    793. 

  793. 		$fr .= pack("V",0); //uncompressed filesize
    794. 

  794. 		$fr .= pack("v", strlen($name) ); //length of pathname
    795. 

  795. 		$fr .= pack("v", 0 ); //extra field length
    796. 

  796. 		$fr .= $name;
    797. 

  797. 		// end of "local file header" segment
    798. 

  798. 

  799. 		// no "file data" segment for path
    800. 

  800. 

  801. 		// "data descriptor" segment (optional but necessary if archive is not served as file)
    802. 

  802. 		$fr .= pack("V",0); //crc32
    803. 

  803. 		$fr .= pack("V",0); //compressed filesize
    804. 

  804. 		$fr .= pack("V",0); //uncompressed filesize
    805. 

  805. 

  806. 		// add this entry to array
    807. 

  807. 		$this->datasec[] = $fr;
    808. 

  808. 

  809. 		$new_offset = strlen(implode("", $this->datasec));
    810. 

  810. 

  811. 		// ext. file attributes mirrors MS-DOS directory attr byte, detailed
    812. 

  812. 		// at http://support.microsoft.com/support/kb/articles/Q125/0/19.asp
    813. 

  813. 

  814. 		// now add to central record
    815. 

  815. 		$cdrec = "\x50\x4b\x01\x02";
    816. 

  816. 		$cdrec .="\x00\x00";    // version made by
    817. 

  817. 		$cdrec .="\x0a\x00";    // version needed to extract
    818. 

  818. 		$cdrec .="\x00\x00";    // gen purpose bit flag
    819. 

  819. 		$cdrec .="\x00\x00";    // compression method
    820. 

  820. 		$cdrec .="\x00\x00\x00\x00"; // last mod time & date
    821. 

  821. 		$cdrec .= pack("V",0); // crc32
    822. 

  822. 		$cdrec .= pack("V",0); //compressed filesize
    823. 

  823. 		$cdrec .= pack("V",0); //uncompressed filesize
    824. 

  824. 		$cdrec .= pack("v", strlen($name) ); //length of filename
    825. 

  825. 		$cdrec .= pack("v", 0 ); //extra field length
    826. 

  826. 		$cdrec .= pack("v", 0 ); //file comment length
    827. 

  827. 		$cdrec .= pack("v", 0 ); //disk number start
    828. 

  828. 		$cdrec .= pack("v", 0 ); //internal file attributes
    829. 

  829. 		$ext = "\x00\x00\x10\x00";
    830. 

  830. 		$ext = "\xff\xff\xff\xff";
    831. 

  831. 		$cdrec .= pack("V", 16 ); //external file attributes  - 'directory' bit set
    832. 

  832. 

  833. 		$cdrec .= pack("V", $this->old_offset ); //relative offset of local header
    834. 

  834. 		$this->old_offset = $new_offset;
    835. 

  835. 

  836. 		$cdrec .= $name;
    837. 

  837. 		// optional extra field, file comment goes here
    838. 

  838. 		// save to array
    839. 

  839. 		$this->ctrl_dir[] = $cdrec;
    840. 

  840. 

  841. 

  842. 	}
    843. 

  843. 

  844. 

  845. 	function add_file($data, $name)
    846. 

  846. 

  847. 		// adds "file" to archive
    848. 

  848. 		// $data - file contents
    849. 

  849. 		// $name - name of file in archive. Add path if your want
    850. 

  850. 

  851. 	{
    852. 

  852. 		$name = str_replace("\\", "/", $name);
    853. 

  853. 		//$name = str_replace("\\", "\\\\", $name);
    854. 

  854. 

  855. 		$fr = "\x50\x4b\x03\x04";
    856. 

  856. 		$fr .= "\x14\x00";    // ver needed to extract
    857. 

  857. 		$fr .= "\x00\x00";    // gen purpose bit flag
    858. 

  858. 		$fr .= "\x08\x00";    // compression method
    859. 

  859. 		$fr .= "\x00\x00\x00\x00"; // last mod time and date
    860. 

  860. 

  861. 		$unc_len = strlen($data);
    862. 

  862. 		$crc = crc32($data);
    863. 

  863. 		$zdata = gzcompress($data);
    864. 

  864. 		$zdata = substr( substr($zdata, 0, strlen($zdata) - 4), 2); // fix crc bug
    865. 

  865. 		$c_len = strlen($zdata);
    866. 

  866. 		$fr .= pack("V",$crc); // crc32
    867. 

  867. 		$fr .= pack("V",$c_len); //compressed filesize
    868. 

  868. 		$fr .= pack("V",$unc_len); //uncompressed filesize
    869. 

  869. 		$fr .= pack("v", strlen($name) ); //length of filename
    870. 

  870. 		$fr .= pack("v", 0 ); //extra field length
    871. 

  871. 		$fr .= $name;
    872. 

  872. 		// end of "local file header" segment
    873. 

  873. 

  874. 		// "file data" segment
    875. 

  875. 		$fr .= $zdata;
    876. 

  876. 

  877. 		// "data descriptor" segment (optional but necessary if archive is not served as file)
    878. 

  878. 		$fr .= pack("V",$crc); //crc32
    879. 

  879. 		$fr .= pack("V",$c_len); //compressed filesize
    880. 

  880. 		$fr .= pack("V",$unc_len); //uncompressed filesize
    881. 

  881. 

  882. 		// add this entry to array
    883. 

  883. 		$this->datasec[] = $fr;
    884. 

  884. 

  885. 		$new_offset = strlen(implode("", $this->datasec));
    886. 

  886. 

  887. 		// now add to central directory record
    888. 

  888. 		$cdrec = "\x50\x4b\x01\x02";
    889. 

  889. 		$cdrec .="\x00\x00";    // version made by
    890. 

  890. 		$cdrec .="\x14\x00";    // version needed to extract
    891. 

  891. 		$cdrec .="\x00\x00";    // gen purpose bit flag
    892. 

  892. 		$cdrec .="\x08\x00";    // compression method
    893. 

  893. 		$cdrec .="\x00\x00\x00\x00"; // last mod time & date
    894. 

  894. 		$cdrec .= pack("V",$crc); // crc32
    895. 

  895. 		$cdrec .= pack("V",$c_len); //compressed filesize
    896. 

  896. 		$cdrec .= pack("V",$unc_len); //uncompressed filesize
    897. 

  897. 		$cdrec .= pack("v", strlen($name) ); //length of filename
    898. 

  898. 		$cdrec .= pack("v", 0 ); //extra field length
    899. 

  899. 		$cdrec .= pack("v", 0 ); //file comment length
    900. 

  900. 		$cdrec .= pack("v", 0 ); //disk number start
    901. 

  901. 		$cdrec .= pack("v", 0 ); //internal file attributes
    902. 

  902. 		$cdrec .= pack("V", 32 ); //external file attributes - 'archive' bit set
    903. 

  903. 

  904. 		$cdrec .= pack("V", $this->old_offset ); //relative offset of local header
    905. 

  905. 		$this->old_offset = $new_offset;
    906. 

  906. 

  907. 		$cdrec .= $name;
    908. 

  908. 		// optional extra field, file comment goes here
    909. 

  909. 		// save to central directory
    910. 

  910. 		$this->ctrl_dir[] = $cdrec;
    911. 

  911. 	}
    912. 

  912. 

  913. 	function file() { //
    914. 

  914. 		$data = implode("", $this->datasec);
    915. 

  915. 		$ctrldir = implode("", $this->ctrl_dir);
    916. 

  916. 

  917. 		return
    918. 

  918. 			$data.
    919. 

  919. 			$ctrldir.
    920. 

  920. 			$this->eof_ctrl_dir.
    921. 

  921. 			pack("v", sizeof($this->ctrl_dir)).     // total # of entries "on this disk"
    922. 

  922. 			pack("v", sizeof($this->ctrl_dir)).     // total # of entries overall
    923. 

  923. 			pack("V", strlen($ctrldir)).             // size of central dir
    924. 

  924. 			pack("V", strlen($data)).                 // offset to start of central dir
    925. 

  925. 			"\x00\x00";                             // .zip file comment length
    926. 

  926. 	}
    927. 

  927. }
    928. 

  928. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    929. 

  929. 

  930. 

  931. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    932. 

  932. function addToZip($item, &$zip, $zipdir="") {
    933. 

  933. 	if (is_dir($item)) {
    934. 

  934. 		$zipdir .= basename($item).SYS_PATH_SEP;
    935. 

  935. 		$zip->add_dir($zipdir);
    936. 

  936. 		$handle = opendir($item);
    937. 

  937. 		while ($entry = readdir($handle)) {
    938. 

  938. 			if (substr($entry, 0, 1) != '.') {
    939. 

  939. 				addToZip($item.SYS_PATH_SEP.$entry, &$zip, $zipdir);
    940. 

  940. 			};
    941. 

  941. 		};
    942. 

  942. 	} else {
    943. 

  943. 		if (is_file($item)) {
    944. 

  944. 		 if (strtolower(substr($item, -4, 4)) != '.zip') {
    945. 

  945. 				$handle = fopen($item, "r");
    946. 

  946. 				$contents = fread($handle, filesize($item));
    947. 

  947. 				fclose($handle);
    948. 

  948.     $zip->add_dir($zipdir);
    949. 

  949. 				$zip->add_file($contents,$zipdir.basename($item));
    950. 

  950.   	};
    951. 

  951.  	};
    952. 

  952. 	};
    953. 

  953. };
    954. 

  954. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    955. 

  955. 

  956. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    957. 

  957. class asPrettyXMLElement extends SimpleXMLElement {
    958. 

  958.     /**
    959. 

  959.      * Outputs this element as pretty XML to increase readability.
    960. 

  960.      *
    961. 

  961.      * @param   int     $level      (optional) The number of spaces to use for
    962. 

  962.      *                              indentation, defaults to 1
    963. 

  963.      * @return  string              The XML output
    964. 

  964.      * @access  public
    965. 

  965.      */
    966. 

  966.     public function asPrettyXML($level = 1)    {
    967. 

  967.         // get an array containing each XML element
    968. 

  968.         $xml = explode("\n", preg_replace('/>'.WS.'*</', ">\n<", preg_replace('/('.WS.')'.WS.'+/','$1',$this->asXML())));
    969. 

  969.         // hold current indentation level
    970. 

  970.         $indent = 0;
    971. 

  971.         // hold the XML segments
    972. 

  972.         $pretty = array();
    973. 

  973.         // shift off opening XML tag if present
    974. 

  974.         if (count($xml) && preg_match('/^<\?'.WS.'*xml/', $xml[0])) {
    975. 

  975.             $pretty[] = array_shift($xml);
    976. 

  976.         };
    977. 

  977.         foreach ($xml as $el) {
    978. 

  978.             if (preg_match('/^<([\w])+[^>\/]*>$/U', $el)) {
    979. 

  979.                 // opening tag, increase indent
    980. 

  980.                 $pretty[] = str_repeat(' ', $indent) . $el;
    981. 

  981.                 $indent += $level;
    982. 

  982.             } else {
    983. 

  983.                 if (preg_match('/^<\/.+>$/', $el)) {
    984. 

  984.                     // closing tag, decrease indent
    985. 

  985.                     $indent -= $level;
    986. 

  986.                 };
    987. 

  987.                 if ($indent<0) $indent = 0;
    988. 

  988.                 $pretty[] = str_repeat(' ', $indent) . $el;
    989. 

  989.             };
    990. 

  990.         };
    991. 

  991.         return implode("\n", $pretty);
    992. 

  992.     }
    993. 

  993. };
    994. 

  994. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
    995. 

  995. 

  996. /* - - - - - - - - - - - - - - - - - */
    997. 

  997. function get_currentpath() {
    998. 

  998.  global $area;
    999. 

  999.  global $curr_area;
    1000. 

  1000.  global $curr_lang;
    1001. 

  1001.  global $other_lang;
    1002. 

  1002.  global $string;
    1003. 

  1003. 

  1004.  $location = "";
    1005. 

  1005.  $prev_step = "";
    1006. 

  1006.  $steps = explode (".", $curr_area);
    1007. 

  1007.  foreach ($steps as $this_step) {
    1008. 

  1008.   if ($location != '') {
    1009. 

  1009.    $location .= ":";
    1010. 

  1010.    $prev_step .= ".";
    1011. 

  1011.   };
    1012. 

  1012.   if (stripos($area['url'][$prev_step.$this_step], '.php') !==FALSE) {
    1013. 

  1013.    $php_script = $area['url'][$prev_step.$this_step];
    1014. 

  1014.   } else {
    1015. 

  1015.    $php_script = 'index.php';
    1016. 

  1016.   };
    1017. 

  1017.   $prev_step .= $this_step;
    1018. 

  1018. 		$thisURL = DCTL_REQUEST_URI;
    1019. 

  1019. 		$thisURL = str_ireplace(basename($_SERVER['PHP_SELF']),$php_script,$thisURL);
    1020. 

  1020. 		$thisURL = str_ireplace('area='.$curr_area,'area='.$prev_step,$thisURL);
    1021. 

  1021. 	if (stripos($thisURL,'.php?') === false) {
    1022. 

  1022.    $thisURL = str_ireplace('.php', '.php?', $thisURL);
    1023. 

  1023.   };
    1024. 

  1024. 	if (XMLDB_PATH_BASE_TMP) {
    1025. 

  1025. 			if (stripos($thisURL,'temp=') === false) {
    1026. 

  1026. 				$thisURL .= "&amp;temp=true";
    1027. 

  1027. 			};
    1028. 

  1028. 		};
    1029. 

  1029.   $otherURL = str_ireplace('lang='.$curr_lang,'lang='.$other_lang,$thisURL);
    1030. 

  1030.   $location .= "<a href=\"".$thisURL."\" class=\"small\" title=\"".strtolower($area[$curr_lang][$prev_step])."\">".strtolower($area[$curr_lang][$prev_step])."</a>";
    1031. 

  1031.  };
    1032. 

  1032.  if ($curr_lang != $other_lang) {
    1033. 

  1033.   $location .= " <a href=\"".$otherURL."\" class=\"small\" title=\"".$string[$other_lang]['language_version']."\">";
    1034. 

  1034.   $location .= "(".strtoupper($other_lang).")</a>";
    1035. 

  1035.  } else {
    1036. 

  1036.   $location .= " ()";
    1037. 

  1037.  };
    1038. 

  1038.  return $location;
    1039. 

  1039. };
    1040. 

  1040. /* - - - - - - - - - - - - - - - - - */
    1041. 

  1041. 

  1042. /* - - - - - - - - - - - - - - - - - */
    1043. 

  1043. function wctl_loader(&$text_result, $f_content, $option="", $putBR=TRUE, $DEBUG=FALSE) {
    1044. 

  1044.  global $string;
    1045. 

  1045. 	$text_done = false;
    1046. 

  1046. 	if ($f_content != '') {
    1047. 

  1047. 		if (stripos($f_content, 'sitemap') !== false) {
    1048. 

  1048. 			global $area;
    1049. 

  1049. 			global $curr_area;
    1050. 

  1050. 			global $curr_lang;
    1051. 

  1051. 			$content = '';
    1052. 

  1052. 			$content .= '<?xml version="1.0" encoding="UTF-8" ?>';
    1053. 

  1053. 			$content .= '<!DOCTYPE wctl SYSTEM "'.DCTL_SITEMAP_DTDS.'">';
    1054. 

  1054. 			$content .= '<wctl>';
    1055. 

  1055. 			$content .= '<wctl_page>';
    1056. 

  1056. 			$content .= '<wctl_caption>'.$area[$curr_lang]['00'].'</wctl_caption>';
    1057. 

  1057. 			$content .= '<wctl_title>www.ctl.sns.it</wctl_title>';
    1058. 

  1058. 			$content .= '<wctl_summary />';
    1059. 

  1059. 			$content .= '<wctl_text>';
    1060. 

  1060. 			foreach($area[$curr_lang] as $key=>$what) {
    1061. 

  1061. 				if ($key != '00') {
    1062. 

  1062. 					$length = strlen($key);
    1063. 

  1063. 					$level = intval($length/2);
    1064. 

  1064. 					for ($i=1; $i<=$length; $i++) $content .= "&#160;";
    1065. 

  1065. 					$tag_b ='';
    1066. 

  1066. 					$tag_e ='';
    1067. 

  1067. 					// $what = ucwords($what);
    1068. 

  1068. 					switch ($level) {
    1069. 

  1069. 						case '1':
    1070. 

  1070. 							$tag_b ='<br /><strong>';
    1071. 

  1071. 							$tag_e ='</strong>';
    1072. 

  1072. 							break;
    1073. 

  1073. 						case '2':
    1074. 

  1074. 							$tag_b ='<em>';
    1075. 

  1075. 							$tag_e ='</em>';
    1076. 

  1076. 							break;
    1077. 

  1077. 						default:
    1078. 

  1078. 							$level = 0;
    1079. 

  1079. 							break;
    1080. 

  1080. 					};
    1081. 

  1081. 					$content .= $tag_b."<a href=\"".$_SERVER['PHP_SELF']."?lang=".$curr_lang."&amp;area=".$key."\" title=\"\">";
    1082. 

  1082. 					$content .= '<img src="'.DCTL_IMAGES.'map_l'.$level.'.gif" alt="(open level)" />'.$what.'</a>'.$tag_e.'<br />';
    1083. 

  1083. 				};
    1084. 

  1084. 			};
    1085. 

  1085. 			$content .= '</wctl_text>';
    1086. 

  1086. 			$content .= '<wctl_note />';
    1087. 

  1087. 			$content .= '<wctl_icon />';
    1088. 

  1088. 			$content .= '</wctl_page>';
    1089. 

  1089. 			$content .= '</wctl>';
    1090. 

  1090. 			$f_handle = fopen($f_content, "wb");
    1091. 

  1091. 			fwrite($f_handle, $content);
    1092. 

  1092. 			fclose($f_handle);
    1093. 

  1093. 			@chmod($f_content, CHMOD);
    1094. 

  1094. 		};
    1095. 

  1095. 		forceUTF8($f_content);
    1096. 

  1096.   if (!($xml = simplexml_load_file($f_content, 'SimpleXMLElement', DCTL_XML_LOADER))) {
    1097. 

  1097. 			$text_result .= "<b class='wctl_error'>".$f_content."</b> : not valid or couldn't open xml file...";
    1098. 

  1098. 			$text_done = false;
    1099. 

  1099. 		};
    1100. 

  1100. 		// hack to work around php 5.0's problems with default namespaces and xpath()
    1101. 

  1101. 		$xml['xmlns'] = '';
    1102. 

  1102. 		$htop = 16;
    1103. 

  1103. 		switch ($option) {
    1104. 

  1104. 			case CMS_VIEWMODE_PROJ: // PROGETTI
    1105. 

  1105. 				$text_result .=  '<div id="wctl_icon01"><img id="wctl_preview01" src="'.WEB_WCTL_ICONS.'camillo.gif" alt="(preview icon)" height="250" /></div>';
    1106. 

  1106. 				$text_result .=  "<div id=\"wctl_summary01\">&#160;</div>";
    1107. 

  1107. 				$text_result .=  '<a class="go_top" href="#top" title=""><img src="'.DCTL_IMAGES.'up.gif" alt="(go top icon)" height="'.$htop.'" /></a>';
    1108. 

  1108. 				break;
    1109. 

  1109. 			case CMS_VIEWMODE_LIST: // ATTIVITA
    1110. 

  1110. 				$text_result .=  '<a class="go_top" href="#top" title=""><img src="'.DCTL_IMAGES.'up.gif" alt="(go top icon)" height="'.$htop.'" /></a>';
    1111. 

  1111. 				break;
    1112. 

  1112. 			default: // PAGE
    1113. 

  1113. 				break;
    1114. 

  1114. 		};
    1115. 

  1115. 		if ($putBR) $text_result .=  '<br />';
    1116. 

  1116. 		$text_result .= wctl_loader_recurse ($option, $xml, '');
    1117. 

  1117. 		if ($putBR) $text_result .=  '<br />';
    1118. 

  1118.   $text_done = true;
    1119. 

  1119. 	};
    1120. 

  1120. 	return $text_done;
    1121. 

  1121. };
    1122. 

  1122. /* - - - - - - - - - - - - - - - - - */
    1123. 

  1123. 

  1124. /* - - - - - - - - - - - - - - - - - */
    1125. 

  1125. function wctl_loader_recurse ($option, $child, $name_father='') {
    1126. 

  1126.  global $curr_area;
    1127. 

  1127.  $text2parse = '';
    1128. 

  1128. 

  1129.  $icon = array();
    1130. 

  1130.  foreach($child->children() as $name=>$children) {
    1131. 

  1131. 		$id = $children['id'];
    1132. 

  1132.   switch ($option) {
    1133. 

  1133. 

  1134. 			case CMS_VIEWMODE_PROJ:
    1135. 

  1135. 				switch ($name) {
    1136. 

  1136. 					case 'wctl_list':
    1137. 

  1137. 						$text2parse .= "<div class=\"wctl_section01\">";
    1138. 

  1138. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1139. 

  1139. 						$text2parse .= "</div>";
    1140. 

  1140. 						break;
    1141. 

  1141. 					case 'wctl_head':
    1142. 

  1142. 						$text2parse .= "<div class=\"wctl_head01\">";
    1143. 

  1143. 						$text2parse .= node_copy ($children->asXML(), $name);
    1144. 

  1144. 						$text2parse .= "</div>";
    1145. 

  1145. 						break;
    1146. 

  1146. 					case 'wctl_item':
    1147. 

  1147. 						$text2parse .= "<div class=\"wctl_item01\">";
    1148. 

  1148. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1149. 

  1149. 						$text2parse .= "</div>";
    1150. 

  1150. 						break;
    1151. 

  1151. 					case 'wctl_title':
    1152. 

  1152. 						$title = node_copy ($children->asXML(), $name);
    1153. 

  1153. 						break;
    1154. 

  1154. 					case 'wctl_summary':
    1155. 

  1155. 						$summary = node_copy ($children->asXML(), $name);
    1156. 

  1156. 						break;
    1157. 

  1157. 					case 'wctl_icon':
    1158. 

  1158. 						if ($children !='') $icon = $children;
    1159. 

  1159. 						break;
    1160. 

  1160. 					case 'wctl_link':
    1161. 

  1161. 						$link = $children;
    1162. 

  1162. 						$text2parse .= "<div class=\"wctl_title01\">";
    1163. 

  1163. 						$text2parse .= "<a href=\"".$link."\" ";
    1164. 

  1164. 						$text2parse .= "onmouseover=\"javascript: document.getElementById('wctl_preview01').src='".WEB_WCTL_ICONS.$icon."'; ";
    1165. 

  1165. 						$text2parse .= "document.getElementById('wctl_summary01').firstChild.nodeValue='".makeSafeEntities($summary)."';\" ";
    1166. 

  1166. 						$text2parse .= "onmouseout=\"javascript:document.getElementById('wctl_preview01').src='".WEB_WCTL_ICONS."camillo.gif'; ";
    1167. 

  1167. 						$text2parse .= "document.getElementById('wctl_summary01').firstChild.nodeValue='&#160;';\" ";
    1168. 

  1168. 						$text2parse .= "title=\"".$icon."\">";
    1169. 

  1169. 						$text2parse .= $title;
    1170. 

  1170. 						$text2parse .= "</a>";
    1171. 

  1171. 						$text2parse .= "</div>";
    1172. 

  1172. 						break;
    1173. 

  1173. 					default:
    1174. 

  1174. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1175. 

  1175. 						break;
    1176. 

  1176. 				};
    1177. 

  1177. 				$text2parse .= "\n";
    1178. 

  1178. 				break;
    1179. 

  1179. 

  1180. 

  1181. 			case CMS_VIEWMODE_LIST:
    1182. 

  1182. 				switch ($name) {
    1183. 

  1183. 					case 'wctl_list':
    1184. 

  1184. 						$text2parse .= "<div ";
    1185. 

  1185. 						if ($id != '') $text2parse .= "id=\"".$id."\" ";
    1186. 

  1186. 							$text2parse .= "class=\"wctl_section02\">";
    1187. 

  1187. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1188. 

  1188. 						$text2parse .= "</div>";
    1189. 

  1189. 						break;
    1190. 

  1190. 					case 'wctl_head':
    1191. 

  1191. 						$text2parse .= "<div class=\"wctl_head02\">";
    1192. 

  1192. 						$text2parse .= node_copy ($children->asXML(), $name);
    1193. 

  1193. 						$text2parse .= "</div>";
    1194. 

  1194. 						break;
    1195. 

  1195. 					case 'wctl_item':
    1196. 

  1196. 						$text2parse .= "<div ";
    1197. 

  1197. 						if ($id != '') $text2parse .= "id=\"".$id."\" ";
    1198. 

  1198. 							$text2parse .= "class=\"wctl_item02\">";
    1199. 

  1199. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1200. 

  1200. 						$text2parse .= "</div>";
    1201. 

  1201. 						break;
    1202. 

  1202. 					case 'wctl_caption':
    1203. 

  1203. 						$caption = node_copy ($children->asXML(), $name);
    1204. 

  1204. 						break;
    1205. 

  1205. 					case 'wctl_title':
    1206. 

  1206. 						$title = node_copy ($children->asXML(), $name);
    1207. 

  1207. 						break;
    1208. 

  1208. 					case 'wctl_summary':
    1209. 

  1209. 						$summary = node_copy ($children->asXML(), $name);
    1210. 

  1210. 						break;
    1211. 

  1211. 					case 'wctl_text':
    1212. 

  1212. 						$text = node_copy ($children->asXML(), $name);
    1213. 

  1213. 						break;
    1214. 

  1214. 					case 'wctl_note':
    1215. 

  1215. 						$note = node_copy ($children->asXML(), $name);
    1216. 

  1216. 						break;
    1217. 

  1217. 					case 'wctl_icon':
    1218. 

  1218. 						if ($children !='') $icon[] = $children;
    1219. 

  1219. 						break;
    1220. 

  1220. 					case 'wctl_summary':
    1221. 

  1221. 						$summary = node_copy ($children->asXML(), $name);
    1222. 

  1222. 						break;
    1223. 

  1223. 					case 'wctl_link':
    1224. 

  1224. 						$link = node_copy ($children->asXML(), $name);
    1225. 

  1225. 						if ($caption!='') {
    1226. 

  1226. 							$text2parse .= "<div class=\"wctl_caption02\">";
    1227. 

  1227. 							$text2parse .= $caption;
    1228. 

  1228. 							$text2parse .= "</div>";
    1229. 

  1229. 						};
    1230. 

  1230. 						for ($ic=0; $ic<count($icon); $ic++) {
    1231. 

  1231. 							$text2parse .= "<div class=\"wctl_icon02\">";
    1232. 

  1232. 							$f_hires = str_ireplace("_pw","", $icon[$ic]);
    1233. 

  1233. 							if (is_file(WEB_WCTL_ICONS.$f_hires) && ($f_hires != $icon[$ic])) {
    1234. 

  1234. 								$text2parse .= "<a class=\"link_pop\" title=\"(open image in a new window)\"
    1235. 

  1235. href=\"".WEB_WCTL_ICONS.$f_hires."\">";
    1236. 

  1236. 							} else {
    1237. 

  1237. 								$f_hires = '';
    1238. 

  1238. 							};
    1239. 

  1239. 							$text2parse .= '<img src="'.WEB_WCTL_ICONS.$icon[$ic].'" alt="(preview)" />';
    1240. 

  1240. 							if ($f_hires) {
    1241. 

  1241. 								$text2parse .= "</a>";
    1242. 

  1242. 							};
    1243. 

  1243. 							$text2parse .= "</div>";
    1244. 

  1244. 						};
    1245. 

  1245. 						$text2parse .= "<div class=\"wctl_title02\">";
    1246. 

  1246. 						if ($children != '' ) {
    1247. 

  1247. 							$text2parse .= "<a class=\"link_int\" href=\"".$link."\" >";
    1248. 

  1248. 							$text2parse .= $title;
    1249. 

  1249. 							$text2parse .= "</a>";
    1250. 

  1250. 						} else {
    1251. 

  1251. 							$text2parse .= $title;
    1252. 

  1252. 						};
    1253. 

  1253. 						$text2parse .= "</div>";
    1254. 

  1254. 						if ($summary!='') {
    1255. 

  1255. 							$text2parse .= "<div class=\"wctl_summary02\">";
    1256. 

  1256. 							$text2parse .= $summary;
    1257. 

  1257. 							$text2parse .= "</div>";
    1258. 

  1258. 						};
    1259. 

  1259. 						if ($text!='') {
    1260. 

  1260. 							$text2parse .= "<div class=\"wctl_text02\">";
    1261. 

  1261. 							$text2parse .= $text;
    1262. 

  1262. 							$text2parse .= "</div>";
    1263. 

  1263. 						};
    1264. 

  1264. 						if ($note!='') {
    1265. 

  1265. 							$text2parse .= "<div class=\"wctl_note02\">";
    1266. 

  1266. 							$text2parse .= $note;
    1267. 

  1267. 							$text2parse .= "</div>";
    1268. 

  1268. 						};
    1269. 

  1269. 						break;
    1270. 

  1270. 					default:
    1271. 

  1271. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1272. 

  1272. 						break;
    1273. 

  1273. 				};
    1274. 

  1274. 				$text2parse .= "\n";
    1275. 

  1275. 				break;
    1276. 

  1276. 

  1277. 

  1278. 			case CMS_VIEWMODE_THUMB:
    1279. 

  1279. 				switch ($name) {
    1280. 

  1280. 					case 'wctl_list':
    1281. 

  1281. 						$text2parse .= "<div class=\"spacer\"> </div>";
    1282. 

  1282. 						$text2parse .= "<div ";
    1283. 

  1283. 						if ($id != '') $text2parse .= "id=\"".$id."\" ";
    1284. 

  1284. 							$text2parse .= "class=\"wctl_section03\">";
    1285. 

  1285. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1286. 

  1286. 						$text2parse .= "</div>";
    1287. 

  1287. 						$text2parse .= "<div class=\"spacer\"> </div>";
    1288. 

  1288. 						break;
    1289. 

  1289. 					case 'wctl_head':
    1290. 

  1290. 						$text2parse .= "<div class=\"wctl_head03\">";
    1291. 

  1291. 						$text2parse .= node_copy ($children->asXML(), $name);
    1292. 

  1292. 						$text2parse .= "</div>";
    1293. 

  1293. 						break;
    1294. 

  1294. 					case 'wctl_item':
    1295. 

  1295. 						$text2parse .= "<div ";
    1296. 

  1296. 						if ($id != '') $text2parse .= "id=\"".$id."\" ";
    1297. 

  1297. 							$text2parse .= "class=\"wctl_item03\">";
    1298. 

  1298. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1299. 

  1299. 						$text2parse .= "</div>";
    1300. 

  1300. 						break;
    1301. 

  1301. 					case 'wctl_caption':
    1302. 

  1302. 						$caption = node_copy ($children->asXML(), $name);
    1303. 

  1303. 						break;
    1304. 

  1304. 					case 'wctl_icon':
    1305. 

  1305. 						if ($children !='') $icon[] = $children;
    1306. 

  1306. 						break;
    1307. 

  1307. 					case 'wctl_link':
    1308. 

  1308. 						$link = node_copy ($children->asXML(), $name);
    1309. 

  1309. 						for ($ic=0; $ic<count($icon); $ic++) {
    1310. 

  1310. 							$text2parse .= "<div class=\"wctl_icon03\">";
    1311. 

  1311. 							$f_hires = str_ireplace("_pw","", $icon[$ic]);
    1312. 

  1312. 							if (is_file(WEB_WCTL_ICONS.$f_hires) && ($f_hires != $icon[$ic])) {
    1313. 

  1313. 								$text2parse .= "<a class=\"link_pop\" title=\"(open image in a new window)\"
    1314. 

  1314. href=\"".WEB_WCTL_ICONS.$f_hires."\">";
    1315. 

  1315. 							} else {
    1316. 

  1316. 								$f_hires = '';
    1317. 

  1317. 							};
    1318. 

  1318. 							$text2parse .= '<img src="'.WEB_WCTL_ICONS.$icon[$ic].'" alt="(preview)" />';
    1319. 

  1319. 							if ($f_hires) {
    1320. 

  1320. 								$text2parse .= "</a>";
    1321. 

  1321. 							};
    1322. 

  1322. 							$text2parse .= "<br /><span class=\"wctl_caption03\">";
    1323. 

  1323. 							$text2parse .= $caption;
    1324. 

  1324. 							$text2parse .= "</span>";
    1325. 

  1325. 						};
    1326. 

  1326. 						$text2parse .= "</div>";
    1327. 

  1327. 						break;
    1328. 

  1328. 					default:
    1329. 

  1329. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1330. 

  1330. 						break;
    1331. 

  1331. 				};
    1332. 

  1332. 				$text2parse .= "\n";
    1333. 

  1333. 				break;
    1334. 

  1334. 

  1335. 

  1336.    case CMS_VIEWMODE_PAGE: // PAGE
    1337. 

  1337. 				switch ($name) {
    1338. 

  1338. 					case 'wctl_page':
    1339. 

  1339. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1340. 

  1340. 						break;
    1341. 

  1341. 					case 'wctl_caption':
    1342. 

  1342. 						if ($children) {
    1343. 

  1343. 							$text2parse .= "<div class=\"wctl_caption99\">";
    1344. 

  1344. 							$text2parse .= node_copy ($children->asXML(), $name);
    1345. 

  1345. 							$text2parse .= "</div>";
    1346. 

  1346. 						};
    1347. 

  1347. 						break;
    1348. 

  1348. 					case 'wctl_title':
    1349. 

  1349. 						if ($children) {
    1350. 

  1350. 							$text2parse .= "<div class=\"wctl_title99\">";
    1351. 

  1351. 							$text2parse .= node_copy ($children->asXML(), $name);
    1352. 

  1352. 							$text2parse .= "</div>";
    1353. 

  1353. 						};
    1354. 

  1354. 						break;
    1355. 

  1355. 					case 'wctl_summary':
    1356. 

  1356. 						if ($children) {
    1357. 

  1357. 							$text2parse .= "<div class=\"wctl_summary99\">";
    1358. 

  1358. 							$text2parse .= node_copy ($children->asXML(), $name);
    1359. 

  1359. 							$text2parse .= "</div>";
    1360. 

  1360. 						};
    1361. 

  1361. 						break;
    1362. 

  1362. 					case 'wctl_text':
    1363. 

  1363. 						$text = node_copy ($children->asXML(), $name);
    1364. 

  1364. 						break;
    1365. 

  1365. 					case 'wctl_note':
    1366. 

  1366. 						$note = "";
    1367. 

  1367. 						if ($children) {
    1368. 

  1368. 							$note = node_copy ($children->asXML(), $name);
    1369. 

  1369. 						};
    1370. 

  1370. 						break;
    1371. 

  1371. 					case 'wctl_icon':
    1372. 

  1372. 						if ($children) {
    1373. 

  1373. 							$text2parse .= '<div class="wctl_icon99"><img src="'.WEB_WCTL_ICONS.$children.'" alt="(preview)" />';
    1374. 

  1374. 							$text2parse .= "</div>";
    1375. 

  1375. 						};
    1376. 

  1376. 						if ($text != '') {
    1377. 

  1377. 							$text2parse .= "<div class=\"wctl_text99\">";
    1378. 

  1378. 							$text2parse .= $text;
    1379. 

  1379. 							$text2parse .= "</div>";
    1380. 

  1380. 						};
    1381. 

  1381. 						if ($note != '') {
    1382. 

  1382. 							$text2parse .= "<div class=\"wctl_note99\">";
    1383. 

  1383. 							$text2parse .= $note;
    1384. 

  1384. 							$text2parse .= "</div>";
    1385. 

  1385. 						};
    1386. 

  1386. 						break;
    1387. 

  1387. 				};
    1388. 

  1388. 				$text2parse .= "\n";
    1389. 

  1389. 				break;
    1390. 

  1390. 

  1391. 

  1392.    case CMS_VIEWMODE_NEWS: // BACHECA
    1393. 

  1393. 				switch ($name) {
    1394. 

  1394. 					case 'wctl_list':
    1395. 

  1395. 						$text2parse .= "<div ";
    1396. 

  1396. 						if ($id != '') $text2parse .= "id=\"".$id."\" ";
    1397. 

  1397. 							$text2parse .= "class=\"wctl_section04\">";
    1398. 

  1398. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1399. 

  1399. 						$text2parse .= "</div>";
    1400. 

  1400. 						break;
    1401. 

  1401. 					case 'wctl_head':
    1402. 

  1402. 						$text2parse .= "<div class=\"wctl_head04\">";
    1403. 

  1403. 						$text2parse .= node_copy ($children->asXML(), $name);
    1404. 

  1404. 						$text2parse .= "</div>";
    1405. 

  1405. 						break;
    1406. 

  1406. 					case 'wctl_item':
    1407. 

  1407. 						$text2parse .= "<div ";
    1408. 

  1408. 						if ($id != '') {
    1409. 

  1409. 							switch ($id)  {
    1410. 

  1410. 								case 'drag01':
    1411. 

  1411. 									$text2parse .= "style=\"position:relative;top:0px;left:50px;\" ";
    1412. 

  1412. 									break;
    1413. 

  1413. 								case 'drag02':
    1414. 

  1414. 									$text2parse .= "style=\"position:relative;top:-130px;left:320px;\" ";
    1415. 

  1415. 									break;
    1416. 

  1416. 								case 'drag03':
    1417. 

  1417. 									$text2parse .= "style=\"position:relative;top:-200px;left:20px;\" ";
    1418. 

  1418. 									break;
    1419. 

  1419. 								case 'drag04':
    1420. 

  1420. 									$text2parse .= "style=\"position:relative;top:-350px;left:280px;\" ";
    1421. 

  1421. 									break;
    1422. 

  1422. 								case 'drag05':
    1423. 

  1423. 									$text2parse .= "style=\"position:relative;top:-400px;left:50px;\" ";
    1424. 

  1424. 									break;
    1425. 

  1425. 								case 'drag06':
    1426. 

  1426. 									$text2parse .= "style=\"position:relative;top:-550px;left:320px;\" ";
    1427. 

  1427. 									break;
    1428. 

  1428. 							};
    1429. 

  1429. 							if ($id != '') $text2parse .= "id=\"".$id."\" ";
    1430. 

  1430. 							$text2parse .= "class=\"wctl_item04_drag\">";
    1431. 

  1431. 						} else {
    1432. 

  1432. 							if ($id != '') $text2parse .= "id=\"".$id."\" ";
    1433. 

  1433. 							$text2parse .= "class=\"wctl_item02\">";
    1434. 

  1434. 						};
    1435. 

  1435. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1436. 

  1436. 						$text2parse .= "</div>";
    1437. 

  1437. 						break;
    1438. 

  1438. 					case 'wctl_title':
    1439. 

  1439. 						$title = node_copy ($children->asXML(), $name);
    1440. 

  1440. 						break;
    1441. 

  1441. 					case 'wctl_text':
    1442. 

  1442. 						$text = node_copy ($children->asXML(), $name);
    1443. 

  1443. 						break;
    1444. 

  1444. 					case 'wctl_link':
    1445. 

  1445. 						$link = node_copy ($children->asXML(), $name);
    1446. 

  1446. 						$text2parse .= "<div class=\"wctl_title04\">";
    1447. 

  1447. 						if ($children != '' ) {
    1448. 

  1448. 							$text2parse .= "<a class=\"link_int\" href=\"".$link."\" >";
    1449. 

  1449. 							$text2parse .= $title;
    1450. 

  1450. 							$text2parse .= "</a>";
    1451. 

  1451. 						} else {
    1452. 

  1452. 							$text2parse .= $title;
    1453. 

  1453. 						};
    1454. 

  1454. 						$text2parse .= "<div class=\"wctl_text04\">";
    1455. 

  1455. 						$text2parse .= $text;
    1456. 

  1456. 						$text2parse .= "</div>";
    1457. 

  1457. 						$text2parse .= "</div>";
    1458. 

  1458. 						break;
    1459. 

  1459. 					default:
    1460. 

  1460. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1461. 

  1461. 						break;
    1462. 

  1462. 				};
    1463. 

  1463. 				$text2parse .= "\n";
    1464. 

  1464. 				break;
    1465. 

  1465. 

  1466. 

  1467.    default: // ...
    1468. 

  1468. 				switch ($name) {
    1469. 

  1469. 					case 'wctl_list':
    1470. 

  1470. 						$text2parse .= "<div class=\"wctl_section\">";
    1471. 

  1471. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1472. 

  1472. 						$text2parse .= "</div>";
    1473. 

  1473. 						break;
    1474. 

  1474. 					case 'wctl_head':
    1475. 

  1475. 						$text2parse .= "<div class=\"wctl_head\">";
    1476. 

  1476. 						$text2parse .= node_copy ($children->asXML(), $name);
    1477. 

  1477. 						$text2parse .= "</div>";
    1478. 

  1478. 						break;
    1479. 

  1479. 					case 'wctl_item':
    1480. 

  1480. 						$text2parse .= "<div class=\"wctl_item\">";
    1481. 

  1481. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1482. 

  1482. 						$text2parse .= "</div>";
    1483. 

  1483. 						break;
    1484. 

  1484. 					case 'wctl_title':
    1485. 

  1485. 						$text2parse .= "<div class=\"wctl_title\">";
    1486. 

  1486. 						$text2parse .= node_copy ($children->asXML(), $name);
    1487. 

  1487. 						$text2parse .= "</div>";
    1488. 

  1488. 						break;
    1489. 

  1489. 					case 'wctl_summary':
    1490. 

  1490. 						$text2parse .= "<div class=\"wctl_summary\">";
    1491. 

  1491. 						$text2parse .= node_copy ($children->asXML(), $name);
    1492. 

  1492. 						$text2parse .= "</div>";
    1493. 

  1493. 						break;
    1494. 

  1494. 					case 'wctl_text':
    1495. 

  1495. 						$text2parse .= "<div class=\"wctl_text\">";
    1496. 

  1496. 						$text2parse .= node_copy ($children->asXML(), $name);
    1497. 

  1497. 						$text2parse .= "</div>";
    1498. 

  1498. 						break;
    1499. 

  1499. 					case 'wctl_note':
    1500. 

  1500. 						$text2parse .= "<div class=\"wctl_note\">";
    1501. 

  1501. 						$text2parse .= node_copy ($children->asXML(), $name);
    1502. 

  1502. 						$text2parse .= "</div>";
    1503. 

  1503. 						break;
    1504. 

  1504. 					case 'wctl_icon':
    1505. 

  1505. 						if ($children !='') $text2parse .= '<div class="wctl_icon"><img src="'.WEB_WCTL_ICONS.$children.'" alt="(preview)" />';
    1506. 

  1506. 						$text2parse .= "</div>";
    1507. 

  1507. 						break;
    1508. 

  1508. 					case 'wctl_link':
    1509. 

  1509. 						$text2parse .= "<a href=\"".$children."\">";
    1510. 

  1510. 						$text2parse .= "&gt;&gt;";
    1511. 

  1511. 						$text2parse .= "</a>";
    1512. 

  1512. 						break;
    1513. 

  1513. 					case 'wctl_page':
    1514. 

  1514. 						$text2parse .= wctl_loader_recurse ($option, $children, $name);
    1515. 

  1515. 						break;
    1516. 

  1516. 					default:
    1517. 

  1517. 						wctl_loader_recurse ($option, $children, $name);
    1518. 

  1518. 						break;
    1519. 

  1519. 				};
    1520. 

  1520. 				$text2parse .= "\n";
    1521. 

  1521. 				break;
    1522. 

  1522. 

  1523. 		};
    1524. 

  1524. 	};
    1525. 

  1525. 	return parse_command($text2parse);
    1526. 

  1526. };
    1527. 

  1527. /*           */
    1528. 

  1528. 

  1529. 

  1530. /* - - - - - - - - - - - - - - - - - */
    1531. 

  1531. function array_multi_search($p_needle, $p_haystack) {
    1532. 

  1532. 	if (! is_array ($p_haystack)) {
    1533. 

  1533. 		return false;
    1534. 

  1534. 	};
    1535. 

  1535. 	$key = array_search ($p_needle, $p_haystack) ;
    1536. 

  1536. 	if (! ($key === false)) {
    1537. 

  1537. 		return $key;
    1538. 

  1538. 	};
    1539. 

  1539. 	foreach ($p_haystack as $row) {
    1540. 

  1540. 		$key = array_multi_search ($p_needle, $row);
    1541. 

  1541. 		if (! ($key === false)) {
    1542. 

  1542. 			return $key;
    1543. 

  1543. 		};
    1544. 

  1544. 	};
    1545. 

  1545. 	return false;
    1546. 

  1546. };
    1547. 

  1547. /* - - - - - - - - - - - - - - - - - */
    1548. 

  1548. 

  1549. /* - - - - - - - - - - - - - - - - - */
    1550. 

  1550. function array_multi_search_getKey($p_needle, $p_haystack, $key1=0) {
    1551. 

  1551. 	if (! is_array ($p_haystack)) {
    1552. 

  1552. 		return false;
    1553. 

  1553. 	};
    1554. 

  1554. 	$key = array_search ($p_needle, $p_haystack) ;
    1555. 

  1555. 	if ($key !== false) {
    1556. 

  1556. 		return $key1;
    1557. 

  1557. 	};
    1558. 

  1558. 	foreach ($p_haystack as $key1=>$row) {
    1559. 

  1559. 		$key = array_multi_search_getKey ($p_needle, $row, $key1);
    1560. 

  1560. 		if ($key !== false) {
    1561. 

  1561. 			return $key1;
    1562. 

  1562. 		};
    1563. 

  1563. 	};
    1564. 

  1564. 	return false;
    1565. 

  1565. };
    1566. 

  1566. /* - - - - - - - - - - - - - - - - - */
    1567. 

  1567. 

  1568. 

  1569. /* - - - - - - - - - - - - - - - - - */
    1570. 

  1570. function parse_command ($text2parse) {
    1571. 

  1571.  global $area;
    1572. 

  1572.  global $area_c;
    1573. 

  1573.  global $area_a;
    1574. 

  1574.  global $area;
    1575. 

  1575.  global $curr_area;
    1576. 

  1576.  global $curr_lang;
    1577. 

  1577.  global $string;
    1578. 

  1578.  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    1579. 

  1579.  do {
    1580. 

  1580.   $PHP_SELF = $_SERVER['PHP_SELF'];
    1581. 

  1581.   $has_command1 = stripos($text2parse, '$[');
    1582. 

  1582. if ($has_command1 !== false) {
    1583. 

  1583. 	$has_command2 = stripos($text2parse, ']$');
    1584. 

  1584. if ($has_command2 !== false) {
    1585. 

  1585. 	$token = substr($text2parse, $has_command1, $has_command2-$has_command1+2);
    1586. 

  1586. 	$what = substr($token,2,strlen($token)-4);
    1587. 

  1587. 	$prefix0 = explode(':', $what);
    1588. 

  1588. 	$what = $prefix0[count($prefix0)-1];
    1589. 

  1589. 	$prefix = $prefix0[0];
    1590. 

  1590. 	if ($prefix != $what) {
    1591. 

  1591. 		$prev_prefix = basename(dirname($PHP_SELF));
    1592. 

  1592. 		$PHP_SELF = str_ireplace($prev_prefix.SYS_PATH_SEP, $prefix.SYS_PATH_SEP, $PHP_SELF);
    1593. 

  1593. 		require_once(str_replace(SYS_PATH_SEP_DOUBLE,SYS_PATH_SEP,dirname(__FILE__).SYS_PATH_SEP).DCTL_DATA_PATH.$prefix.SYS_PATH_SEP.'config.inc.php');
    1594. 

  1594. 		switch ($prefix) {
    1595. 

  1595. 			case WEB_WCTL_NAME:
    1596. 

  1596. 				$key = array_multi_search ($what, $area_c);
    1597. 

  1597. 				break;
    1598. 

  1598. 			case WEB_DCTL_NAME:
    1599. 

  1599. 				$key = array_multi_search ($what, $area_a);
    1600. 

  1600. 				break;
    1601. 

  1601. 		};
    1602. 

  1602. 	} else {
    1603. 

  1603. 		$key = array_multi_search ($what, $area);
    1604. 

  1604. 	};
    1605. 

  1605. 	if (!(stripos($what, '.php')) === false) {
    1606. 

  1606. 		$replace = $what;
    1607. 

  1607. 	} else {
    1608. 

  1608. 		$replace = $PHP_SELF;
    1609. 

  1609. 	};
    1610. 

  1610. 	$replace .= "?lang=".$curr_lang."&amp;area=".$key;
    1611. 

  1611. 	if (XMLDB_PATH_BASE_TMP) {
    1612. 

  1612. 		$replace .= "&amp;temp=true";
    1613. 

  1613. 	};
    1614. 

  1614. 	$text2parse = str_replace($token, $replace, $text2parse);
    1615. 

  1615. };
    1616. 

  1616.   };
    1617. 

  1617.  } while ($has_command1 && $has_command2);
    1618. 

  1618. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    1619. 

  1619. do {
    1620. 

  1620. 	$has_command1 = stripos($text2parse, '${');
    1621. 

  1621. if (!($has_command1 === false)) {
    1622. 

  1622. 	$has_command2 = stripos($text2parse, '}$');
    1623. 

  1623. if (!($has_command2 === false)) {
    1624. 

  1624. 	$token = substr($text2parse, $has_command1, $has_command2-$has_command1+2);
    1625. 

  1625. 	$what = substr($token,2,strlen($token)-4);
    1626. 

  1626. 	$replace = '';
    1627. 

  1627. 	switch ($what) {
    1628. 

  1628. 		case 'newsletter':
    1629. 

  1629. 			$email = '';
    1630. 

  1630. 			if (isSet($_REQUEST['email'])) {
    1631. 

  1631. 				$email = $_REQUEST['email'];
    1632. 

  1632. 			};
    1633. 

  1633. 			if (!(stripos($email, '@')) === false) {
    1634. 

  1634. 				require_once(str_replace('//','/',dirname(__FILE__).'/').'../_shared'.SYS_PATH_SEP.'config.inc.php');
    1635. 

  1635. 				require_once(str_replace(SYS_PATH_SEP_DOUBLE, SYS_PATH_SEP, dirname(__FILE__).SYS_PATH_SEP).'./config.inc.php');
    1636. 

  1636. 				$connection = dctl_sql_connect(WEB_NEWSLETTER);
    1637. 

  1637. 				if ($connection) {
    1638. 

  1638. 					$email = addslashes($email);
    1639. 

  1639. 					$email = trim($email);
    1640. 

  1640. 					$query = "SELECT * FROM news_address WHERE email = '$email'";
    1641. 

  1641. 					$result = mysql_query($query);
    1642. 

  1642. 					if (mysql_num_rows($result) != false) {
    1643. 

  1643. 						$replace .= "<br /><strong class=\"thankyou\">".$string[$curr_lang]['mail_yetrecorded']." (".$email.")...</strong>";
    1644. 

  1644. 					} else {
    1645. 

  1645. 						$query = "INSERT INTO news_address (id, email) VALUES (NULL, '$email')";
    1646. 

  1646. 						$result = mysql_query($query);
    1647. 

  1647. 						if (mysql_affected_rows() == 1) {
    1648. 

  1648. 							$replace .= "<br /><strong class=\"thankyou\">".$string[$curr_lang]['mail_ok']."...</strong>";
    1649. 

  1649. 						} else {
    1650. 

  1650. 							$replace .= "<br /><strong class=\"thankyou\">".$string[$curr_lang]['mail_not']." (".$email.")...</strong>";
    1651. 

  1651. 						};
    1652. 

  1652. 					};
    1653. 

  1653. 					mysql_close($connection);
    1654. 

  1654. 				} else {
    1655. 

  1655. 					$replace .= "<br /><strong class=\"thankyou\">".$string[$curr_lang]['mail_nosrv']."...</strong></em>";
    1656. 

  1656. 				};
    1657. 

  1657. 			} else {
    1658. 

  1658. 				$replace .= '<form id="newsletter" action="'.$_SERVER['PHP_SELF'].'" method="'.DCTL_FORM_METHOD.'" enctype="'.DCTL_FORM_ENCTYPE.'">';
    1659. 

  1659. 				$replace .= "<fieldset>";
    1660. 

  1660. 				$replace .= "<input class=\"small\" type=\"text\" size=\"20\" name=\"email\" value=\"(e-mail)\" />";
    1661. 

  1661. 				$replace .= "<label class=\"small\">";
    1662. 

  1662. 				$replace .= "<a class=\"small\" href=\"javascript:submitform('newsletter');\"> -&gt; ".$string[$curr_lang]['mail_sign']."</a>";
    1663. 

  1663. 				$replace .= "</label>";
    1664. 

  1664. 				$replace .= "<input type=\"hidden\" name=\"area\" value=\"".$curr_area."\" />";
    1665. 

  1665. 				$replace .= "<input type=\"hidden\" name=\"lang\" value=\"".$curr_lang."\" />";
    1666. 

  1666. 				$replace .= "</fieldset></form>";
    1667. 

  1667. 			};
    1668. 

  1668. 			break;
    1669. 

  1669. 	};
    1670. 

  1670. 	$text2parse = str_replace($token, $replace, $text2parse);
    1671. 

  1671. };
    1672. 

  1672.    };
    1673. 

  1673.  } while ($has_command1 && $has_command2);
    1674. 

  1674. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    1675. 

  1675. return $text2parse;
    1676. 

  1676. };
    1677. 

  1677. /* - - - - - - - - - - - - - - - - - */
    1678. 

  1678. 

  1679. 

  1680. /* - - - - - - - - - - - - - - - - - */
    1681. 

  1681. function node_copy ($value, $strip) {
    1682. 

  1682.  $strip_s = "<".$strip.">";
    1683. 

  1683.  $strip_e1 = "<".$strip."/>";
    1684. 

  1684.  $strip_e2 = "<".$strip." />";
    1685. 

  1685.  $strip_e3 = "</".$strip.">";
    1686. 

  1686.  $strip_e4 = "</ ".$strip.">";
    1687. 

  1687.  $text = $value;
    1688. 

  1688.  $text = str_ireplace($strip_s, "", $text);
    1689. 

  1689.  $text = str_ireplace($strip_e1, "", $text);
    1690. 

  1690.  $text = str_ireplace($strip_e2, "", $text);
    1691. 

  1691.  $text = str_ireplace($strip_e3, "", $text);
    1692. 

  1692.  $text = str_ireplace($strip_e4, "", $text);
    1693. 

  1693.  return $text;
    1694. 

  1694. };
    1695. 

  1695. /* - - - - - - - - - - - - - - - - - */
    1696. 

  1696. 

  1697. /* - - - - - - - - - - - - - - - - - */
    1698. 

  1698. // Convert str to UTF-8 (if not already), then convert to HTML numbered decimal entities.
    1699. 

  1699. // If selected, it first converts any illegal chars to safe named (and numbered) entities
    1700. 

  1700. // as in makeSafeEntities(). Unlike mb_convert_encoding(), mb_encode_numericentity() will
    1701. 

  1701. // NOT skip any already existing entities in the string, so use a regex to skip them.
    1702. 

  1702. function makeAllEntities($str, $useNamedEntities = 0, $encoding = "") {
    1703. 

  1703. 	if (is_array($str)) {
    1704. 

  1704. 		foreach ($str as $s)
    1705. 

  1705. 		$arrOutput[] = makeAllEntities($s,$encoding);
    1706. 

  1706. 		return $arrOutput;
    1707. 

  1707. 	}
    1708. 

  1708. 	else if (strlen($str)>0) {
    1709. 

  1709. 		$str = makeUTF8($str,$encoding);
    1710. 

  1710. 		if ($useNamedEntities)
    1711. 

  1711. 			$str = mb_convert_encoding($str,"HTML-ENTITIES","UTF-8");
    1712. 

  1712. 		$str = makeTagEntities($str,$useNamedEntities);
    1713. 

  1713. 		// Fix backslashes so they don't screw up following mb_ereg_replace
    1714. 

  1714. 		// Single quotes are fixed by makeTagEntities() above
    1715. 

  1715. 		$str = mb_ereg_replace('\\\\',"&#92;", $str);
    1716. 

  1716. 		mb_regex_encoding("UTF-8");
    1717. 

  1717. 		$str = mb_ereg_replace("(?>(&(?:[a-z]{0,4}\w{2,3};|#\d{2,5};)))|(\S+?)",
    1718. 

  1718.                          "'\\1'.mb_encode_numericentity('\\2',array(0x0,0x2FFFF,0,0xFFFF),'UTF-8')", $str, "ime");
    1719. 

  1719. 		$str = correctIllegalEntities($str);
    1720. 

  1720. 		return $str;
    1721. 

  1721. 	}
    1722. 

  1722. }
    1723. 

  1723. /* - - - - - - - - - - - - - - - - - */
    1724. 

  1724. 

  1725. /* - - - - - - - - - - - - - - - - - */
    1726. 

  1726. // Convert common characters to named or numbered entities
    1727. 

  1727. function makeTagEntities($str, $useNamedEntities = 1) {
    1728. 

  1728. 	// Note that we should use &apos; for the single quote, but IE doesn't like it
    1729. 

  1729. 	$arrReplace = $useNamedEntities ? array('&#39;','&quot;','&lt;','&gt;') : array('&#39;','&#34;','&#60;','&#62;');
    1730. 

  1730. 	return str_replace(array("'",'"','<','>'), $arrReplace, $str);
    1731. 

  1731. }
    1732. 

  1732. /* - - - - - - - - - - - - - - - - - */
    1733. 

  1733. 

  1734. /* - - - - - - - - - - - - - - - - - */
    1735. 

  1735. function fixID ($n_string) {
    1736. 

  1736.  $n_string = preg_replace('/[^a-zA-Z0-9_\-]/', '', $n_string);// remove all unwanted chars
    1737. 

  1737.  return trim($n_string);
    1738. 

  1738. 

  1739. };
    1740. 

  1740. /* - - - - - - - - - - - - - - - - - */
    1741. 

  1741. /* - - - - - - - - - - - - - - - - - */
    1742. 

  1742. /**
    1743. 

  1743. * Perform a simple text replace
    1744. 

  1744. 	* This should be used when the string does not contain HTML
    1745. 

  1745. 	* (off by default)
    1746. 

  1746. 	*/
    1747. 

  1747. define('STR_HIGHLIGHT_SIMPLE', 1);
    1748. 

  1748. 

  1749. /**
    1750. 

  1750. * Only match whole words in the string
    1751. 

  1751. 	* (off by default)
    1752. 

  1752. 	*/
    1753. 

  1753. define('STR_HIGHLIGHT_WHOLEWD', 2);
    1754. 

  1754. 

  1755. /**
    1756. 

  1756. * Case sensitive matching
    1757. 

  1757. 	* (off by default)
    1758. 

  1758. 	*/
    1759. 

  1759. define('STR_HIGHLIGHT_CASESENS', 4);
    1760. 

  1760. 

  1761. /**
    1762. 

  1762. * Overwrite links if matched
    1763. 

  1763. 	* This should be used when the replacement string is a link
    1764. 

  1764. 	* (off by default)
    1765. 

  1765. 	*/
    1766. 

  1766. define('STR_HIGHLIGHT_STRIPLINKS', 8);
    1767. 

  1767. 

  1768. /**
    1769. 

  1769. * Highlight a string in text without corrupting HTML tags
    1770. 

  1770. 	*
    1771. 

  1771. 	* @author      Aidan Lister <aidan@php.net>
    1772. 

  1772. 	* @version     3.1.1
    1773. 

  1773. 	* @link        http://aidanlister.com/repos/v/function.str_highlight.php
    1774. 

  1774. 	* @param       string          $text           Haystack - The text to search
    1775. 

  1775. 	* @param       array|string    $needle         Needle - The string to highlight
    1776. 

  1776. 	* @param       bool            $options        Bitwise set of options
    1777. 

  1777. 	* @param       array           $highlight      Replacement string
    1778. 

  1778. 	* @return      Text with needle highlighted
    1779. 

  1779. 	*/
    1780. 

  1780. function str_highlight($text, $needle, $options = null, $highlight = null, $start = "<strong>", $end = "</strong>", &$refs) {
    1781. 

  1781.  $text = preg_replace('/'.WS.''.WS.'+/', ' ', $text);
    1782. 

  1782.  $refs = array();
    1783. 

  1783.  // Default highlighting
    1784. 

  1784.  if ($highlight === null) {
    1785. 

  1785.   $highlight = $start.'\1'.$end;
    1786. 

  1786.  }
    1787. 

  1787.  // Select pattern to use
    1788. 

  1788.  if ($options & STR_HIGHLIGHT_SIMPLE) {
    1789. 

  1789.   $pattern = '#(%s)#';
    1790. 

  1790.   $sl_pattern = '#(%s)#';
    1791. 

  1791.  } else {
    1792. 

  1792.   $pattern = '#(?!<.*?)(%s)(?![^<>]*?>)#';
    1793. 

  1793.   $sl_pattern = '#<a'.WS.'(?:.*?)>(%s)</a>#';
    1794. 

  1794.  }
    1795. 

  1795.  // Case sensitivity
    1796. 

  1796.  if (!($options & STR_HIGHLIGHT_CASESENS)) {
    1797. 

  1797.   $pattern .= 'i';
    1798. 

  1798.   $sl_pattern .= 'i';
    1799. 

  1799.  }
    1800. 

  1800.  $needle = $needle;
    1801. 

  1801.  foreach ($needle as $needle_s) {
    1802. 

  1802.   $needle_s = preg_quote($needle_s);
    1803. 

  1803.   // Escape needle with optional whole word check
    1804. 

  1804.   if ($options & STR_HIGHLIGHT_WHOLEWD) {
    1805. 

  1805.    $needle_s = '\b' . $needle_s . '\b';
    1806. 

  1806.   }
    1807. 

  1807.   // Strip links
    1808. 

  1808.   if ($options & STR_HIGHLIGHT_STRIPLINKS) {
    1809. 

  1809.    $sl_regex = sprintf($sl_pattern, $needle_s);
    1810. 

  1810.    $text = preg_replace($sl_regex, '\1', $text);
    1811. 

  1811.   }
    1812. 

  1812.   $regex = sprintf($pattern, $needle_s);
    1813. 

  1813.   $highlight2 = $highlight;
    1814. 

  1814.   $highlight2 = str_ireplace('_TITLE_', $needle_s, $highlight2);
    1815. 

  1815.   $text = preg_replace($regex, $highlight2, $text);
    1816. 

  1816.   while (stripos($text, '_ID_') !== FALSE) {
    1817. 

  1817.    $thisID = 'H-'.md5(uniqid(rand(), true));
    1818. 

  1818.    $text = preg_replace('/_ID_/', fixID($thisID), $text, 1);
    1819. 

  1819.    $refs[$needle_s][] = $thisID;
    1820. 

  1820.   };
    1821. 

  1821. 	}
    1822. 

  1822.  return $text;
    1823. 

  1823. }
    1824. 

  1824. /* - - - - - - - - - - - - - - - - - */
    1825. 

  1825. 

  1826. /* - - - - - - - - - - - - - - - - - */
    1827. 

  1827. function replaceValueInURLajax ($theItem, $theNext, $theAnchor='') {
    1828. 

  1828. 	$URLs['doc'] = $_REQUEST['doc'];
    1829. 

  1829. 	$URLs[$theItem] = $theNext;
    1830. 

  1830.  return http_build_query($URLs);
    1831. 

  1831. };
    1832. 

  1832. /* - - - - - - - - - - - - - - - - - */
    1833. 

  1833. /* - - - - - - - - - - - - - - - - - */
    1834. 

  1834. function replaceValueInURL ($theURL, $theItem, $theNext, $theAnchor='') {
    1835. 

  1835. if(true) {
    1836. 

  1836.  return ($theURL);
    1837. 

  1837. } else {
    1838. 

  1838. if (DVLP_USE_PAGINATION) {
    1839. 

  1839. 		$params0 = explode('&',$theURL);
    1840. 

  1840. 

  1841. 		$params = preg_grep('/'.$theItem.'=(.*)/', $params0, PREG_GREP_INVERT);
    1842. 

  1842. 

  1843.  		$params[] = $theItem.'='.$theNext;
    1844. 

  1844. 

  1845.  		$params[] = 'posx='.$theAnchor;
    1846. 

  1846. 

  1847. 		$thisURL = implode('&',$params);
    1848. 

  1848. 		$load = array_values(preg_grep('/doc=(.*)/', $params));
    1849. 

  1849.   $load2 = str_ireplace(XMLDB_PATH_BASE, '', $load[0]);
    1850. 

  1850. 		$load2 = str_ireplace('doc=','',$load2);
    1851. 

  1851. 

  1852. 		$collection_id = dirname($load2);
    1853. 

  1853. 		$package_id = str_ireplace('.xml', '', basename($load2));
    1854. 

  1854. 

  1855. 		$result = '';
    1856. 

  1856. 		$result .='javascript: indexAjax(\'load_package\', \''.DCTL_EXPLORER_1.'\', \''.$collection_id.'\', \''.$package_id.'\'';
    1857. 

  1857. 

  1858. 		$result .=', \'url='.$theNext.SYS_PATH_SEP.$theAnchor.'\'';
    1859. 

  1859. 

  1860. 		foreach ($params as $param) {
    1861. 

  1861. 			$result .= ', \''.$param.'\'';
    1862. 

  1862. 		};
    1863. 

  1863. 

  1864. 		$result .= ');';
    1865. 

  1865. 

  1866. 		return strval($result);
    1867. 

  1867. 	} else {
    1868. 

  1868. 	 return '#'.$theNext;
    1869. 

  1869. 	};
    1870. 

  1870. 	};
    1871. 

  1871. };
    1872. 

  1872. /* - - - - - - - - - - - - - - - - - */
    1873. 

  1873. /* - - - - - - - - - - - - - - - - - */
    1874. 

  1874. function get_value_from_url($curr_what, $where) {
    1875. 

  1875.  $result = false;
    1876. 

  1876.  foreach($where as $key => $value) {
    1877. 

  1877.   if(is_array($value)) {
    1878. 

  1878.    $result = array_get_value($curr_what, $value);
    1879. 

  1879.   } else {
    1880. 

  1880.    if (!(stripos($value, $curr_what) === false))  {
    1881. 

  1881.     $result = str_ireplace($curr_what.'=', '', $value);
    1882. 

  1882.    };
    1883. 

  1883.   };
    1884. 

  1884.  };
    1885. 

  1885.  if ($result) {
    1886. 

  1886.   return (string) $result;
    1887. 

  1887.  };
    1888. 

  1888. };
    1889. 

  1889. /* - - - - - - - - - - - - - - - - - */
    1890. 

  1890. /* - - - - - - - - - - - - - - - - - */
    1891. 

  1891. function multexplode($spacer,$string) {
    1892. 

  1892.  if (strlen($spacer)<1) {
    1893. 

  1893.   return($string);
    1894. 

  1894.  } else {
    1895. 

  1895.   $trenn=array_shift($spacer);
    1896. 

  1896.   $string=explode($trenn,$string);
    1897. 

  1897.   while (list($key,$val) = each($string)) {
    1898. 

  1898.    $string[$key]=multexplode($spacer,$val);
    1899. 

  1899.   };
    1900. 

  1900.   return($string);
    1901. 

  1901.  };
    1902. 

  1902. };
    1903. 

  1903. /* - - - - - - - - - - - - - - - - - */
    1904. 

  1904. 

  1905. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    1906. 

  1906. function validate_xml($xml_path) {
    1907. 

  1907.  $message = true;
    1908. 

  1908. 	if (is_file($xml_path)) {
    1909. 

  1909. 		libxml_use_internal_errors(true);
    1910. 

  1910. 		$dom = new DOMDocument('1.0', 'UTF-8');
    1911. 

  1911. 		$dom->resolveExternals = true;
    1912. 

  1912. 		$dom->substituteEntities = true;
    1913. 

  1913. 		$dom->validateOnParse = true;
    1914. 

  1914. 		$dom->load($xml_path);
    1915. 

  1915. 		$errors = libxml_get_errors();
    1916. 

  1916. 		if (strlen($errors)<1) {
    1917. 

  1917. 			return true;
    1918. 

  1918. 		} else {
    1919. 

  1919. 			$message = '';
    1920. 

  1920. 			foreach($errors as $error) {
    1921. 

  1921. 				$message .= $error->message.' at line '.$error->line.':<br />';
    1922. 

  1922. 			};
    1923. 

  1923. 		};
    1924. 

  1924. 		return $message;
    1925. 

  1925. 	};
    1926. 

  1926. 	return $message;
    1927. 

  1927. };
    1928. 

  1928. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    1929. 

  1929. 

  1930. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    1931. 

  1931. /* NO ?> IN FILE .INC */
    1932. 

  1932.