PageRenderTime 27ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 0ms

/vpsadmin/lib/xtemplate.lib.php

http://pef.googlecode.com/
PHP | 801 lines | 772 code | 3 blank | 26 comment | 4 complexity | e2c2e84b09ee9017e78f08646da28d92 MD5 | raw file
    

  1. <?php
    2. 

  2. /*
    3. 

  3.     ./lib/xtemplate.lib.php
    4. 

    5. 

  5.     vpsAdmin
    6. 

  6.     Web-admin interface for OpenVZ (see http://openvz.org)
    7. 

  7.     Copyright (C) 2008-2009 Pavel Snajdr, snajpa@snajpa.net
    8. 

    9. 

  9.     This program is free software: you can redistribute it and/or modify
    10. 

  10.     it under the terms of the GNU General Public License as published by
    11. 

  11.     the Free Software Foundation, either version 3 of the License, or
    12. 

  12.     (at your option) any later version.
    13. 

    14. 

  14.     This program is distributed in the hope that it will be useful,
    15. 

  15.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    16. 

  16.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17. 

  17.     GNU General Public License for more details.
    18. 

    19. 

  19.     You should have received a copy of the GNU General Public License
    20. 

  20.     along with this program.  If not, see <http://www.gnu.org/licenses/>
    21. 

    22. 

  22.     Xtemplate
    23. 

  23.      Copyright (c) 2000-2001 Barnabas Debreceni [cranx@users.sourceforge.net] XTemplate
    24. 

  24.      Copyright (c) 2002-2007 Jeremy Coates [cocomp@users.sourceforge.net] XTemplate & CachingXTemplate
    25. 

    26. 

  26. */
    27. 

  27. // if we are using xtemplate, this is not CLI application
    28. 

  28. $_SESSION["cli_mode"] = false;
    29. 

  29. 

  30. class XTemplate {
    31. 

  31. 	var $filecontents = '';
    32. 

  32. 	var $blocks = array();
    33. 

  33. 	var $parsed_blocks = array();
    34. 

  34. 	var $preparsed_blocks = array();
    35. 

  35. 	var $block_parse_order = array();
    36. 

  36. 	var $sub_blocks = array();
    37. 

  37. 	var $vars = array();
    38. 

  38. 	var $filevars = array();
    39. 

  39. 	var $filevar_parent = array();
    40. 

  40. 	var $filecache = array();
    41. 

  41. 	var $tpldir = '';
    42. 

  42. 	var $files = null;
    43. 

  43. 	var $filename = '';
    44. 

  44. 	var $file_delim = '';//"/\{FILE\s*\"([^\"]+)\"\s*\}/m"; 
    45. 

  45. 	var $filevar_delim = '';//"/\{FILE\s*\{([A-Za-z0-9\._]+?)\}\s*\}/m";  
    46. 

  46. 	var $filevar_delim_nl = '';//"/^\s*\{FILE\s*\{([A-Za-z0-9\._]+?)\}\s*\}\s*\n/m";  
    47. 

  47. 	var $block_start_delim = '<!-- ';         /* block start delimiter */
    48. 

  48. 	var $block_end_delim = '-->';                 /* block end delimiter */
    49. 

  49. 	var $block_start_word = 'BEGIN:';         /* block start word */
    50. 

  50. 	var $block_end_word = 'END:';                 /* block end word */
    51. 

  51. 

  52. 	var $tag_start_delim = '{';
    53. 

  53. 	var $tag_end_delim = '}';
    54. 

  54. 

  55. 	var $mainblock = 'main';
    56. 

  56. 	var $output_type = 'HTML';
    57. 

  57. 	var $_null_string = array('' => '');             /* null string for unassigned vars */
    58. 

  58. 	var $_null_block = array('' => '');  /* null string for unassigned blocks */
    59. 

  59. 	var $_error = '';
    60. 

  60. 	var $_autoreset = true;                                     /* auto-reset sub blocks */
    61. 

  61. 	var $_ignore_missing_blocks = true ;          // NW 17 oct 2002 - Set to FALSE to
    62. 

  62. 	var $_file_name_full_path = '';
    63. 

  63. 	function XTemplate ($file,  $tpldir = '', $files = null, $mainblock = 'main', $autosetup = true) {
    64. 

  64. 		$this->filename = $file;
    65. 

  65. 		$this->_file_name_full_path = realpath($file);
    66. 

  66. 		$this->tpldir = $tpldir;
    67. 

  67. 		if (is_array($files)) {
    68. 

  68. 			$this->files = $files;
    69. 

  69. 		}
    70. 

  70. 		$this->mainblock = $mainblock;
    71. 

  71. 		if ($autosetup) {
    72. 

  72. 			$this->setup();
    73. 

  73. 		}
    74. 

  74. 	}
    75. 

  75. 	function restart ($file, $tpldir = '', $files = null, $mainblock = 'main', $autosetup = true, $tag_start = '{', $tag_end = '}') {
    76. 

  76. 		$this->filename = $file;
    77. 

  77. 		$this->_file_name_full_path = realpath($file);
    78. 

  78. 		$this->tpldir = $tpldir;
    79. 

  79. 		if (is_array($files)) {
    80. 

  80. 			$this->files = $files;
    81. 

  81. 		}
    82. 

  82. 		$this->mainblock = $mainblock;
    83. 

  83. 		$this->tag_start_delim = $tag_start;
    84. 

  84. 		$this->tag_end_delim = $tag_end;
    85. 

  85. 		$this->filecontents = '';
    86. 

  86. 		$this->blocks = array();
    87. 

  87. 		$this->parsed_blocks = array();
    88. 

  88. 		$this->preparsed_blocks = array();
    89. 

  89. 		$this->block_parse_order = array();
    90. 

  90. 		$this->sub_blocks = array();
    91. 

  91. 		$this->vars = array();
    92. 

  92. 		$this->filevars = array();
    93. 

  93. 		$this->filevar_parent = array();
    94. 

  94. 		$this->filecache = array();
    95. 

  95. 		if ($autosetup) {
    96. 

  96. 			$this->setup();
    97. 

  97. 		}
    98. 

  98. 	}
    99. 

  99. 	function setup ($add_outer = false) {
    100. 

  100. 		$this->tag_start_delim = preg_quote($this->tag_start_delim);
    101. 

  101. 		$this->tag_end_delim = preg_quote($this->tag_end_delim);
    102. 

  102. 		$this->file_delim = "/" . $this->tag_start_delim . "FILE\s*\"([^\"]+)\"\s*" . $this->tag_end_delim . "/m";
    103. 

  103. 		$this->filevar_delim = "/" . $this->tag_start_delim . "FILE\s*" . $this->tag_start_delim . "([A-Za-z0-9\._]+?)" . $this->tag_end_delim . "\s*" . $this->tag_end_delim . "/m";
    104. 

  104. 		$this->filevar_delim_nl = "/^\s*" . $this->tag_start_delim . "FILE\s*" . $this->tag_start_delim . "([A-Za-z0-9\._]+?)" . $this->tag_end_delim . "\s*" . $this->tag_end_delim . "\s*\n/m";
    105. 

  105. 		if (empty($this->filecontents)) {
    106. 

  106. 			$this->filecontents = $this->_r_getfile($this->filename);
    107. 

  107. 		}
    108. 

  108. 		if ($add_outer) {
    109. 

  109. 			$this->_add_outer_block();
    110. 

  110. 		}
    111. 

  111. 		$this->blocks = $this->_maketree($this->filecontents, '');
    112. 

  112. 		$this->filevar_parent = $this->_store_filevar_parents($this->blocks);
    113. 

  113. 		$this->scan_globals();
    114. 

  114. 	}
    115. 

  115. 	function assign ($name, $val = '') {
    116. 

  116. 		if (is_array($name)) {
    117. 

  117. 			foreach ($name as $k => $v) {
    118. 

  118. 				$this->vars[$k] = $v;
    119. 

  119. 			}
    120. 

  120. 		} else {
    121. 

  121. 			$this->vars[$name] = $val;
    122. 

  122. 		}
    123. 

  123. 	}
    124. 

  124. 

  125. 	function assign_file ($name, $val = '') {
    126. 

  126. 		if (is_array($name)) {
    127. 

  127. 			foreach ($name as $k => $v) {
    128. 

  128. 				$this->_assign_file_sub($k, $v);
    129. 

  129. 			}
    130. 

  130. 		} else {
    131. 

  131. 			$this->_assign_file_sub($name, $val);
    132. 

  132. 		}
    133. 

  133. 	}
    134. 

  134. 

  135. 	function parse ($bname) {
    136. 

  136. 		if (isset($this->preparsed_blocks[$bname])) {
    137. 

  137. 			$copy = $this->preparsed_blocks[$bname];
    138. 

  138. 		} elseif (isset($this->blocks[$bname])) {
    139. 

  139. 			$copy = $this->blocks[$bname];
    140. 

  140. 		} elseif ($this->_ignore_missing_blocks) {
    141. 

  141. 			$this->_set_error("parse: blockname [$bname] does not exist");
    142. 

  142. 			return;
    143. 

  143. 		} else {
    144. 

  144. 			$this->_set_error("parse: blockname [$bname] does not exist");
    145. 

  145. 		}
    146. 

  146. 		if (!isset($copy)) {
    147. 

  147. 			die('Block: ' . $bname);
    148. 

  148. 		}
    149. 

  149. 		$copy = preg_replace($this->filevar_delim_nl, '', $copy);
    150. 

  150. 		$var_array = array();
    151. 

  151. 		preg_match_all("/" . $this->tag_start_delim . "([A-Za-z0-9\._]+? ?#?.*?)" . $this->tag_end_delim. "/", $copy, $var_array);
    152. 

  152. 		$var_array = $var_array[1];
    153. 

  153. 		foreach ($var_array as $k => $v) {
    154. 

  154. 			$any_comments = explode('#', $v);
    155. 

  155. 			$v = rtrim($any_comments[0]);
    156. 

  156. 			if (sizeof($any_comments) > 1) {
    157. 

  157. 				$comments = $any_comments[1];
    158. 

  158. 			} else {
    159. 

  159. 				$comments = '';
    160. 

  160. 			}
    161. 

  161. 			$sub = explode('.', $v);
    162. 

  162. 			if ($sub[0] == '_BLOCK_') {
    163. 

  163. 				unset($sub[0]);
    164. 

  164. 				$bname2 = implode('.', $sub);
    165. 

  165. 				$var = isset($this->parsed_blocks[$bname2]) ? $this->parsed_blocks[$bname2] : null;
    166. 

  166. 				$nul = (!isset($this->_null_block[$bname2])) ? $this->_null_block[''] : $this->_null_block[$bname2];
    167. 

  167. 				if ($var == '') {
    168. 

  168. 					if ($nul == '') {
    169. 

  169. 						$copy = preg_replace("/" . $this->tag_start_delim . $v . $this->tag_end_delim . "/m", '', $copy);
    170. 

  170. 					} else {
    171. 

  171. 						$copy = preg_replace("/" . $this->tag_start_delim . $v . $this->tag_end_delim . "/", "$nul", $copy);
    172. 

  172. 					}
    173. 

  173. 				} else {
    174. 

  174. 					$var = trim($var);
    175. 

  175. 					$var = str_replace('\\', '\\\\', $var);
    176. 

  176. 					$var = str_replace('$', '\\$', $var);
    177. 

  177. 					$var = str_replace('\\|', '|', $var);
    178. 

  178. 					$copy = preg_replace("|" . $this->tag_start_delim . $v . $this->tag_end_delim . "|", "$var", $copy);
    179. 

  179. 				}
    180. 

  180. 			} else {
    181. 

  181. 				$var = $this->vars;
    182. 

  182. 				foreach ($sub as $v1) {
    183. 

  183. 					if (!isset($var[$v1]) || (!is_array($var[$v1]) && strlen($var[$v1]) == 0)) {
    184. 

  184. 						if (defined($v1)) {
    185. 

  185. 							$var[$v1] = constant($v1);
    186. 

  186. 						} else {
    187. 

  187. 							$var[$v1] = null;
    188. 

  188. 						}
    189. 

  189. 					}
    190. 

  190. 					$var = $var[$v1];
    191. 

  191. 				}
    192. 

  192. 				$nul = (!isset($this->_null_string[$v])) ? ($this->_null_string[""]) : ($this->_null_string[$v]);
    193. 

  193. 				$var = (!isset($var)) ? $nul : $var;
    194. 

  194. 				if ($var == '') {
    195. 

  195. 					$copy=preg_replace("|\s*" . $this->tag_start_delim . $v . " ?#?" . $comments . $this->tag_end_delim . "\s*\n|m", '', $copy);
    196. 

  196. 				}
    197. 

  197. 				$var = trim($var);
    198. 

  198. 				$var = str_replace('\\', '\\\\', $var);
    199. 

  199. 				$var = str_replace('$', '\\$', $var);
    200. 

  200. 				$var = str_replace('\\|', '|', $var);
    201. 

  201. 				$copy=preg_replace("|" . $this->tag_start_delim . $v . " ?#?" . $comments . $this->tag_end_delim . "|", "$var", $copy);
    202. 

  202. 			}
    203. 

  203. 		}
    204. 

  204. 		if (isset($this->parsed_blocks[$bname])) {
    205. 

  205. 			$this->parsed_blocks[$bname] .= $copy;
    206. 

  206. 		} else {
    207. 

  207. 			$this->parsed_blocks[$bname] = $copy;
    208. 

  208. 		}
    209. 

  209. 		/* reset sub-blocks */
    210. 

  210. 		if ($this->_autoreset && (!empty($this->sub_blocks[$bname]))) {
    211. 

  211. 			reset($this->sub_blocks[$bname]);
    212. 

  212. 			foreach ($this->sub_blocks[$bname] as $k => $v) {
    213. 

  213. 				$this->reset($v);
    214. 

  214. 			}
    215. 

  215. 		}
    216. 

  216. 	}
    217. 

  217. 	function rparse ($bname) {
    218. 

  218. 		if (!empty($this->sub_blocks[$bname])) {
    219. 

  219. 			reset($this->sub_blocks[$bname]);
    220. 

  220. 			foreach ($this->sub_blocks[$bname] as $k => $v) {
    221. 

  221. 				if (!empty($v)) {
    222. 

  222. 					$this->rparse($v);
    223. 

  223. 				}
    224. 

  224. 			}
    225. 

  225. 		}
    226. 

  226. 		$this->parse($bname);
    227. 

  227. 	}
    228. 

  228. 	function insert_loop ($bname, $var, $value = '') {
    229. 

  229. 		$this->assign($var, $value);
    230. 

  230. 		$this->parse($bname);
    231. 

  231. 	}
    232. 

  232. 	function array_loop ($bname, $var, &$values) {
    233. 

  233. 		if (is_array($values)) {
    234. 

  234. 			foreach($values as $v) {
    235. 

  235. 				$this->assign($var, $v);
    236. 

  236. 				$this->parse($bname);
    237. 

  237. 			}
    238. 

  238. 		}
    239. 

  239. 	}
    240. 

  240. 	function text ($bname = '') {
    241. 

  241. 		$text = '';
    242. 

  242. 		$bname = !empty($bname) ? $bname : $this->mainblock;
    243. 

  243. 		$text .= isset($this->parsed_blocks[$bname]) ? $this->parsed_blocks[$bname] : $this->get_error();
    244. 

  244. 		return $text;
    245. 

  245. 	}
    246. 

  246. 	function out ($bname) {
    247. 

  247. 		$out = $this->text($bname);
    248. 

  248. 		echo $out;
    249. 

  249. 	}
    250. 

  250. 	function out_file ($bname, $fname) {
    251. 

  251. 		if (!empty($bname) && !empty($fname) && is_writeable($fname)) {
    252. 

  252. 			$fp = fopen($fname, 'w');
    253. 

  253. 			fwrite($fp, $this->text($bname));
    254. 

  254. 			fclose($fp);
    255. 

  255. 		}
    256. 

  256. 	}
    257. 

  257. 	function reset ($bname) {
    258. 

  258. 		$this->parsed_blocks[$bname] = '';
    259. 

  259. 	}
    260. 

  260. 	function parsed ($bname) {
    261. 

  261. 		return (!empty($this->parsed_blocks[$bname]));
    262. 

  262. 	}
    263. 

  263. 	function SetNullString ($str, $varname = '') {
    264. 

  264. 		$this->_null_string[$varname] = $str;
    265. 

  265. 	}
    266. 

  266. 	function SetNullBlock ($str, $bname = '') {
    267. 

  267. 		$this->_null_block[$bname] = $str;
    268. 

  268. 	}
    269. 

  269. 	function set_autoreset () {
    270. 

  270. 		$this->_autoreset = true;
    271. 

  271. 	}
    272. 

  272. 	function clear_autoreset () {
    273. 

  273. 		$this->_autoreset = false;
    274. 

  274. 	}
    275. 

  275. 	function scan_globals () {
    276. 

  276. 		reset($GLOBALS);
    277. 

  277. 		foreach ($GLOBALS as $k => $v) {
    278. 

  278. 			$GLOB[$k] = $v;
    279. 

  279. 		}
    280. 

  280. 		$this->assign('PHP', $GLOB);
    281. 

  281. 	}
    282. 

  282. 	function get_error () {
    283. 

  283. 		$retval = false;
    284. 

  284. 		if ($this->_error != '') {
    285. 

  285. 			switch ($this->output_type) {
    286. 

  286. 				case 'HTML':
    287. 

  287. 				case 'html':
    288. 

  288. 				$retval = '<b>[XTemplate]</b><ul>' . nl2br(str_replace('* ', '<li>', str_replace(" *\n", "</li>\n", $this->_error))) . '</ul>';
    289. 

  289. 				break;
    290. 

  290. 				default:
    291. 

  291. 				$retval = '[XTemplate] ' . str_replace(' *\n', "\n", $this->_error);
    292. 

  292. 				break;
    293. 

  293. 			}
    294. 

  294. 		}
    295. 

  295. 		return $retval;
    296. 

  296. 	}
    297. 

  297. 	function _maketree ($con, $parentblock='') {
    298. 

  298. 		$blocks = array();
    299. 

  299. 		$con2 = explode($this->block_start_delim, $con);
    300. 

  300. 		if (!empty($parentblock)) {
    301. 

  301. 			$block_names = explode('.', $parentblock);
    302. 

  302. 			$level = sizeof($block_names);
    303. 

  303. 		} else {
    304. 

  304. 			$block_names = array();
    305. 

  305. 			$level = 0;
    306. 

  306. 		}
    307. 

  307. 		foreach($con2 as $k => $v) {
    308. 

  308. 			$patt = "($this->block_start_word|$this->block_end_word)\s*(\w+) ?#?.*?\s*$this->block_end_delim(.*)";
    309. 

  309. 			$res = array();
    310. 

  310. 			if (preg_match_all("/$patt/ims", $v, $res, PREG_SET_ORDER)) {
    311. 

  311. 				$block_word	= $res[0][1];
    312. 

  312. 				$block_name	= $res[0][2];
    313. 

  313. 				$content	= $res[0][3];
    314. 

  314. 				if (strtoupper($block_word) == $this->block_start_word) {
    315. 

  315. 					$parent_name = implode('.', $block_names);
    316. 

  316. 					$block_names[++$level] = $block_name;
    317. 

  317. 					$cur_block_name=implode('.', $block_names);
    318. 

  318. 					$this->block_parse_order[] = $cur_block_name;
    319. 

  319. 					$blocks[$cur_block_name] = isset($blocks[$cur_block_name]) ? $blocks[$cur_block_name] . $content : $content;
    320. 

  320. 					$blocks[$parent_name] .= str_replace('\\', '', $this->tag_start_delim) . '_BLOCK_.' . $cur_block_name . str_replace('\\', '', $this->tag_end_delim);
    321. 

  321. 					$this->sub_blocks[$parent_name][] = $cur_block_name;
    322. 

  322. 					$this->sub_blocks[$cur_block_name][] = '';
    323. 

  323. 				} else if (strtoupper($block_word) == $this->block_end_word) {
    324. 

  324. 					unset($block_names[$level--]);
    325. 

  325. 					$parent_name = implode('.', $block_names);
    326. 

  326. 					$blocks[$parent_name] .= $res[0][3];
    327. 

  327. 				}
    328. 

  328. 			} else {
    329. 

  329. 				$tmp = implode('.', $block_names);
    330. 

  330. 				if ($k) {
    331. 

  331. 					$blocks[$tmp] .= $this->block_start_delim;
    332. 

  332. 				}
    333. 

  333. 				$blocks[$tmp] = isset($blocks[$tmp]) ? $blocks[$tmp] . $v : $v;
    334. 

  334. 			}
    335. 

  335. 		}
    336. 

  336. 		return $blocks;
    337. 

  337. 	}
    338. 

  338. 	function _assign_file_sub ($name, $val) {
    339. 

  339. 		if (isset($this->filevar_parent[$name])) {
    340. 

  340. 			if ($val != '') {
    341. 

  341. 				$val = $this->_r_getfile($val);
    342. 

  342. 				foreach($this->filevar_parent[$name] as $parent) {
    343. 

  343. 					if (isset($this->preparsed_blocks[$parent]) && !isset($this->filevars[$name])) {
    344. 

  344. 						$copy = $this->preparsed_blocks[$parent];
    345. 

  345. 					} elseif (isset($this->blocks[$parent])) {
    346. 

  346. 						$copy = $this->blocks[$parent];
    347. 

  347. 					}
    348. 

  348. 					$res = array();
    349. 

  349. 					preg_match_all($this->filevar_delim, $copy, $res, PREG_SET_ORDER);
    350. 

  350. 					if (is_array($res) && isset($res[0])) {
    351. 

  351. 						foreach ($res[0] as $v) {
    352. 

  352. 							$copy = preg_replace("/" . preg_quote($v) . "/", "$val", $copy);
    353. 

  353. 							$this->preparsed_blocks = array_merge($this->preparsed_blocks, $this->_maketree($copy, $parent));
    354. 

  354. 							$this->filevar_parent = array_merge($this->filevar_parent, $this->_store_filevar_parents($this->preparsed_blocks));
    355. 

  355. 						}
    356. 

  356. 					}
    357. 

  357. 				}
    358. 

  358. 			}
    359. 

  359. 		}
    360. 

  360. 		$this->filevars[$name] = $val;
    361. 

  361. 	}
    362. 

  362. 	function _store_filevar_parents ($blocks){
    363. 

  363. 		$parents = array();
    364. 

  364. 		foreach ($blocks as $bname => $con) {
    365. 

  365. 			$res = array();
    366. 

  366. 			preg_match_all($this->filevar_delim, $con, $res);
    367. 

  367. 			foreach ($res[1] as $k => $v) {
    368. 

  368. 				$parents[$v][] = $bname;
    369. 

  369. 			}
    370. 

  370. 		}
    371. 

  371. 		return $parents;
    372. 

  372. 	}
    373. 

  373. 	function _set_error ($str)    {
    374. 

  374. 		$this->_error .= '* ' . $str . " *\n";
    375. 

  375. 	}
    376. 

  376. 	function _getfile ($file) {
    377. 

  377. 		if (!isset($file)) {
    378. 

  378. 			$this->_set_error('!isset file name!' . $file);
    379. 

  379. 			return '';
    380. 

  380. 		}
    381. 

  381. 		if (isset($this->files)) {
    382. 

  382. 			if (isset($this->files[$file])) {
    383. 

  383. 				$file = $this->files[$file];
    384. 

  384. 			}
    385. 

  385. 		}
    386. 

  386. 		if (!empty($this->tpldir)) {
    387. 

  387. 			$file = $this->tpldir. '/' . $file;
    388. 

  388. 		}
    389. 

  389. 		if (isset($this->filecache[$file])) {
    390. 

  390. 			$file_text=$this->filecache[$file];
    391. 

  391. 		} else {
    392. 

  392. 			if (is_file($file)) {
    393. 

  393. 				if (!($fh = fopen($file, 'r'))) {
    394. 

  394. 					$this->_set_error('Cannot open file: ' . $file);
    395. 

  395. 					return '';
    396. 

  396. 				}
    397. 

  397. 				$file_text = fread($fh,filesize($file));
    398. 

  398. 				fclose($fh);
    399. 

  399. 			} else {
    400. 

  400. 				$this->_set_error("[" . realpath($file) . "] ($file) does not exist");
    401. 

  401. 				$file_text = "<b>__XTemplate fatal error: file [$file] does not exist__</b>";
    402. 

  402. 			}
    403. 

  403. 			$this->filecache[$file] = $file_text;
    404. 

  404. 		}
    405. 

  405. 		return $file_text;
    406. 

  406. 	}
    407. 

  407. 	function _r_getfile ($file) {
    408. 

  408. 		$text = $this->_getfile($file);
    409. 

  409. 		$res = array();
    410. 

  410. 		while (preg_match($this->file_delim,$text,$res)) {
    411. 

  411. 			$text2 = $this->_getfile($res[1]);
    412. 

  412. 			$text = preg_replace("'".preg_quote($res[0])."'",$text2,$text);
    413. 

  413. 		}
    414. 

  414. 		return $text;
    415. 

  415. 	}
    416. 

  416. 	function _add_outer_block () {
    417. 

  417. 		$before = $this->block_start_delim . $this->block_start_word . ' ' . $this->mainblock . ' ' . $this->block_end_delim;
    418. 

  418. 		$after = $this->block_start_delim . $this->block_end_word . ' ' . $this->mainblock . ' ' . $this->block_end_delim;
    419. 

  419. 		$this->filecontents = $before . "\n" . $this->filecontents . "\n" . $after;
    420. 

  420. 	}
    421. 

  421. 	function _pre_var_dump () {
    422. 

  422. 		echo '<pre>';
    423. 

  423. 		var_dump(func_get_args());
    424. 

  424. 		echo '</pre>';
    425. 

  425. 	}
    426. 

  426. /* XTemplate extensions for vpsAdmin for lazy programmers */
    427. 

  427. 	/**
    428. 

  428. 	  * Set title of the page
    429. 

  429. 	  * @param $title - title of page
    430. 

  430. 	*/
    431. 

  431. 	function title ($title) {
    432. 

  432. 	    $this->assign('TITLE', $title);
    433. 

  433. 	}
    434. 

  434. 	function title2 ($title2) {
    435. 

  435. 	    $this->assign('S_TITLE', $title2);
    436. 

  436. 	    $this->parse('main.s_title');
    437. 

  437. 	}
    438. 

  438. 	function title3 ($title3) {
    439. 

  439. 	    $this->assign('S_S_TITLE', $title3);
    440. 

  440. 	    $this->parse('main.s_s_title');
    441. 

  441. 	}
    442. 

  442. 	/**
    443. 

  443. 	  * @param $code - lang code
    444. 

  444. 	  * @param $icon - lang icon code
    445. 

  445. 	  * @param $lang - language name
    446. 

  446. 	  * @param $class - class of image
    447. 

  447. 	**/
    448. 

  448. 	function lang_add($code, $icon, $lang, $class) {
    449. 

  449. 	    $this->assign('LANG_CODE', $code);
    450. 

  450. 	    $this->assign('LANG_ICON', $icon);
    451. 

  451. 	    $this->assign('LANG_IMG_CLASS', $class);
    452. 

  452. 	    $this->assign('LANG_LANG', $lang);
    453. 

  453. 	    $this->parse('main.langitem');
    454. 

  454. 	}
    455. 

  455. 	/**
    456. 

  456. 	  * Parse out the login box
    457. 

  457. 	  * @param $logged - is user logged in?
    458. 

  458. 	  * @param $user_name - if so, what is is nick?
    459. 

  459. 	  */
    460. 

  460. 	function logbox ($logged = false, $user_name = 'none') {
    461. 

  461. 		if ($logged) {
    462. 

  462. 			$this->assign('USER_NAME', $user_name);
    463. 

  463. 			$this->parse('main.loggedbox');
    464. 

  464. 			}
    465. 

  465. 		  else
    466. 

  466. 			$this->parse('main.logbox');  
    467. 

  467. 	}
    468. 

  468. 	/**
    469. 

  469. 	  * Add item to menu
    470. 

  470. 	  * @param $title - title of the perex
    471. 

  471. 	  * @param $link - URL link of item
    472. 

  472. 	  * @param $active - Is user currently here?
    473. 

  473. 	  * @param $is_last - Is this item last in the menu?
    474. 

  474. 	  */
    475. 

  475. 	function menu_add ($title = 'Titulek', $link = '#', $active = false, $is_last = false) {
    476. 

  476. 		$this->assign('MENU_LINK', $link);
    477. 

  477. 		$this->assign('MENU_TITLE', $title);
    478. 

  478. 		$this->assign('MENU_ACTIVE', ($active) ? 'id="nav-active"' : '');
    479. 

  479. 		$this->assign('MENU_LAST', ($is_last) ? 'class="last"' : '');
    480. 

  480. 		$this->parse('main.menu_item');
    481. 

  481. 	}
    482. 

  482. 	/**
    483. 

  483. 	  * Add perex to page
    484. 

  484. 	  * @param $title - title of the perex
    485. 

  485. 	  * @param $content - HTML content of the perex
    486. 

  486. 	  */
    487. 

  487. 	function perex ($title, $content) {
    488. 

  488. 		$this->assign('PEREX_TITLE', $title);
    489. 

  489. 		$this->assign('PEREX_CONTENT', $content);
    490. 

  490. 		$this->parse('main.perex');
    491. 

  491. 	}
    492. 

  492. 	/**
    493. 

  493. 	  * Add perex - command output to page
    494. 

  494. 	  * @param $title - title
    495. 

  495. 	  * @param $output - array of lines
    496. 

  496. 	  */
    497. 

  497. 	function perex_cmd_output ($title, $output) {
    498. 

  498. 		$this->assign('PEREX_TITLE', $title);
    499. 

  499. 		if (is_array($output))
    500. 

  500. 		foreach ($output as $line) $content .= $line.' <br />';
    501. 

  501. 		$this->assign('PEREX_CONTENT', $content);
    502. 

  502. 		$this->parse('main.perex');
    503. 

  503. 	}
    504. 

  504. 	/**
    505. 

  505. 	  * Add link to sidebar
    506. 

  506. 	  * @param $title - link title
    507. 

  507. 	  * @param $link - link URL
    508. 

  508. 	  */
    509. 

  509. 	function sbar_add ($title, $link) {
    510. 

  510. 		$this->assign('SBI_TITLE' ,$title);
    511. 

  511. 		$this->assign('SBI_LINK', $link);
    512. 

  512. 		$this->parse('main.sidebar.sb_item');
    513. 

  513. 	}
    514. 

  514. 	/**
    515. 

  515. 	  * Parse out the sidebar
    516. 

  516. 	  * @param $title - tile for the sidebar
    517. 

  517. 	  */
    518. 

  518. 	function sbar_out ($title) {
    519. 

  519. 		$this->assign('SB_TITLE',$title);
    520. 

  520. 		$this->parse('main.sidebar');
    521. 

  521. 	}
    522. 

  522. 	/**
    523. 

  523. 	  * Add table category to table header
    524. 

  524. 	  * @param $name - HTML content of the category header
    525. 

  525. 	  */
    526. 

  526. 	function table_add_category ($name) {
    527. 

  527. 		$this->assign('TABLE_CATEGORY', $name);
    528. 

  528. 		$this->parse('main.table.category');
    529. 

  529. 	}
    530. 

  530. 	/**
    531. 

  531. 	  * Add table cell
    532. 

  532. 	  * @param $content - HTML content of the cell
    533. 

  533. 	  * @param $td_back_color - HTML background color
    534. 

  534. 	  * @param $toright - Right side text align
    535. 

  535. 	  */
    536. 

  536. 	function table_td ($content, $td_back_color=false, $toright = false, $colspan = '1', $rowspan = '1') {
    537. 

  537. 		$tdstyle = 'style="';
    538. 

  538. 		if ($td_back_color) $tdstyle .= 'background:'.$td_back_color.';';
    539. 

  539. 		if ($toright) $tdstyle .= 'text-align:right;';
    540. 

  540. 		$tdstyle .='" colspan="'.$colspan.'" rowspan="'.$rowspan.'"';
    541. 

  541. 		$this->assign('TDSTYLE',$tdstyle);
    542. 

  542. 		$this->assign('TABLE_TD',$content);
    543. 

  543. 		$this->parse('main.table.tr.td');
    544. 

  544. 		$this->assign('TDSTYLE','');
    545. 

  545. 	}
    546. 

  546. 	/**
    547. 

  547. 	  * Parse out the table row
    548. 

  548. 	  * @param $tr_back_color - background color of 
    549. 

  549. 	  * @param $tr_class - CSS class of row
    550. 

  550. 	  * @param $tr_class_hover - CSS class when mouse over
    551. 

  551. 	  */
    552. 

  552. 	function table_tr ($tr_back_color=false, $tr_class=false, $tr_class_hover=false) {
    553. 

  553. 		// UPDATED BY toms
    554. 

  554. 		if ($tr_back_color) 
    555. 

  555. 			$this->assign('TRSTYLE','style="background:'.$tr_back_color.'"');
    556. 

  556. 		elseif ($tr_class)
    557. 

  557. 			$this->assign('TRSTYLE', 'class="'.$tr_class.'"');
    558. 

  558. 		else
    559. 

  559. 			$this->assign('TRSTYLE', '');
    560. 

  560. 

  561. 		if ($tr_class)
    562. 

  562. 			$this->assign('TRCLASS', $tr_class);
    563. 

  563. 		else 
    564. 

  564. 			$this->assign('TRCLASS', 'none');
    565. 

  565. 

  566. 		if ($tr_class_hover)
    567. 

  567. 			$this->assign('TRCLASS_HOVER', $tr_class_hover);
    568. 

  568. 		else
    569. 

  569. 			$this->assign('TRCLASS_HOVER', 'bg');
    570. 

  570. 

  571. 		$this->parse('main.table.tr');
    572. 

  572. 	}
    573. 

  573. 	/**
    574. 

  574. 	  * Parse out the table
    575. 

  575. 	  */
    576. 

  576. 	function table_out() {
    577. 

  577. 		$this->parse('main.table');
    578. 

  578. 	}
    579. 

  579. 	/**
    580. 

  580. 	  * Add form to the page, begin with this
    581. 

  581. 	  * @param $action - action URL
    582. 

  582. 	  * @param $method - GET or POST
    583. 

  583. 	  */
    584. 

  584. 	function form_create($action = '?page=', $method = 'post') {
    585. 

  585. 		$this->assign('TABLE_FORM_BEGIN','<form action="'.$action.'" method="'.$method.'">');
    586. 

  586. 	}
    587. 

  587. 	/**
    588. 

  588. 	  * Add input to form
    589. 

  589. 	  * @param $label - label of textarea
    590. 

  590. 	  * @param $type - type of HTML input
    591. 

  591. 	  * @param $size - size of element
    592. 

  592. 	  * @param $name - $_RESULT[name]
    593. 

  593. 	  * @param $value - default value
    594. 

  594. 	  * @param $hint - helping hint
    595. 

  595. 	  */
    596. 

  596. 	function form_add_input($label = 'popisek', $type = 'text', $size = '30', $name = 'input_fromgen', $value = '', $hint = '', $nchar = 0) {
    597. 

  597.     $uid = uniqid();
    598. 

  598. 

  599. 		$this->table_td($label);
    600. 

  600.     
    601. 

  601.     $maxlength = '';
    602. 

  602. 

  603.     if ($nchar!=0) {
    604. 

  604.       $code   = moo_inputremaining("input".$uid, "inputh".$uid, $nchar, $uid);
    605. 

  605.       if ($nchar>0) {
    606. 

  606.         $output = sprintf(_("<span id='inputh%s'>%d</span> chars remaining; "), $uid, $nchar-strlen($value));
    607. 

  607.         $maxlength = 'maxlength="'.$nchar.'"';
    608. 

  608.       }
    609. 

  609.       else
    610. 

  610.         $output = sprintf(_("<span id='inputh%s'>%d</span> chars needed; "), $uid, ($nchar-strlen($value))*-1);
    611. 

  611.       $hint = $code.$output.$hint;
    612. 

  612.     }
    613. 

  613. 

  614.     $this->table_td('<input type="'.$type.'" size="'.$size.'" name="'.$name.'" id="input'. $uid .'" value="'.$value.'" '.$maxlength.' />');
    615. 

  615. 

  616. 		if ($hint != '') {
    617. 

  617.       $this->table_td( $hint );
    618. 

  618.     }
    619. 

  619. 		$this->table_tr();
    620. 

  620. 	}
    621. 

  621. 	/**
    622. 

  622. 	  * Add select (combobox) to form
    623. 

  623. 	  * @param $label - label of textarea
    624. 

  624. 	  * @param $name - $_RESULT[name]
    625. 

  625. 	  * @param $options - array of options, $option[option_name] = "Option Label"
    626. 

  626. 	  * @param $selected_value - default selected value
    627. 

  627. 	  * @param $hint - helping hint
    628. 

  628. 	  */
    629. 

  629. 	function form_add_select($label = 'popisek', $name = 'select_fromgen', $options, $selected_value = '', $hint = '') {
    630. 

  630. 		$this->table_td($label);
    631. 

  631. 		$code = ('<select  name="'.$name.'" id="input">');
    632. 

  632. 		if ($options)
    633. 

  633. 		foreach ($options as $key=>$value) {
    634. 

  634. 		if ($selected_value == $key)
    635. 

  635. 			$code .= '<option selected="selected" value="'.$key.'" title="">'.$value.'</option> \n';
    636. 

  636. 			else $code .= '<option value="'.$key.'" title="">'.$value.'</option> \n';
    637. 

  637. 		}
    638. 

  638. 		$code .= ('</select>');
    639. 

  639. 		$this->table_td($code);
    640. 

  640. 		if ($hint != '') $this->table_td($hint);
    641. 

  641. 		$this->table_tr();
    642. 

  642. 	}
    643. 

  643. 	/**
    644. 

  644. 	  * Add textarea to form
    645. 

  645. 	  * @param $label - label of textarea
    646. 

  646. 	  * @param $cols - number of columns
    647. 

  647. 	  * @param $rows - number of rows
    648. 

  648. 	  * @param $name - $_RESULT[name]
    649. 

  649. 	  * @param $value - default value
    650. 

  650. 	  * @param $hint - helping hint
    651. 

  651. 	  */
    652. 

  652. 	function form_add_textarea($label = 'popisek', $cols = 10, $rows = 4, $name = 'textarea_formgen', $value = '', $hint = '') {
    653. 

  653. 		$this->table_td($label);
    654. 

  654. 		$this->table_td('<textarea name="'.$name.'" cols="'.$cols.'" rows="'.$rows.'" id="input">'.$value.'</textarea>');
    655. 

  655. 		if ($hint != '') $this->table_td($hint);
    656. 

  656. 		$this->table_tr();
    657. 

  657. 	}
    658. 

  658. 	/**
    659. 

  659. 	  * Add checkobox to form
    660. 

  660. 	  * @param $label - label of checkbox
    661. 

  661. 	  * @param $name - $_RESULT[name]
    662. 

  662. 	  * @param $value - value if checked
    663. 

  663. 	  * @param $checked - if it is checked by default
    664. 

  664. 	  * @param $hint - helping hint
    665. 

  665. 	  */
    666. 

  666. 	function form_add_checkbox($label = 'popisek', $name = 'input_fromgen', $value = '', $checked=false, $hint = '') {
    667. 

  667. 		$this->table_td($label);
    668. 

  668. 		$this->table_td('<input type="checkbox" name="'.$name.'" id="input" value="'.$value.'" '.(($checked) ? 'checked':'').' />');
    669. 

  669. 		if ($hint != '') $this->table_td($hint);
    670. 

  670. 		$this->table_tr();
    671. 

  671. 	}
    672. 

  672. 

  673. 	/**
    674. 

  674. 	  * Parse out the form
    675. 

  675. 	  * @param $submit_label - label of submit button of the form
    676. 

  676. 	  */
    677. 

  677. 	function form_out($submit_label) {
    678. 

  678. 		$this->table_td('');
    679. 

  679. 		$this->table_td('<input type="submit" value=" '.$submit_label.' "  id="button"/>');
    680. 

  680. 		$this->table_tr('');
    681. 

  681. 		$this->assign('TABLE_FORM_END','</form>');
    682. 

  682. 		$this->table_out();
    683. 

  683. 	}
    684. 

  684. 	/**
    685. 

  685. 	  * Add transaction line to rightside shortlog
    686. 

  686. 	  * @param $t_id - transaction ID
    687. 

  687. 	  * @param $t_server - server_id, where was transaction run
    688. 

  688. 	  * @param $t_vps - vps_id, which was transaction for
    689. 

  689. 	  * @param $t_class - background color class (CSS)
    690. 

  690. 	  */
    691. 

  691. 	function transaction($t_id, $t_server, $t_vps, $t_label, $t_class = "pending") {
    692. 

  692. 		$this->assign('T_ID', $t_id);
    693. 

  693. 		$this->assign('T_SERVER', $t_server);
    694. 

  694. 		$this->assign('T_VPS', $t_vps);
    695. 

  695. 		$this->assign('T_LABEL', $t_label);
    696. 

  696. 		$this->assign('T_CLASS', $t_class);
    697. 

  697. 		switch ($t_class) {
    698. 

  698. 		    case "pending":
    699. 

  699. 			$this->assign('T_ICO', '<img src="template/icons/transact_pending.gif"> ');
    700. 

  700. 			break;
    701. 

  701. 		    case "ok":
    702. 

  702. 			$this->assign('T_ICO', '<img src="template/icons/transact_ok.png"> ');
    703. 

  703. 			break;
    704. 

  704. 		    default:
    705. 

  705. 			$this->assign('T_ICO', '<img src="template/icons/transact_fail.png"> ');
    706. 

  706. 			break;
    707. 

  707. 		}
    708. 

  708. 		$this->parse('main.transactions.item');
    709. 

  709. 	}
    710. 

  710. 	/**
    711. 

  711. 	  * Parse out rightside transact shortlog
    712. 

  712. 	  */
    713. 

  713. 	function transactions_out() {
    714. 

  714. 		$this->parse('main.transactions');
    715. 

  715. 	}
    716. 

  716. 	/**
    717. 

  717. 	  * @param $title - helpbox title
    718. 

  718. 	  * @param $content - helpbox content, must not have \<br\>'s
    719. 

  719. 	  */
    720. 

  720. 	function helpbox($title, $content) {
    721. 

  721. 		$this->assign('HELPBOX_TITLE', $title);
    722. 

  722. 		$this->assign('HELPBOX_CONTENT', nl2br($content));
    723. 

  723. 		$this->parse('main.helpbox');
    724. 

  724. 	}
    725. 

  725. 	/**
    726. 

  726. 	  * @param $data - HTML code, which will be added above the table
    727. 

  727. 	  */
    728. 

  728. 	function table_begin($data) {
    729. 

  729. 	  $this->assign('TABLE_FORM_BEGIN', $data);
    730. 

  730. 	}
    731. 

  731. 	/**
    732. 

  732. 	  * @param $data - HTML code, which will be added below the table
    733. 

  733. 	  */
    734. 

  734. 	function table_end($data) {
    735. 

  735. 	  $this->assign('TABLE_FORM_END', $data);
    736. 

  736. 	}
    737. 

  737. 	/**
    738. 

  738. 	  * @param $content - HTML content of adminbox
    739. 

  739. 	  */
    740. 

  740. 	function adminbox($content) {
    741. 

  741. 	    $this->assign('ADMINBOX_CONTENT', $content);
    742. 

  742. 	    $this->parse('main.adminbox');
    743. 

  743. 	}
    744. 

  744. 	/**
    745. 

  745. 	  * @param $url - Where to redirect
    746. 

  746. 	  * @param $delay - Delay in msecs 
    747. 

  747. 	  */
    748. 

  748. 	function delayed_redirect($url, $delay = 1500) {
    749. 

  749. 	$script ='
    750. 

  750. 		    <script language="JavaScript">
    751. 

  751. 			function redirect () {
    752. 

  752. 			    setTimeout("top.location.href = \'' . $url . '\'", ' . $delay . ');
    753. 

  753. 			}
    754. 

  754. 		    </script>
    755. 

  755. 		';
    756. 

  756. 	$this->assign('SCRIPT', $script);
    757. 

  757. 	$this->assign('SCRIPT_BODY', 'onload="redirect()"');
    758. 

  758. 	}
    759. 

  759. }
    760. 

  760. /**
    761. 

  761.   * pages are indexed from 0, however they are displayed from 1, therefore there are some cases when -1 had to be added
    762. 

  762.   * @param $current integer - current page number 
    763. 

  763.   * @param $pages   integer - number of all possible pages
    764. 

  764.   * @param $offset  integer - number of pages displayed left or right from current page
    765. 

  765.   * @param $display boolean - default false - returns HTML code, true - prints the code on STDO and also returns it;
    766. 

  766.   * 
    767. 

  767.   * @return String - HTML code for the listing 
    768. 

  768.   */
    769. 

  769. function gen_pages_listing($current, $pages, $offset, $display=false)
    770. 

  770. {
    771. 

  771.   $out = '<div class="page_listing">';
    772. 

  772. 

  773.   $begin = 0;
    774. 

  774.   if ($current>$offset) {
    775. 

  775.     $begin = $current-$offset;
    776. 

  776.     $out .= '<a href="?page=transactions&amp;page_number=0">&laquo;</a> ';
    777. 

  777.   }
    778. 

  778. 

  779.   $end = $pages;
    780. 

  780.   if (($pages-$current-1)>$offset) 
    781. 

  781.     $end = $current+$offset;
    782. 

  782.    
    783. 

  783.   for ($page=$begin; $page<$end; $page++) {
    784. 

  784.     $out .= '&nbsp;';
    785. 

  785.     if ($page == $current) 
    786. 

  786.       $out .= '<b>'.($page+1).'</b>';
    787. 

  787.     else 
    788. 

  788.       $out .= '<a href="?page=transactions&amp;page_number='.$page.'">'.($page+1).'</a>';
    789. 

  789.     $out .= '&nbsp;';
    790. 

  790.   }
    791. 

  791.   if (($pages-1-$current)>$offset) 
    792. 

  792.     $out .= ' <a href="?page=transactions&amp;page_number='.($pages-1).'">&raquo;</a> ';
    793. 

  793.   
    794. 

  794.   $out .= '</div>';
    795. 

  795. 

  796.   if ($display)
    797. 

  797.     echo $out;
    798. 

  798. 

  799.   return $out;
    800. 

  800. }
    801. 

  801. ?>
    802. 

  802.