|
1 <?php |
|
2 /** |
|
3 * Project: Smarty: the PHP compiling template engine |
|
4 * File: SmartyBC.class.php |
|
5 * SVN: $Id: $ |
|
6 * |
|
7 * This library is free software; you can redistribute it and/or |
|
8 * modify it under the terms of the GNU Lesser General Public |
|
9 * License as published by the Free Software Foundation; either |
|
10 * version 2.1 of the License, or (at your option) any later version. |
|
11 * |
|
12 * This library is distributed in the hope that it will be useful, |
|
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
15 * Lesser General Public License for more details. |
|
16 * |
|
17 * You should have received a copy of the GNU Lesser General Public |
|
18 * License along with this library; if not, write to the Free Software |
|
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
20 * |
|
21 * For questions, help, comments, discussion, etc., please join the |
|
22 * Smarty mailing list. Send a blank e-mail to |
|
23 * smarty-discussion-subscribe@googlegroups.com |
|
24 * |
|
25 * @link http://www.smarty.net/ |
|
26 * @copyright 2008 New Digital Group, Inc. |
|
27 * @author Monte Ohrt <monte at ohrt dot com> |
|
28 * @author Uwe Tews |
|
29 * @author Rodney Rehm |
|
30 * @package Smarty |
|
31 */ |
|
32 /** |
|
33 * @ignore |
|
34 */ |
|
35 require(dirname(__FILE__) . '/Smarty.class.php'); |
|
36 |
|
37 /** |
|
38 * Smarty Backward Compatability Wrapper Class |
|
39 * |
|
40 * @package Smarty |
|
41 */ |
|
42 class SmartyBC extends Smarty { |
|
43 |
|
44 /** |
|
45 * Smarty 2 BC |
|
46 * @var string |
|
47 */ |
|
48 public $_version = self::SMARTY_VERSION; |
|
49 |
|
50 /** |
|
51 * Initialize new SmartyBC object |
|
52 * |
|
53 * @param array $options options to set during initialization, e.g. array( 'forceCompile' => false ) |
|
54 */ |
|
55 public function __construct(array $options=array()) |
|
56 { |
|
57 parent::__construct($options); |
|
58 // register {php} tag |
|
59 $this->registerPlugin('block', 'php', 'smarty_php_tag'); |
|
60 } |
|
61 |
|
62 /** |
|
63 * wrapper for assign_by_ref |
|
64 * |
|
65 * @param string $tpl_var the template variable name |
|
66 * @param mixed &$value the referenced value to assign |
|
67 */ |
|
68 public function assign_by_ref($tpl_var, &$value) |
|
69 { |
|
70 $this->assignByRef($tpl_var, $value); |
|
71 } |
|
72 |
|
73 /** |
|
74 * wrapper for append_by_ref |
|
75 * |
|
76 * @param string $tpl_var the template variable name |
|
77 * @param mixed &$value the referenced value to append |
|
78 * @param boolean $merge flag if array elements shall be merged |
|
79 */ |
|
80 public function append_by_ref($tpl_var, &$value, $merge = false) |
|
81 { |
|
82 $this->appendByRef($tpl_var, $value, $merge); |
|
83 } |
|
84 |
|
85 /** |
|
86 * clear the given assigned template variable. |
|
87 * |
|
88 * @param string $tpl_var the template variable to clear |
|
89 */ |
|
90 public function clear_assign($tpl_var) |
|
91 { |
|
92 $this->clearAssign($tpl_var); |
|
93 } |
|
94 |
|
95 /** |
|
96 * Registers custom function to be used in templates |
|
97 * |
|
98 * @param string $function the name of the template function |
|
99 * @param string $function_impl the name of the PHP function to register |
|
100 * @param bool $cacheable |
|
101 * @param mixed $cache_attrs |
|
102 */ |
|
103 public function register_function($function, $function_impl, $cacheable=true, $cache_attrs=null) |
|
104 { |
|
105 $this->registerPlugin('function', $function, $function_impl, $cacheable, $cache_attrs); |
|
106 } |
|
107 |
|
108 /** |
|
109 * Unregisters custom function |
|
110 * |
|
111 * @param string $function name of template function |
|
112 */ |
|
113 public function unregister_function($function) |
|
114 { |
|
115 $this->unregisterPlugin('function', $function); |
|
116 } |
|
117 |
|
118 /** |
|
119 * Registers object to be used in templates |
|
120 * |
|
121 * @param string $object name of template object |
|
122 * @param object $object_impl the referenced PHP object to register |
|
123 * @param array $allowed list of allowed methods (empty = all) |
|
124 * @param boolean $smarty_args smarty argument format, else traditional |
|
125 * @param array $block_functs list of methods that are block format |
|
126 */ |
|
127 public function register_object($object, $object_impl, $allowed = array(), $smarty_args = true, $block_methods = array()) |
|
128 { |
|
129 settype($allowed, 'array'); |
|
130 settype($smarty_args, 'boolean'); |
|
131 $this->registerObject($object, $object_impl, $allowed, $smarty_args, $block_methods); |
|
132 } |
|
133 |
|
134 /** |
|
135 * Unregisters object |
|
136 * |
|
137 * @param string $object name of template object |
|
138 */ |
|
139 public function unregister_object($object) |
|
140 { |
|
141 $this->unregisterObject($object); |
|
142 } |
|
143 |
|
144 /** |
|
145 * Registers block function to be used in templates |
|
146 * |
|
147 * @param string $block name of template block |
|
148 * @param string $block_impl PHP function to register |
|
149 * @param bool $cacheable |
|
150 * @param mixed $cache_attrs |
|
151 */ |
|
152 public function register_block($block, $block_impl, $cacheable=true, $cache_attrs=null) |
|
153 { |
|
154 $this->registerPlugin('block', $block, $block_impl, $cacheable, $cache_attrs); |
|
155 } |
|
156 |
|
157 /** |
|
158 * Unregisters block function |
|
159 * |
|
160 * @param string $block name of template function |
|
161 */ |
|
162 public function unregister_block($block) |
|
163 { |
|
164 $this->unregisterPlugin('block', $block); |
|
165 } |
|
166 |
|
167 /** |
|
168 * Registers compiler function |
|
169 * |
|
170 * @param string $function name of template function |
|
171 * @param string $function_impl name of PHP function to register |
|
172 * @param bool $cacheable |
|
173 */ |
|
174 public function register_compiler_function($function, $function_impl, $cacheable=true) |
|
175 { |
|
176 $this->registerPlugin('compiler', $function, $function_impl, $cacheable); |
|
177 } |
|
178 |
|
179 /** |
|
180 * Unregisters compiler function |
|
181 * |
|
182 * @param string $function name of template function |
|
183 */ |
|
184 public function unregister_compiler_function($function) |
|
185 { |
|
186 $this->unregisterPlugin('compiler', $function); |
|
187 } |
|
188 |
|
189 /** |
|
190 * Registers modifier to be used in templates |
|
191 * |
|
192 * @param string $modifier name of template modifier |
|
193 * @param string $modifier_impl name of PHP function to register |
|
194 */ |
|
195 public function register_modifier($modifier, $modifier_impl) |
|
196 { |
|
197 $this->registerPlugin('modifier', $modifier, $modifier_impl); |
|
198 } |
|
199 |
|
200 /** |
|
201 * Unregisters modifier |
|
202 * |
|
203 * @param string $modifier name of template modifier |
|
204 */ |
|
205 public function unregister_modifier($modifier) |
|
206 { |
|
207 $this->unregisterPlugin('modifier', $modifier); |
|
208 } |
|
209 |
|
210 /** |
|
211 * Registers a resource to fetch a template |
|
212 * |
|
213 * @param string $type name of resource |
|
214 * @param array $functions array of functions to handle resource |
|
215 */ |
|
216 public function register_resource($type, $functions) |
|
217 { |
|
218 $this->registerResource($type, $functions); |
|
219 } |
|
220 |
|
221 /** |
|
222 * Unregisters a resource |
|
223 * |
|
224 * @param string $type name of resource |
|
225 */ |
|
226 public function unregister_resource($type) |
|
227 { |
|
228 $this->unregisterResource($type); |
|
229 } |
|
230 |
|
231 /** |
|
232 * Registers a prefilter function to apply |
|
233 * to a template before compiling |
|
234 * |
|
235 * @param callable $function |
|
236 */ |
|
237 public function register_prefilter($function) |
|
238 { |
|
239 $this->registerFilter('pre', $function); |
|
240 } |
|
241 |
|
242 /** |
|
243 * Unregisters a prefilter function |
|
244 * |
|
245 * @param callable $function |
|
246 */ |
|
247 public function unregister_prefilter($function) |
|
248 { |
|
249 $this->unregisterFilter('pre', $function); |
|
250 } |
|
251 |
|
252 /** |
|
253 * Registers a postfilter function to apply |
|
254 * to a compiled template after compilation |
|
255 * |
|
256 * @param callable $function |
|
257 */ |
|
258 public function register_postfilter($function) |
|
259 { |
|
260 $this->registerFilter('post', $function); |
|
261 } |
|
262 |
|
263 /** |
|
264 * Unregisters a postfilter function |
|
265 * |
|
266 * @param callable $function |
|
267 */ |
|
268 public function unregister_postfilter($function) |
|
269 { |
|
270 $this->unregisterFilter('post', $function); |
|
271 } |
|
272 |
|
273 /** |
|
274 * Registers an output filter function to apply |
|
275 * to a template output |
|
276 * |
|
277 * @param callable $function |
|
278 */ |
|
279 public function register_outputfilter($function) |
|
280 { |
|
281 $this->registerFilter('output', $function); |
|
282 } |
|
283 |
|
284 /** |
|
285 * Unregisters an outputfilter function |
|
286 * |
|
287 * @param callable $function |
|
288 */ |
|
289 public function unregister_outputfilter($function) |
|
290 { |
|
291 $this->unregisterFilter('output', $function); |
|
292 } |
|
293 |
|
294 /** |
|
295 * load a filter of specified type and name |
|
296 * |
|
297 * @param string $type filter type |
|
298 * @param string $name filter name |
|
299 */ |
|
300 public function load_filter($type, $name) |
|
301 { |
|
302 $this->loadFilter($type, $name); |
|
303 } |
|
304 |
|
305 /** |
|
306 * clear cached content for the given template and cache id |
|
307 * |
|
308 * @param string $tpl_file name of template file |
|
309 * @param string $cache_id name of cache_id |
|
310 * @param string $compile_id name of compile_id |
|
311 * @param string $exp_time expiration time |
|
312 * @return boolean |
|
313 */ |
|
314 public function clear_cache($tpl_file = null, $cache_id = null, $compile_id = null, $exp_time = null) |
|
315 { |
|
316 return $this->clearCache($tpl_file, $cache_id, $compile_id, $exp_time); |
|
317 } |
|
318 |
|
319 /** |
|
320 * clear the entire contents of cache (all templates) |
|
321 * |
|
322 * @param string $exp_time expire time |
|
323 * @return boolean |
|
324 */ |
|
325 public function clear_all_cache($exp_time = null) |
|
326 { |
|
327 return $this->clearCache(null, null, null, $exp_time); |
|
328 } |
|
329 |
|
330 /** |
|
331 * test to see if valid cache exists for this template |
|
332 * |
|
333 * @param string $tpl_file name of template file |
|
334 * @param string $cache_id |
|
335 * @param string $compile_id |
|
336 * @return boolean |
|
337 */ |
|
338 public function is_cached($tpl_file, $cache_id = null, $compile_id = null) |
|
339 { |
|
340 return $this->isCached($tpl_file, $cache_id, $compile_id); |
|
341 } |
|
342 |
|
343 /** |
|
344 * clear all the assigned template variables. |
|
345 */ |
|
346 public function clear_all_assign() |
|
347 { |
|
348 $this->clearAllAssign(); |
|
349 } |
|
350 |
|
351 /** |
|
352 * clears compiled version of specified template resource, |
|
353 * or all compiled template files if one is not specified. |
|
354 * This function is for advanced use only, not normally needed. |
|
355 * |
|
356 * @param string $tpl_file |
|
357 * @param string $compile_id |
|
358 * @param string $exp_time |
|
359 * @return boolean results of {@link smarty_core_rm_auto()} |
|
360 */ |
|
361 public function clear_compiled_tpl($tpl_file = null, $compile_id = null, $exp_time = null) |
|
362 { |
|
363 return $this->clearCompiledTemplate($tpl_file, $compile_id, $exp_time); |
|
364 } |
|
365 |
|
366 /** |
|
367 * Checks whether requested template exists. |
|
368 * |
|
369 * @param string $tpl_file |
|
370 * @return boolean |
|
371 */ |
|
372 public function template_exists($tpl_file) |
|
373 { |
|
374 return $this->templateExists($tpl_file); |
|
375 } |
|
376 |
|
377 /** |
|
378 * Returns an array containing template variables |
|
379 * |
|
380 * @param string $name |
|
381 * @return array |
|
382 */ |
|
383 public function get_template_vars($name=null) |
|
384 { |
|
385 return $this->getTemplateVars($name); |
|
386 } |
|
387 |
|
388 /** |
|
389 * Returns an array containing config variables |
|
390 * |
|
391 * @param string $name |
|
392 * @return array |
|
393 */ |
|
394 public function get_config_vars($name=null) |
|
395 { |
|
396 return $this->getConfigVars($name); |
|
397 } |
|
398 |
|
399 /** |
|
400 * load configuration values |
|
401 * |
|
402 * @param string $file |
|
403 * @param string $section |
|
404 * @param string $scope |
|
405 */ |
|
406 public function config_load($file, $section = null, $scope = 'global') |
|
407 { |
|
408 $this->ConfigLoad($file, $section, $scope); |
|
409 } |
|
410 |
|
411 /** |
|
412 * return a reference to a registered object |
|
413 * |
|
414 * @param string $name |
|
415 * @return object |
|
416 */ |
|
417 public function get_registered_object($name) |
|
418 { |
|
419 return $this->getRegisteredObject($name); |
|
420 } |
|
421 |
|
422 /** |
|
423 * clear configuration values |
|
424 * |
|
425 * @param string $var |
|
426 */ |
|
427 public function clear_config($var = null) |
|
428 { |
|
429 $this->clearConfig($var); |
|
430 } |
|
431 |
|
432 /** |
|
433 * trigger Smarty error |
|
434 * |
|
435 * @param string $error_msg |
|
436 * @param integer $error_type |
|
437 */ |
|
438 public function trigger_error($error_msg, $error_type = E_USER_WARNING) |
|
439 { |
|
440 trigger_error("Smarty error: $error_msg", $error_type); |
|
441 } |
|
442 |
|
443 } |
|
444 |
|
445 /** |
|
446 * Smarty {php}{/php} block function |
|
447 * |
|
448 * @param array $params parameter list |
|
449 * @param string $content contents of the block |
|
450 * @param object $template template object |
|
451 * @param boolean &$repeat repeat flag |
|
452 * @return string content re-formatted |
|
453 */ |
|
454 function smarty_php_tag($params, $content, $template, &$repeat) |
|
455 { |
|
456 eval($content); |
|
457 return ''; |
|
458 } |
|
459 |
|
460 ?> |