Context Navigation

source: trunk/include/template.class.php @ 8170

Last change on this file since 8170 was 8170, checked in by rvelices, 13 years ago
combined css and js are minified
Property svn:eol-style set to `LF`
File size: 36.2 KB

Line
1	<?php
2	// +-----------------------------------------------------------------------+
3	// \| Piwigo - a PHP based picture gallery \|
4	// +-----------------------------------------------------------------------+
5	// \| Copyright(C) 2008-2010 Piwigo Team http://piwigo.org \|
6	// \| Copyright(C) 2003-2008 PhpWebGallery Team http://phpwebgallery.net \|
7	// \| Copyright(C) 2002-2003 Pierrick LE GALL http://le-gall.net/pierrick \|
8	// +-----------------------------------------------------------------------+
9	// \| This program is free software; you can redistribute it and/or modify \|
10	// \| it under the terms of the GNU General Public License as published by \|
11	// \| the Free Software Foundation \|
12	// \| \|
13	// \| This program is distributed in the hope that it will be useful, but \|
14	// \| WITHOUT ANY WARRANTY; without even the implied warranty of \|
15	// \| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU \|
16	// \| General Public License for more details. \|
17	// \| \|
18	// \| You should have received a copy of the GNU General Public License \|
19	// \| along with this program; if not, write to the Free Software \|
20	// \| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, \|
21	// \| USA. \|
22	// +-----------------------------------------------------------------------+
23
24
25	require_once(PHPWG_ROOT_PATH.'include/smarty/libs/Smarty.class.php');
26
27
28	class Template {
29
30	var $smarty;
31
32	var $output = '';
33
34	// Hash of filenames for each template handle.
35	var $files = array();
36
37	// Template extents filenames for each template handle.
38	var $extents = array();
39
40	// Templates prefilter from external sources (plugins)
41	var $external_filters = array();
42
43	// used by html_head smarty block to add content before </head>
44	var $html_head_elements = array();
45
46	const COMBINED_SCRIPTS_TAG = '<!-- COMBINED_SCRIPTS -->';
47	var $scriptLoader;
48
49	const COMBINED_CSS_TAG = '<!-- COMBINED_CSS -->';
50	var $css_by_priority = array();
51
52	function Template($root = ".", $theme= "", $path = "template")
53	{
54	global $conf, $lang_info;
55
56	$this->scriptLoader = new ScriptLoader;
57	$this->smarty = new Smarty;
58	$this->smarty->debugging = $conf['debug_template'];
59	$this->smarty->compile_check = $conf['template_compile_check'];
60	$this->smarty->force_compile = $conf['template_force_compile'];
61
62	if (!isset($conf['local_data_dir_checked']))
63	{
64	mkgetdir($conf['local_data_dir'], MKGETDIR_DEFAULT&~MKGETDIR_DIE_ON_ERROR);
65	if (!is_writable($conf['local_data_dir']))
66	{
67	load_language('admin.lang');
68	fatal_error(
69	sprintf(
70	l10n('Give write access (chmod 777) to "%s" directory at the root of your Piwigo installation'),
71	basename($conf['local_data_dir'])
72	),
73	l10n('an error happened'),
74	false // show trace
75	);
76	}
77	if (function_exists('pwg_query')) {
78	conf_update_param('local_data_dir_checked', 'true');
79	}
80	}
81
82	$compile_dir = $conf['local_data_dir'].'/templates_c';
83	mkgetdir( $compile_dir );
84
85	$this->smarty->compile_dir = $compile_dir;
86
87	$this->smarty->assign_by_ref( 'pwg', new PwgTemplateAdapter() );
88	$this->smarty->register_modifier( 'translate', array('Template', 'mod_translate') );
89	$this->smarty->register_modifier( 'explode', array('Template', 'mod_explode') );
90	$this->smarty->register_modifier( 'get_extent', array(&$this, 'get_extent') );
91	$this->smarty->register_block('html_head', array(&$this, 'block_html_head') );
92	$this->smarty->register_function('combine_script', array(&$this, 'func_combine_script') );
93	$this->smarty->register_function('get_combined_scripts', array(&$this, 'func_get_combined_scripts') );
94	$this->smarty->register_function('combine_css', array(&$this, 'func_combine_css') );
95	$this->smarty->register_function('get_combined_css', array(&$this, 'func_get_combined_css') );
96	$this->smarty->register_block('footer_script', array(&$this, 'block_footer_script') );
97	$this->smarty->register_function('known_script', array(&$this, 'func_known_script') );
98	$this->smarty->register_prefilter( array('Template', 'prefilter_white_space') );
99	if ( $conf['compiled_template_cache_language'] )
100	{
101	$this->smarty->register_prefilter( array('Template', 'prefilter_language') );
102	}
103
104	$this->smarty->template_dir = array();
105	if ( !empty($theme) )
106	{
107	$this->set_theme($root, $theme, $path);
108	$this->set_prefilter( 'header', array('Template', 'prefilter_local_css') );
109	}
110	else
111	$this->set_template_dir($root);
112
113	$this->smarty->assign('lang_info', $lang_info);
114
115	if (!defined('IN_ADMIN') and isset($conf['extents_for_templates']))
116	{
117	$tpl_extents = unserialize($conf['extents_for_templates']);
118	$this->set_extents($tpl_extents, './template-extension/', true, $theme);
119	}
120	}
121
122	/**
123	* Load theme's parameters.
124	*/
125	function set_theme($root, $theme, $path, $load_css=true, $load_local_head=true)
126	{
127	$this->set_template_dir($root.'/'.$theme.'/'.$path);
128
129	$themeconf = $this->load_themeconf($root.'/'.$theme);
130
131	if (isset($themeconf['parent']) and $themeconf['parent'] != $theme)
132	{
133	$this->set_theme(
134	$root,
135	$themeconf['parent'],
136	$path,
137	isset($themeconf['load_parent_css']) ? $themeconf['load_parent_css'] : $load_css,
138	isset($themeconf['load_parent_local_head']) ? $themeconf['load_parent_local_head'] : $load_local_head
139	);
140	}
141
142	$tpl_var = array(
143	'id' => $theme,
144	'load_css' => $load_css,
145	);
146	if (!empty($themeconf['local_head']) and $load_local_head)
147	{
148	$tpl_var['local_head'] = realpath($root.'/'.$theme.'/'.$themeconf['local_head'] );
149	}
150	$themeconf['id'] = $theme;
151	$this->smarty->append('themes', $tpl_var);
152	$this->smarty->append('themeconf', $themeconf, true);
153	}
154
155	/**
156	* Add template directory for this Template object.
157	* Set compile id if not exists.
158	*/
159	function set_template_dir($dir)
160	{
161	$this->smarty->template_dir[] = $dir;
162
163	if (!isset($this->smarty->compile_id))
164	{
165	$real_dir = realpath($dir);
166	$compile_id = crc32( $real_dir===false ? $dir : $real_dir);
167	$this->smarty->compile_id = base_convert($compile_id, 10, 36 );
168	}
169	}
170
171	/**
172	* Gets the template root directory for this Template object.
173	*/
174	function get_template_dir()
175	{
176	return $this->smarty->template_dir;
177	}
178
179	/**
180	* Deletes all compiled templates.
181	*/
182	function delete_compiled_templates()
183	{
184	$save_compile_id = $this->smarty->compile_id;
185	$this->smarty->compile_id = null;
186	$this->smarty->clear_compiled_tpl();
187	$this->smarty->compile_id = $save_compile_id;
188	file_put_contents($this->smarty->compile_dir.'/index.htm', 'Not allowed!');
189	FileCombiner::clear_combined_files();
190	}
191
192	function get_themeconf($val)
193	{
194	$tc = $this->smarty->get_template_vars('themeconf');
195	return isset($tc[$val]) ? $tc[$val] : '';
196	}
197
198	/**
199	* Sets the template filename for handle.
200	*/
201	function set_filename($handle, $filename)
202	{
203	return $this->set_filenames( array($handle=>$filename) );
204	}
205
206	/**
207	* Sets the template filenames for handles. $filename_array should be a
208	* hash of handle => filename pairs.
209	*/
210	function set_filenames($filename_array)
211	{
212	if (!is_array($filename_array))
213	{
214	return false;
215	}
216	reset($filename_array);
217	while(list($handle, $filename) = each($filename_array))
218	{
219	if (is_null($filename))
220	{
221	unset($this->files[$handle]);
222	}
223	else
224	{
225	$this->files[$handle] = $this->get_extent($filename, $handle);
226	}
227	}
228	return true;
229	}
230
231	/**
232	* Sets template extention filename for handles.
233	*/
234	function set_extent($filename, $param, $dir='', $overwrite=true, $theme='N/A')
235	{
236	return $this->set_extents(array($filename => $param), $dir, $overwrite);
237	}
238
239	/**
240	* Sets template extentions filenames for handles.
241	* $filename_array should be an hash of filename => array( handle, param) or filename => handle
242	*/
243	function set_extents($filename_array, $dir='', $overwrite=true, $theme='N/A')
244	{
245	if (!is_array($filename_array))
246	{
247	return false;
248	}
249	foreach ($filename_array as $filename => $value)
250	{
251	if (is_array($value))
252	{
253	$handle = $value[0];
254	$param = $value[1];
255	$thm = $value[2];
256	}
257	elseif (is_string($value))
258	{
259	$handle = $value;
260	$param = 'N/A';
261	$thm = 'N/A';
262	}
263	else
264	{
265	return false;
266	}
267
268	if ((stripos(implode('',array_keys($_GET)), '/'.$param) !== false or $param == 'N/A')
269	and ($thm == $theme or $thm == 'N/A')
270	and (!isset($this->extents[$handle]) or $overwrite)
271	and file_exists($dir . $filename))
272	{
273	$this->extents[$handle] = realpath($dir . $filename);
274	}
275	}
276	return true;
277	}
278
279	/** return template extension if exists */
280	function get_extent($filename='', $handle='')
281	{
282	if (isset($this->extents[$handle]))
283	{
284	$filename = $this->extents[$handle];
285	}
286	return $filename;
287	}
288
289	/** see smarty assign http://www.smarty.net/manual/en/api.assign.php */
290	function assign($tpl_var, $value = null)
291	{
292	$this->smarty->assign( $tpl_var, $value );
293	}
294
295	/**
296	* Inserts the uncompiled code for $handle as the value of $varname in the
297	* root-level. This can be used to effectively include a template in the
298	* middle of another template.
299	* This is equivalent to assign($varname, $this->parse($handle, true))
300	*/
301	function assign_var_from_handle($varname, $handle)
302	{
303	$this->assign($varname, $this->parse($handle, true));
304	return true;
305	}
306
307	/** see smarty append http://www.smarty.net/manual/en/api.append.php */
308	function append($tpl_var, $value=null, $merge=false)
309	{
310	$this->smarty->append( $tpl_var, $value, $merge );
311	}
312
313	/**
314	* Root-level variable concatenation. Appends a string to an existing
315	* variable assignment with the same name.
316	*/
317	function concat($tpl_var, $value)
318	{
319	$old_val = & $this->smarty->get_template_vars($tpl_var);
320	if ( isset($old_val) )
321	{
322	$old_val .= $value;
323	}
324	else
325	{
326	$this->assign($tpl_var, $value);
327	}
328	}
329
330	/** see smarty append http://www.smarty.net/manual/en/api.clear_assign.php */
331	function clear_assign($tpl_var)
332	{
333	$this->smarty->clear_assign( $tpl_var );
334	}
335
336	/** see smarty get_template_vars http://www.smarty.net/manual/en/api.get_template_vars.php */
337	function &get_template_vars($name=null)
338	{
339	return $this->smarty->get_template_vars( $name );
340	}
341
342
343	/**
344	* Load the file for the handle, eventually compile the file and run the compiled
345	* code. This will add the output to the results or return the result if $return
346	* is true.
347	*/
348	function parse($handle, $return=false)
349	{
350	if ( !isset($this->files[$handle]) )
351	{
352	fatal_error("Template->parse(): Couldn't load template file for handle $handle");
353	}
354
355	$this->smarty->assign( 'ROOT_URL', get_root_url() );
356
357	$save_compile_id = $this->smarty->compile_id;
358	$this->load_external_filters($handle);
359
360	global $conf, $lang_info;
361	if ( $conf['compiled_template_cache_language'] and isset($lang_info['code']) )
362	{
363	$this->smarty->compile_id .= '.'.$lang_info['code'];
364	}
365
366	$v = $this->smarty->fetch($this->files[$handle], null, null, false);
367
368	$this->smarty->compile_id = $save_compile_id;
369	$this->unload_external_filters($handle);
370
371	if ($return)
372	{
373	return $v;
374	}
375	$this->output .= $v;
376	}
377
378	/**
379	* Load the file for the handle, eventually compile the file and run the compiled
380	* code. This will print out the results of executing the template.
381	*/
382	function pparse($handle)
383	{
384	$this->parse($handle, false);
385	$this->flush();
386	}
387
388	function flush()
389	{
390	if (!$this->scriptLoader->did_head())
391	{
392	$pos = strpos( $this->output, self::COMBINED_SCRIPTS_TAG );
393	if ($pos !== false)
394	{
395	$scripts = $this->scriptLoader->get_head_scripts();
396	$content = array();
397	foreach ($scripts as $script)
398	{
399	$content[]=
400	'<script type="text/javascript" src="'
401	. self::make_script_src($script)
402	.'"></script>';
403	}
404
405	$this->output = substr_replace( $this->output, "\n".implode( "\n", $content ), $pos, strlen(self::COMBINED_SCRIPTS_TAG) );
406	} //else maybe error or warning ?
407	}
408
409	if(!empty($this->css_by_priority))
410	{
411	ksort($this->css_by_priority);
412
413	global $conf;
414	$css = array();
415	if ($conf['template_combine_files'])
416	{
417	$combiner = new FileCombiner('css');
418	foreach ($this->css_by_priority as $files)
419	{
420	foreach ($files as $file_ver)
421	$combiner->add( $file_ver[0], $file_ver[1] );
422	}
423	if ( $combiner->combine( $out_file, $out_version) )
424	$css[] = array($out_file, $out_version);
425	}
426	else
427	{
428	foreach ($this->css_by_priority as $files)
429	$css = array_merge($css, $files);
430	}
431
432	$content = array();
433	foreach( $css as $file_ver )
434	{
435	$href = get_root_url() . $file_ver[0];
436	if ($file_ver[1] !== false)
437	$href .= '?v' . ($file_ver[1] ? $file_ver[1] : PHPWG_VERSION);
438	// trigger the event for eventual use of a cdn
439	$href = trigger_event('combined_css', $href, $file_ver[0], $file_ver[1]);
440	$content[] = '<link rel="stylesheet" type="text/css" href="'.$href.'">';
441	}
442	$this->output = str_replace(self::COMBINED_CSS_TAG,
443	implode( "\n", $content ),
444	$this->output );
445	}
446
447	if ( count($this->html_head_elements) )
448	{
449	$search = "\n</head>";
450	$pos = strpos( $this->output, $search );
451	if ($pos !== false)
452	{
453	$this->output = substr_replace( $this->output, "\n".implode( "\n", $this->html_head_elements ), $pos, 0 );
454	} //else maybe error or warning ?
455	$this->html_head_elements = array();
456	}
457
458	echo $this->output;
459	$this->output='';
460	}
461
462	/** flushes the output */
463	function p()
464	{
465	$this->flush();
466
467	if ($this->smarty->debugging)
468	{
469	global $t2;
470	$this->smarty->assign(
471	array(
472	'AAAA_DEBUG_TOTAL_TIME__' => get_elapsed_time($t2, get_moment())
473	)
474	);
475	require_once(SMARTY_CORE_DIR . 'core.display_debug_console.php');
476	echo smarty_core_display_debug_console(null, $this->smarty);
477	}
478	}
479
480	/**
481	* translate variable modifier - translates a text to the currently loaded
482	* language
483	*/
484	static function mod_translate($text)
485	{
486	return l10n($text);
487	}
488
489	/**
490	* explode variable modifier - similar to php explode
491	* 'Yes;No'\|@explode:';' -> array('Yes', 'No')
492	*/
493	static function mod_explode($text, $delimiter=',')
494	{
495	return explode($delimiter, $text);
496	}
497
498	/**
499	* This smarty "html_head" block allows to add content just before
500	* </head> element in the output after the head has been parsed. This is
501	* handy in order to respect strict standards when <style> and <link>
502	* html elements must appear in the <head> element
503	*/
504	function block_html_head($params, $content, &$smarty, &$repeat)
505	{
506	$content = trim($content);
507	if ( !empty($content) )
508	{ // second call
509	$this->html_head_elements[] = $content;
510	}
511	}
512
513	/**
514	* This smarty "known_script" functions allows to insert well known java scripts
515	* such as prototype, jquery, etc... only once. Examples:
516	* {known_script id="jquery" src="{$ROOT_URL}template-common/lib/jquery.packed.js"}
517	*/
518	function func_known_script($params, &$smarty )
519	{
520	if (!isset($params['id']))
521	{
522	$smarty->trigger_error("known_script: missing 'id' parameter");
523	return;
524	}
525	$id = $params['id'];
526	trigger_error("known_script is deprecated $id ".@$params['src'], E_USER_WARNING);
527	if ('jquery'==$id)
528	{
529	$this->scriptLoader->add($id, 0, array(), null);
530	return;
531	}
532	if (! isset( $this->known_scripts[$id] ) )
533	{
534	if (!isset($params['src']))
535	{
536	$smarty->trigger_error("known_script: missing 'src' parameter");
537	return;
538	}
539	$this->known_scripts[$id] = $params['src'];
540	$content = '<script type="text/javascript" src="'.$params['src'].'"></script>';
541	if (isset($params['now']) and $params['now'] and empty($this->output) )
542	{
543	return $content;
544	}
545	$repeat = false;
546	$this->block_html_head(null, $content, $smarty, $repeat);
547	}
548	}
549
550	function func_combine_script($params, &$smarty)
551	{
552	if (!isset($params['id']))
553	{
554	$smarty->trigger_error("combine_script: missing 'id' parameter", E_USER_ERROR);
555	}
556	$load = 0;
557	if (isset($params['load']))
558	{
559	switch ($params['load'])
560	{
561	case 'header': break;
562	case 'footer': $load=1; break;
563	case 'async': $load=2; break;
564	default: $smarty->trigger_error("combine_script: invalid 'load' parameter", E_USER_ERROR);
565	}
566	}
567	$this->scriptLoader->add( $params['id'], $load,
568	empty($params['require']) ? array() : explode( ',', $params['require'] ),
569	@$params['path'],
570	isset($params['version']) ? $params['version'] : 0 );
571	}
572
573
574	function func_get_combined_scripts($params, &$smarty)
575	{
576	if (!isset($params['load']))
577	{
578	$smarty->trigger_error("get_combined_scripts: missing 'load' parameter", E_USER_ERROR);
579	}
580	$load = $params['load']=='header' ? 0 : 1;
581	$content = array();
582
583	if ($load==0)
584	{
585	return self::COMBINED_SCRIPTS_TAG;
586	}
587	else
588	{
589	$scripts = $this->scriptLoader->get_footer_scripts();
590	foreach ($scripts[0] as $script)
591	{
592	$content[]=
593	'<script type="text/javascript" src="'
594	. self::make_script_src($script)
595	.'"></script>';
596	}
597	if (count($this->scriptLoader->inline_scripts))
598	{
599	$content[]= '<script type="text/javascript">';
600	$content = array_merge($content, $this->scriptLoader->inline_scripts);
601	$content[]= '</script>';
602	}
603
604	if (count($scripts[1]))
605	{
606	$content[]= '<script type="text/javascript">';
607	$content[]= '(function() {
608	var after = document.getElementsByTagName(\'script\')[document.getElementsByTagName(\'script\').length-1];
609	var s;';
610	foreach ($scripts[1] as $id => $script)
611	{
612	$content[]=
613	's=document.createElement(\'script\'); s.type = \'text/javascript\'; s.async = true; s.src = \''
614	. self::make_script_src($script)
615	.'\';';
616	$content[]= 'after = after.parentNode.insertBefore(s, after);';
617	}
618	$content[]= '})();';
619	$content[]= '</script>';
620	}
621	}
622	return implode("\n", $content);
623	}
624
625
626	private static function make_script_src( $script )
627	{
628	$ret = '';
629	if ( $script->is_remote() )
630	$ret = $script->path;
631	else
632	{
633	$ret = get_root_url().$script->path;
634	if ($script->version!==false)
635	{
636	$ret.= '?v'. ($script->version ? $script->version : PHPWG_VERSION);
637	}
638	}
639	// trigger the event for eventual use of a cdn
640	$ret = trigger_event('combined_script', $ret, $script);
641	return $ret;
642	}
643
644	function block_footer_script($params, $content, &$smarty, &$repeat)
645	{
646	$content = trim($content);
647	if ( !empty($content) )
648	{ // second call
649	$this->scriptLoader->add_inline( $content, @$params['require'] );
650	}
651	}
652
653	function func_combine_css($params, &$smarty)
654	{
655	!empty($params['path']) \|\| fatal_error('combine_css missing path');
656	$order = (int)@$params['order'];
657	$version = isset($params['version']) ? $params['version'] : 0;
658	$this->css_by_priority[$order][] = array( $params['path'], $version);
659	}
660
661	function func_get_combined_css($params, &$smarty)
662	{
663	return self::COMBINED_CSS_TAG;
664	}
665
666
667	/**
668	* This function allows to declare a Smarty prefilter from a plugin, thus allowing
669	* it to modify template source before compilation and without changing core files
670	* They will be processed by weight ascending.
671	* http://www.smarty.net/manual/en/advanced.features.prefilters.php
672	*/
673	function set_prefilter($handle, $callback, $weight=50)
674	{
675	$this->external_filters[$handle][$weight][] = array('prefilter', $callback);
676	ksort($this->external_filters[$handle]);
677	}
678
679	function set_postfilter($handle, $callback, $weight=50)
680	{
681	$this->external_filters[$handle][$weight][] = array('postfilter', $callback);
682	ksort($this->external_filters[$handle]);
683	}
684
685	function set_outputfilter($handle, $callback, $weight=50)
686	{
687	$this->external_filters[$handle][$weight][] = array('outputfilter', $callback);
688	ksort($this->external_filters[$handle]);
689	}
690
691	/**
692	* This function actually triggers the filters on the tpl files.
693	* Called in the parse method.
694	* http://www.smarty.net/manual/en/advanced.features.prefilters.php
695	*/
696	function load_external_filters($handle)
697	{
698	if (isset($this->external_filters[$handle]))
699	{
700	$compile_id = '';
701	foreach ($this->external_filters[$handle] as $filters)
702	{
703	foreach ($filters as $filter)
704	{
705	list($type, $callback) = $filter;
706	$compile_id .= $type.( is_array($callback) ? implode('', $callback) : $callback );
707	call_user_func(array($this->smarty, 'register_'.$type), $callback);
708	}
709	}
710	$this->smarty->compile_id .= '.'.base_convert(crc32($compile_id), 10, 36);
711	}
712	}
713
714	function unload_external_filters($handle)
715	{
716	if (isset($this->external_filters[$handle]))
717	{
718	foreach ($this->external_filters[$handle] as $filters)
719	{
720	foreach ($filters as $filter)
721	{
722	list($type, $callback) = $filter;
723	call_user_func(array($this->smarty, 'unregister_'.$type), $callback);
724	}
725	}
726	}
727	}
728
729	static function prefilter_white_space($source, &$smarty)
730	{
731	$ld = $smarty->left_delimiter;
732	$rd = $smarty->right_delimiter;
733	$ldq = preg_quote($ld, '#');
734	$rdq = preg_quote($rd, '#');
735
736	$regex = array();
737	$tags = array('if', 'foreach', 'section');
738	foreach($tags as $tag)
739	{
740	array_push($regex, "#^[ \t]+($ldq$tag"."[^$ld$rd]$rdq)\s$#m");
741	array_push($regex, "#^[ \t]+($ldq/$tag$rdq)\s*$#m");
742	}
743	$tags = array('include', 'else', 'html_head');
744	foreach($tags as $tag)
745	{
746	array_push($regex, "#^[ \t]+($ldq$tag"."[^$ld$rd]$rdq)\s$#m");
747	}
748	$source = preg_replace( $regex, "$1", $source);
749	return $source;
750	}
751
752	/**
753	* Smarty prefilter to allow caching (whenever possible) language strings
754	* from templates.
755	*/
756	static function prefilter_language($source, &$smarty)
757	{
758	global $lang;
759	$ldq = preg_quote($smarty->left_delimiter, '~');
760	$rdq = preg_quote($smarty->right_delimiter, '~');
761
762	$regex = "~$ldq \'([^'$]+)\'\\|@translate $rdq~";
763	$source = preg_replace( $regex.'e', 'isset($lang[\'$1\']) ? $lang[\'$1\'] : \'$0\'', $source);
764
765	$regex = "~$ldq *\'([^'$]+)\'\\|@translate\\|~";
766	$source = preg_replace( $regex.'e', 'isset($lang[\'$1\']) ? \'{\'.var_export($lang[\'$1\'],true).\'\|\' : \'$0\'', $source);
767
768	$regex = "~($ldq *assign +var=.+ +value=)\'([^'$]+)\'\\|@translate~e";
769	$source = preg_replace( $regex, 'isset($lang[\'$2\']) ? \'$1\'.var_export($lang[\'$2\'],true) : \'$0\'', $source);
770
771	return $source;
772	}
773
774	static function prefilter_local_css($source, &$smarty)
775	{
776	$css = array();
777	foreach ($smarty->get_template_vars('themes') as $theme)
778	{
779	$f = 'local/css/'.$theme['id'].'-rules.css';
780	if (file_exists(PHPWG_ROOT_PATH.$f))
781	{
782	array_push($css, "{combine_css path='$f' order=10}");
783	}
784	}
785	$f = 'local/css/rules.css';
786	if (file_exists(PHPWG_ROOT_PATH.$f))
787	{
788	array_push($css, "{combine_css path='$f' order=10}");
789	}
790
791	if (!empty($css))
792	{
793	$source = str_replace("\n{get_combined_css}", "\n".implode( "\n", $css )."\n{get_combined_css}", $source);
794	}
795
796	return $source;
797	}
798
799	function load_themeconf($dir)
800	{
801	global $themeconfs, $conf;
802
803	$dir = realpath($dir);
804	if (!isset($themeconfs[$dir]))
805	{
806	$themeconf = array();
807	include($dir.'/themeconf.inc.php');
808	// Put themeconf in cache
809	$themeconfs[$dir] = $themeconf;
810	}
811	return $themeconfs[$dir];
812	}
813	}
814
815
816	/**
817	* This class contains basic functions that can be called directly from the
818	* templates in the form $pwg->l10n('edit')
819	*/
820	class PwgTemplateAdapter
821	{
822	function l10n($text)
823	{
824	return l10n($text);
825	}
826
827	function l10n_dec($s, $p, $v)
828	{
829	return l10n_dec($s, $p, $v);
830	}
831
832	function sprintf()
833	{
834	$args = func_get_args();
835	return call_user_func_array('sprintf', $args );
836	}
837	}
838
839
840	final class Script
841	{
842	public $id;
843	public $load_mode;
844	public $precedents = array();
845	public $path;
846	public $version;
847	public $extra = array();
848
849	function Script($load_mode, $id, $path, $version, $precedents)
850	{
851	$this->id = $id;
852	$this->load_mode = $load_mode;
853	$this->id = $id;
854	$this->set_path($path);
855	$this->version = $version;
856	$this->precedents = $precedents;
857	}
858
859	function set_path($path)
860	{
861	if (!empty($path))
862	$this->path = $path;
863	}
864
865	function is_remote()
866	{
867	return url_is_remote( $this->path );
868	}
869	}
870
871
872	/** Manage a list of required scripts for a page, by optimizing their loading location (head, bottom, async)
873	and later on by combining them in a unique file respecting at the same time dependencies.*/
874	class ScriptLoader
875	{
876	private $registered_scripts;
877	public $inline_scripts;
878
879	private $did_head;
880	private $head_done_scripts;
881
882	private static $known_paths = array(
883	'core.scripts' => 'themes/default/js/scripts.js',
884	'jquery' => 'themes/default/js/jquery.min.js',
885	'jquery.ui' => 'themes/default/js/ui/packed/ui.core.packed.js'
886	);
887
888	function __construct()
889	{
890	$this->clear();
891	}
892
893	function clear()
894	{
895	$this->registered_scripts = array();
896	$this->inline_scripts = array();
897	$this->head_done_scripts = array();
898	$this->did_head = false;
899	}
900
901	function add_inline($code, $require)
902	{
903	if(!empty($require))
904	{
905	if(!isset($this->registered_scripts[$require]))
906	fatal_error("inline script not found require $require");
907	$s = $this->registered_scripts[$require];
908	if($s->load_mode==2)
909	$s->load_mode=1; // until now the implementation does not allow executing inline script depending on another async script
910	}
911	$this->inline_scripts[] = $code;
912	}
913
914	function add($id, $load_mode, $require, $path, $version=0)
915	{
916	if ($this->did_head && $load_mode==0 )
917	{
918	trigger_error("Attempt to add a new script $id but the head has been written", E_USER_WARNING);
919	}
920	if (! isset( $this->registered_scripts[$id] ) )
921	{
922	$script = new Script($load_mode, $id, $path, $version, $require);
923	self::fill_well_known($id, $script);
924	$this->registered_scripts[$id] = $script;
925	}
926	else
927	{
928	$script = & $this->registered_scripts[$id];
929	if (count($require))
930	{
931	$script->precedents = array_unique( array_merge($script->precedents, $require) );
932	}
933	$script->set_path($path);
934	if ($version && version_compare($script->version, $version)<0 )
935	$script->version = $version;
936	if ($load_mode < $script->load_mode)
937	$script->load_mode = $load_mode;
938	}
939	}
940
941	function did_head()
942	{
943	return $this->did_head;
944	}
945
946	function get_head_scripts()
947	{
948	self::check_load_dep($this->registered_scripts);
949	foreach( array_keys($this->registered_scripts) as $id )
950	{
951	$this->compute_script_topological_order($id);
952	}
953
954	uasort($this->registered_scripts, array('ScriptLoader', 'cmp_by_mode_and_order'));
955
956	foreach( $this->registered_scripts as $id => $script)
957	{
958	if ($script->load_mode > 0)
959	break;
960	if ( !empty($script->path) )
961	$this->head_done_scripts[$id] = $script;
962	else
963	trigger_error("Script $id has an undefined path", E_USER_WARNING);
964	}
965	$this->did_head = true;
966	return self::do_combine($this->head_done_scripts, 0);
967	}
968
969	function get_footer_scripts()
970	{
971	/*if (!$this->did_head)
972	{
973	trigger_error("Attempt to write footer scripts without header scripts", E_USER_ERROR );
974	}*/
975	$todo = array();
976	foreach( $this->registered_scripts as $id => $script)
977	{
978	if (!isset($this->head_done_scripts[$id]))
979	{
980	$todo[$id] = $script;
981	}
982	}
983	foreach( array_keys($todo) as $id )
984	{
985	$this->compute_script_topological_order($id);
986	}
987
988	uasort($todo, array('ScriptLoader', 'cmp_by_mode_and_order'));
989
990	$result = array( array(), array() );
991	foreach( $todo as $id => $script)
992	{
993	$result[$script->load_mode-1][$id] = $script;
994	}
995	return array( self::do_combine($result[0],1), self::do_combine($result[1],2) );
996	}
997
998	private static function do_combine($scripts, $load_mode)
999	{
1000	global $conf;
1001	if (count($scripts)<2 or !$conf['template_combine_files'])
1002	return $scripts;
1003	$combiner = new FileCombiner('js');
1004	foreach ($scripts as $script)
1005	{
1006	if ($script->is_remote()) fatal_error("NOT IMPLEMENTED");// TODO - we cannot combine remote scripts
1007	$combiner->add( $script->path, $script->version );
1008	}
1009	if ( $combiner->combine( $out_file, $out_version) )
1010	{
1011	return array( 'combi' => new Script($load_mode, 'combi', $out_file, $out_version, array() ) );
1012	}
1013	return null;
1014	}
1015
1016	// checks that if B depends on A, then B->load_mode >= A->load_mode in order to respect execution order
1017	private static function check_load_dep($scripts)
1018	{
1019	global $conf;
1020	do
1021	{
1022	$changed = false;
1023	foreach( $scripts as $id => $script)
1024	{
1025	$load = $script->load_mode;
1026	if ($load==0)
1027	continue;
1028	foreach( $script->precedents as $precedent)
1029	{
1030	if ( !isset($scripts[$precedent] ) )
1031	continue;
1032	if ( $scripts[$precedent]->load_mode > $load )
1033	{
1034	$scripts[$precedent]->load_mode = $load;
1035	$changed = true;
1036	}
1037	if ($load==2 && $scripts[$precedent]->load_mode==2 && ($script->is_remote() or !$conf['template_combine_files']) )
1038	{// we are async -> a predecessor cannot be async unlesss it can be merged; otherwise script execution order is not guaranteed
1039	$scripts[$precedent]->load_mode = 1;
1040	$changed = true;
1041	}
1042	}
1043	}
1044	}
1045	while ($changed);
1046	}
1047
1048
1049	private static function fill_well_known($id, $script)
1050	{
1051	if ( empty($script->path) && isset(self::$known_paths[$id]))
1052	{
1053	$script->path = self::$known_paths[$id];
1054	}
1055	if ( strncmp($id, 'jquery.', 7)==0 )
1056	{
1057	if ( !in_array('jquery', $script->precedents ) )
1058	$script->precedents[] = 'jquery';
1059	if ( strncmp($id, 'jquery.ui.', 10)==0 && !in_array('jquery.ui', $script->precedents ) )
1060	$script->precedents[] = 'jquery.ui';
1061	}
1062	}
1063
1064	private function compute_script_topological_order($script_id, $recursion_limiter=0)
1065	{
1066	if (!isset($this->registered_scripts[$script_id]))
1067	{
1068	trigger_error("Undefined script $script_id is required by someone", E_USER_WARNING);
1069	return 0;
1070	}
1071	$recursion_limiter<5 or fatal_error("combined script circular dependency");
1072	$script = & $this->registered_scripts[$script_id];
1073	if (isset($script->extra['order']))
1074	return $script->extra['order'];
1075	if (count($script->precedents) == 0)
1076	return ($script->extra['order'] = 0);
1077	$max = 0;
1078	foreach( $script->precedents as $precedent)
1079	$max = max($max, $this->compute_script_topological_order($precedent, $recursion_limiter+1) );
1080	$max++;
1081	return ($script->extra['order'] = $max);
1082	}
1083
1084	private static function cmp_by_mode_and_order($s1, $s2)
1085	{
1086	$ret = $s1->load_mode - $s2->load_mode;
1087	if ($ret) return $ret;
1088
1089	$ret = $s1->extra['order'] - $s2->extra['order'];
1090	if ($ret) return $ret;
1091
1092	if ($s1->extra['order']==0 and ($s1->is_remote() xor $s2->is_remote()) )
1093	{
1094	return $s1->is_remote() ? -1 : 1;
1095	}
1096	return strcmp($s1->id,$s2->id);
1097	}
1098	}
1099
1100
1101	/Allows merging of javascript and css files into a single one./
1102	final class FileCombiner
1103	{
1104	const OUT_SUB_DIR = 'local/combined/';
1105	private $type; // js or css
1106	private $files = array();
1107	private $versions = array();
1108
1109	function FileCombiner($type)
1110	{
1111	$this->type = $type;
1112	}
1113
1114	static function clear_combined_files()
1115	{
1116	$dir = opendir(PHPWG_ROOT_PATH.self::OUT_SUB_DIR);
1117	while ($file = readdir($dir))
1118	{
1119	if ( get_extension($file)=='js' \|\| get_extension($file)=='css')
1120	unlink(PHPWG_ROOT_PATH.self::OUT_SUB_DIR.$file);
1121	}
1122	closedir($dir);
1123	}
1124
1125	function add($file, $version)
1126	{
1127	$this->files[] = $file;
1128	$this->versions[] = $version;
1129	}
1130
1131	function clear()
1132	{
1133	$this->files = array();
1134	$this->versions = array();
1135	}
1136
1137	function combine(&$out_file, &$out_version)
1138	{
1139	if (count($this->files) == 0)
1140	{
1141	return false;
1142	}
1143	if (count($this->files) == 1)
1144	{
1145	$out_file = $this->files[0];
1146	$out_version = $this->versions[0];
1147	$this->clear();
1148	return 1;
1149	}
1150
1151	$is_css = $this->type == "css";
1152	global $conf;
1153	$key = array();
1154	if ($is_css)
1155	$key[] = get_absolute_root_url(false);//because we modify bg url
1156	for ($i=0; $i<count($this->files); $i++)
1157	{
1158	$key[] = $this->files[$i];
1159	$key[] = $this->versions[$i];
1160	if ($conf['template_compile_check']) $key[] = filemtime( PHPWG_ROOT_PATH . $this->files[$i] );
1161	}
1162	$key = join('>', $key);
1163
1164	$file = base_convert(crc32($key),10,36);
1165	$file = self::OUT_SUB_DIR . $file . '.' . $this->type;
1166
1167	$exists = file_exists( PHPWG_ROOT_PATH . $file );
1168	if ($exists)
1169	{
1170	$is_reload =
1171	(isset($_SERVER['HTTP_CACHE_CONTROL']) && strpos($_SERVER['HTTP_CACHE_CONTROL'], 'max-age=0') !== false)
1172	\|\| (isset($_SERVER['HTTP_PRAGMA']) && strpos($_SERVER['HTTP_PRAGMA'], 'no-cache'));
1173	if ($is_reload)
1174	{// the user pressed F5 in the browser
1175	if ($is_css \|\| $conf['template_compile_check']==false)
1176	$exists = false; // we foce regeneration of css because @import sub-files are never checked for modification
1177	}
1178	}
1179
1180	if ($exists)
1181	{
1182	$out_file = $file;
1183	$out_version = false;
1184	$this->clear();
1185	return 2;
1186	}
1187
1188	$output = '';
1189	$output .= "/* ".count($this->files)."\n".join("\n", $this->files)."*/\n";
1190	foreach ($this->files as $input_file)
1191	{
1192	$output .= "/* BEGIN $input_file */\n";
1193	if ($is_css)
1194	$output .= self::process_css($input_file);
1195	else
1196	$output .= self::process_js($input_file);
1197	$output .= "\n";
1198	}
1199
1200	file_put_contents( PHPWG_ROOT_PATH . $file, $output );
1201	$out_file = $file;
1202	$out_version = false;
1203	$this->clear();
1204	return 2;
1205	}
1206
1207	private static function process_js($file)
1208	{
1209	$js = file_get_contents(PHPWG_ROOT_PATH . $file);
1210	if (strpos($file, '.min')===false and strpos($file, '.packed')===false )
1211	{
1212	require_once(PHPWG_ROOT_PATH.'include/jsmin.class.php');
1213	try { $js = JSMin::minify($js); } catch(Exception $e) {}
1214	}
1215	return $js;
1216	}
1217
1218	private static function process_css($file)
1219	{
1220	$css = self::process_css_rec($file);
1221	require_once(PHPWG_ROOT_PATH.'include/cssmin.class.php');
1222	$css = CssMin::minify($css, array('emulate-css3-variables'=>false));
1223	return $css;
1224	}
1225
1226	private static function process_css_rec($file)
1227	{
1228	static $PATTERN = "#url\(\s['\|\"]{0,1}(.?)['\|\"]{0,1}\s*\)#";
1229	$css = file_get_contents(PHPWG_ROOT_PATH . $file);
1230	if (preg_match_all($PATTERN, $css, $matches, PREG_SET_ORDER))
1231	{
1232	$search = $replace = array();
1233	foreach ($matches as $match)
1234	{
1235	if ( !url_is_remote($match[1]) \|\| $match[1][0] != '/')
1236	{
1237	$relative = dirname($file) . "/$match[1]";
1238	$search[] = $match[0];
1239	$replace[] = "url('" . get_absolute_root_url(false) . $relative . "')";
1240	}
1241	}
1242	$css = str_replace($search, $replace, $css);
1243	}
1244
1245	$imports = preg_match_all("#@import\s['\|\"]{0,1}(.?)['\|\"]{0,1};#", $css, $matches, PREG_SET_ORDER);
1246	if ($imports)
1247	{
1248	$search = $replace = array();
1249	foreach ($matches as $match)
1250	{
1251	$search[] = $match[0];
1252	$replace[] = self::process_css_rec(dirname($file) . "/$match[1]");
1253	}
1254	$css = str_replace($search, $replace, $css);
1255	}
1256	return $css;
1257	}
1258	}
1259
1260	?>

Note: See TracBrowser for help on using the repository browser.

Download in other formats: