Subversion Repositories ALCASAR

Rev

Go to most recent revision | Details | Last modification | View Log

Rev Author Line No. Line
325 richard 1 
<?php
2 
  /**************************************************************************\
3 
  * eGroupWare API - Template class                                          *
4 
  * (C) Copyright 1999-2000 NetUSE GmbH Kristian Koehntopp                   *
5 
  * ------------------------------------------------------------------------ *
6 
  * http://www.egroupware.org/                                               *
7 
  * ------------------------------------------------------------------------ *
8 
  * This program is free software; you can redistribute it and/or modify it  *
9 
  * under the terms of the GNU Lesser General Public License as published    *
10 
  * by the Free Software Foundation; either version 2.1 of the License, or   *
11 
  * any later version.                                                       *
12 
  \**************************************************************************/
13 
 
14 
  /* $Id: class.Template.inc.php,v 1.5 2005/11/26 13:01:24 bigmichi1 Exp $ */
15 
 
16 
	class Template
17 
	{
18 
		var $classname = 'Template';
19 
 
20 
		/* if set, echo assignments */
21 
		var $debug = False;
22 
 
23 
		/* $file[handle] = 'filename'; */
24 
		var $file = array();
25 
 
26 
		/* relative filenames are relative to this pathname */
27 
		var $root = '';
28 
 
29 
		/* $varkeys[key] = 'key'; $varvals[key] = 'value'; */
30 
		var $varkeys = array();
31 
		var $varvals = array();
32 
 
33 
		/* 'remove'  => remove undefined variables
34 
		 * 'comment' => replace undefined variables with comments
35 
		 * 'keep'    => keep undefined variables
36 
		 */
37 
		var $unknowns = 'remove';
38 
 
39 
		/* 'yes' => halt, 'report' => report error, continue, 'no' => ignore error quietly */
40 
		var $halt_on_error = 'yes';
41 
 
42 
		/* last error message is retained here */
43 
		var $last_error = '';
44 
 
45 
		/***************************************************************************/
46 
		/* public: Constructor.
47 
		 * root:     template directory.
48 
		 * unknowns: how to handle unknown variables.
49 
		 */
50 
		function Template($root = '.', $unknowns = 'remove')
51 
		{
52 
			$this->set_root($root);
53 
			$this->set_unknowns($unknowns);
54 
		}
55 
 
56 
		/* public: setroot(pathname $root)
57 
		 * root:   new template directory.
58 
		 */
59 
		function set_root($root)
60 
		{
61 
			if (!is_dir($root))
62 
			{
63 
				$this->halt("set_root: $root is not a directory.");
64 
				return false;
65 
			}
66 
			$this->root = $root;
67 
			return true;
68 
		}
69 
 
70 
		/* public: set_unknowns(enum $unknowns)
71 
		 * unknowns: 'remove', 'comment', 'keep'
72 
		 *
73 
		 */
74 
		function set_unknowns($unknowns = 'keep')
75 
		{
76 
			$this->unknowns = $unknowns;
77 
		}
78 
 
79 
		/* public: set_file(array $filelist)
80 
		 * filelist: array of handle, filename pairs.
81 
		 *
82 
		 * public: set_file(string $handle, string $filename)
83 
		 * handle: handle for a filename,
84 
		 * filename: name of template file
85 
		 */
86 
		function set_file($handle, $filename = '')
87 
		{
88 
			if (!is_array($handle))
89 
			{
90 
				if ($filename == '')
91 
				{
92 
					$this->halt("set_file: For handle $handle filename is empty.");
93 
					return false;
94 
				}
95 
				$this->file[$handle] = $this->filename($filename);
96 
			}
97 
			else
98 
			{
99 
				reset($handle);
100 
				while(list($h, $f) = each($handle))
101 
				{
102 
					$this->file[$h] = $this->filename($f);
103 
				}
104 
			}
105 
		}
106 
 
107 
		/* public: set_block(string $parent, string $handle, string $name = '')
108 
		 * extract the template $handle from $parent,
109 
		 * place variable {$name} instead.
110 
		 */
111 
		function set_block($parent, $handle, $name = '')
112 
		{
113 
			if (!$this->loadfile($parent))
114 
			{
115 
				$this->halt("subst: unable to load $parent.");
116 
				return false;
117 
			}
118 
			if ($name == '')
119 
			{
120 
				$name = $handle;
121 
			}
122 
			$str = $this->get_var($parent);
123 
			$reg = "/<!--\s+BEGIN $handle\s+-->(.*)\n\s*<!--\s+END $handle\s+-->/sm";
124 
			preg_match_all($reg, $str, $m);
125 
			$str = preg_replace($reg, '{' . "$name}", $str);
126 
			$this->set_var($handle, $m[1][0]);
127 
			$this->set_var($parent, $str);
128 
		}
129 
 
130 
		/* public: set_var(array $values)
131 
		 * values: array of variable name, value pairs.
132 
		 *
133 
		 * public: set_var(string $varname, string $value)
134 
		 * varname: name of a variable that is to be defined
135 
		 * value:   value of that variable
136 
		 */
137 
		function set_var($varname, $value = '')
138 
		{
139 
			if (!is_array($varname))
140 
			{
141 
				if (!empty($varname))
142 
				{
143 
					if ($this->debug)
144 
					{
145 
						print "scalar: set *$varname* to *$value*<br>\n";
146 
					}
147 
					$this->varkeys[$varname] = $this->varname($varname);
148 
					$this->varvals[$varname] = str_replace('phpGroupWare','eGroupWare',$value);
149 
				}
150 
			}
151 
			else
152 
			{
153 
				reset($varname);
154 
				while(list($k, $v) = each($varname))
155 
				{
156 
					if (!empty($k))
157 
					{
158 
						if ($this->debug)
159 
						{
160 
							print "array: set *$k* to *$v*<br>\n";
161 
						}
162 
						$this->varkeys[$k] = $this->varname($k);
163 
						$this->varvals[$k] = str_replace('phpGroupWare','eGroupWare',$v);
164 
					}
165 
				}
166 
			}
167 
		}
168 
 
169 
		/* public: subst(string $handle)
170 
		 * handle: handle of template where variables are to be substituted.
171 
		 */
172 
		function subst($handle)
173 
		{
174 
			if (!$this->loadfile($handle))
175 
			{
176 
				$this->halt("subst: unable to load $handle.");
177 
				return false;
178 
			}
179 
 
180 
			$str = $this->get_var($handle);
181 
			reset($this->varkeys);
182 
			while (list($k, $v) = each($this->varkeys))
183 
			{
184 
				$str = str_replace($v, $this->varvals[$k], $str);
185 
			}
186 
			return $str;
187 
		}
188 
 
189 
		/* public: psubst(string $handle)
190 
		 * handle: handle of template where variables are to be substituted.
191 
		 */
192 
		function psubst($handle)
193 
		{
194 
			print $this->subst($handle);
195 
			return false;
196 
		}
197 
 
198 
		/* public: parse(string $target, string $handle, boolean append)
199 
		 * public: parse(string $target, array  $handle, boolean append)
200 
		 * target: handle of variable to generate
201 
		 * handle: handle of template to substitute
202 
		 * append: append to target handle
203 
		 */
204 
		function parse($target, $handle, $append = false)
205 
		{
206 
			if (!is_array($handle))
207 
			{
208 
				$str = $this->subst($handle);
209 
				if ($append)
210 
				{
211 
					$this->set_var($target, $this->get_var($target) . $str);
212 
				}
213 
				else
214 
				{
215 
					$this->set_var($target, $str);
216 
				}
217 
			}
218 
			else
219 
			{
220 
				reset($handle);
221 
				while(list($i, $h) = each($handle))
222 
				{
223 
					$str = $this->subst($h);
224 
					$this->set_var($target, $str);
225 
				}
226 
			}
227 
			return $str;
228 
		}
229 
 
230 
		function pparse($target, $handle, $append = false)
231 
		{
232 
			print $this->parse($target, $handle, $append);
233 
			return false;
234 
		}
235 
 
236 
		/* This is short for finish parse */
237 
		function fp($target, $handle, $append = False)
238 
		{
239 
			return $this->finish($this->parse($target, $handle, $append));
240 
		}
241 
 
242 
		/* This is a short cut for print finish parse */
243 
		function pfp($target, $handle, $append = False)
244 
		{
245 
			echo $this->finish($this->parse($target, $handle, $append));
246 
		}
247 
 
248 
		/* public: get_vars()
249 
		 */
250 
		function get_vars()
251 
		{
252 
			reset($this->varkeys);
253 
			while(list($k, $v) = each($this->varkeys))
254 
			{
255 
				$result[$k] = $this->varvals[$k];
256 
			}
257 
			return $result;
258 
		}
259 
 
260 
		/* public: get_var(string varname)
261 
		 * varname: name of variable.
262 
		 *
263 
		 * public: get_var(array varname)
264 
		 * varname: array of variable names
265 
		 */
266 
		function get_var($varname)
267 
		{
268 
			if (!is_array($varname))
269 
			{
270 
				return $this->varvals[$varname];
271 
			}
272 
			else
273 
			{
274 
				reset($varname);
275 
				while(list($k, $v) = each($varname))
276 
				{
277 
					$result[$k] = $this->varvals[$k];
278 
				}
279 
				return $result;
280 
			}
281 
		}
282 
 
283 
		/* public: get_undefined($handle)
284 
		 * handle: handle of a template.
285 
		 */
286 
		function get_undefined($handle)
287 
		{
288 
			if (!$this->loadfile($handle))
289 
			{
290 
				$this->halt("get_undefined: unable to load $handle.");
291 
				return false;
292 
			}
293 
 
294 
			preg_match_all("/\{([^}]+)\}/", $this->get_var($handle), $m);
295 
			$m = $m[1];
296 
			if (!is_array($m))
297 
			{
298 
				return false;
299 
			}
300 
			reset($m);
301 
			while(list($k, $v) = each($m))
302 
			{
303 
				if (!isset($this->varkeys[$v]))
304 
				{
305 
					$result[$v] = $v;
306 
				}
307 
			}
308 
 
309 
			if (count($result))
310 
			{
311 
				return $result;
312 
			}
313 
			else
314 
			{
315 
				return false;
316 
			}
317 
		}
318 
 
319 
		/* public: finish(string $str)
320 
		 * str: string to finish.
321 
		 */
322 
		function finish($str)
323 
		{
324 
			switch ($this->unknowns)
325 
			{
326 
				case 'keep':
327 
					break;
328 
				case 'remove':
329 
					$str = preg_replace('/{[^ \t\r\n}]+}/', '', $str);
330 
					break;
331 
				case 'comment':
332 
					$str = preg_replace('/{([^ \t\r\n}]+)}/', "<!-- Template $handle: Variable \\1 undefined -->", $str);
333 
					break;
334 
			}
335 
 
336 
			return $str;
337 
		}
338 
 
339 
		/* public: p(string $varname)
340 
		 * varname: name of variable to print.
341 
		 */
342 
		function p($varname)
343 
		{
344 
			print $this->finish($this->get_var($varname));
345 
		}
346 
 
347 
		function get($varname)
348 
		{
349 
			return $this->finish($this->get_var($varname));
350 
		}
351 
 
352 
		/***************************************************************************/
353 
		/* private: filename($filename)
354 
		 * filename: name to be completed.
355 
		 */
356 
		function filename($filename,$root='',$time=1)
357 
		{
358 
			if($root=='')
359 
			{
360 
				$root=$this->root;
361 
			}
362 
			if (substr($filename, 0, 1) != '/')
363 
			{
364 
				$new_filename = $root.'/'.$filename;
365 
			}
366 
			else
367 
			{
368 
				$new_filename = $filename;
369 
			}
370 
 
371 
			if (!file_exists($new_filename))
372 
			{
373 
				if($time==2)
374 
				{
375 
					$this->halt("filename: file $new_filename does not exist.");
376 
				}
377 
				else
378 
				{
379 
					$new_root = str_replace($GLOBALS['egw_info']['server']['template_set'],'default',$root);
380 
					$new_filename = $this->filename(str_replace($root.'/','',$new_filename),$new_root,2);
381 
				}
382 
			}
383 
			return $new_filename;
384 
		}
385 
 
386 
		/* private: varname($varname)
387 
		 * varname: name of a replacement variable to be protected.
388 
		 */
389 
		function varname($varname)
390 
		{
391 
			return '{'.$varname.'}';
392 
		}
393 
 
394 
		/* private: loadfile(string $handle)
395 
		 * handle:  load file defined by handle, if it is not loaded yet.
396 
		 */
397 
		function loadfile($handle)
398 
		{
399 
			if (isset($this->varkeys[$handle]) and !empty($this->varvals[$handle]))
400 
			{
401 
				return true;
402 
			}
403 
			if (!isset($this->file[$handle]))
404 
			{
405 
				$this->halt("loadfile: $handle is not a valid handle.");
406 
				return false;
407 
			}
408 
			$filename = $this->file[$handle];
409 
 
410 
			$str = implode('', @file($filename));
411 
			if (empty($str))
412 
			{
413 
				$this->halt("loadfile: While loading $handle, $filename does not exist or is empty.");
414 
				return false;
415 
			}
416 
 
417 
			$this->set_var($handle, $str);
418 
			return true;
419 
		}
420 
 
421 
		/***************************************************************************/
422 
		/* public: halt(string $msg)
423 
		 * msg:    error message to show.
424 
		 */
425 
		function halt($msg)
426 
		{
427 
			$this->last_error = $msg;
428 
 
429 
			if ($this->halt_on_error != 'no')
430 
			{
431 
				$this->haltmsg($msg);
432 
			}
433 
 
434 
			if ($this->halt_on_error == 'yes')
435 
			{
436 
				echo('<b>Halted.</b>');
437 
			}
438 
 
439 
			exit;
440 
		}
441 
 
442 
		/* public, override: haltmsg($msg)
443 
		 * msg: error message to show.
444 
		 */
445 
		function haltmsg($msg)
446 
		{
447 
			printf("<b>Template Error:</b> %s<br>\n", $msg);
448 
		}
449 
	}