]> git.p6c8.net - form-email.git/blob - form-email/class.Template.php
Neue Lizenz im Change Log erwaehnen
[form-email.git] / form-email / class.Template.php
1 <?php
2
3 #
4 # Template (Version 2.5)
5 #
6 # Klasse zum Parsen von Templates
7 #
8 # Autor: Patrick Canterino <patrick@patshaping.de>
9 # Letzte Aenderung: 25.11.2011
10 #
11 # Copyright (C) 2002-2011 Patrick Canterino
12 #
13 # Diese Datei kann unter den Bedingungen der "Artistic License 2.0"
14 # weitergegeben und / oder veraendert werden.
15 # Siehe:
16 # http://www.opensource.org/licenses/artistic-license-2.0
17 #
18
19 class Template {
20 var $file;
21 var $template;
22 var $original;
23 var $old_parsing = 0;
24 var $vars = array();
25 var $defined_vars = array();
26 var $loop_vars = array();
27
28 # get_template()
29 #
30 # Kompletten Vorlagentext zurueckgeben
31 #
32 # Parameter: -keine-
33 #
34 # Rueckgabe: Kompletter Vorlagentext (String)
35
36 function get_template() {
37 return $this->template;
38 }
39
40 # set_template()
41 #
42 # Kompletten Vorlagentext aendern
43 #
44 # Parameter: Vorlagentext
45 #
46 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
47
48 function set_template($text) {
49 $this->template = $text;
50 }
51
52 # add_text()
53 #
54 # Vorlagentext ans Template-Objekt anhaengen
55 #
56 # Parameter: Vorlagentext
57 #
58 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
59
60 function add_text($text) {
61 $this->set_template($this->get_template().$text);
62 }
63
64 # read_file()
65 #
66 # Einlesen einer Vorlagendatei und {INCLUDE}-Anweisungen ggf. verarbeiten
67 # (Text wird an bereits vorhandenen Text angehaengt)
68 #
69 # Parameter: 1. Datei zum Einlesen
70 # 2. Status-Code (Boolean):
71 # true => {INCLUDE}-Anweisungen nicht verarbeiten
72 # false => {INCLUDE}-Anweisungen verarbeiten (Standard)
73 #
74 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
75
76 function read_file($file,$not_include=0) {
77 $this->file = $file;
78
79 if(filesize($file) > 0) {
80 $fp = fopen($file,'r');
81 if(!$fp) die;
82 $content = fread($fp,filesize($file));
83 fclose($fp);
84 }
85 else $content = '';
86
87 $this->add_text($content);
88 $this->save_state();
89
90 if(!$not_include) $this->parse_includes();
91 }
92
93 # set_var()
94 #
95 # Wert einer Variable setzen
96 #
97 # Parameter: 1. Name der Variable
98 # 2. Wert, den die Variable erhalten soll
99 #
100 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
101
102 function set_var($var,$content) {
103 $this->vars[$var] = $content;
104 }
105
106 # get_var()
107 #
108 # Wert einer Variable zurueckgeben
109 #
110 # Parameter: (optional) Variablenname
111 #
112 # Rueckgabe: Wert der Variable;
113 # wenn die Variable nicht existiert, false;
114 # wenn kein Variablenname angegeben wurde, wird ein
115 # Array mit den Variablennamen zurueckgegeben
116
117 function get_var($var=false) {
118 if($var !== false) {
119 if(isset($this->vars[$var])) {
120 return $this->vars[$var];
121 }
122 else {
123 return false;
124 }
125 }
126 else {
127 return array_keys($this->vars);
128 }
129 }
130
131 # set_vars()
132 #
133 # Komplettes Variablen-Array mit einem anderen Array ueberschreiben
134 #
135 # Parameter: Array
136 #
137 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
138
139 function set_vars($vars) {
140 $this->vars = $vars;
141 }
142
143 # add_vars()
144 #
145 # Zum bestehenden Variablen-Array weitere Variablen in Form eines Arrays
146 # hinzufuegen
147 #
148 # Parameter: Array
149 #
150 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
151
152 function add_vars($vars) {
153 $this->vars = array_merge($this->vars,$vars);
154 }
155
156 # set_loop_data()
157 #
158 # Daten fuer eine Schleife setzen
159 #
160 # Parameter: 1. Name der Schleife
161 # 2. Array mit den Arrays mit den Variablen fuer
162 # die Schleifendurchgaenge
163 #
164 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
165
166 function set_loop_data($loop,$data) {
167 $this->loop_vars[$loop] = $data;
168 }
169
170 # add_loop_data()
171 #
172 # Daten fuer einen Schleifendurchgang hinzufuegen
173 #
174 # Parameter: 1. Name der Schleife
175 # 2. Array mit den Variablen fuer den
176 # Schleifendurchgang
177 #
178 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
179
180 function add_loop_data($loop,$data) {
181 if(isset($this->loop_vars[$loop]) && is_array($this->loop_vars[$loop])) {
182 array_push($this->loop_vars[$loop],$data);
183 }
184 else {
185 $this->loop_vars[$loop] = array($data);
186 }
187 }
188
189 # parse()
190 #
191 # In der Template definierte Variablen auslesen, Variablen
192 # ersetzen, {IF}- und {TRIM}-Bloecke parsen
193 #
194 # Parameter: -nichts-
195 #
196 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
197
198 function parse() {
199 if($this->old_parsing) return $this->parse_old();
200
201 # Zuerst die Schleifen parsen
202
203 if(is_array($this->loop_vars) && ($loops = array_keys($this->loop_vars))) {
204 foreach($loops as $loop) {
205 $this->parse_loop($loop);
206 }
207 }
208
209 # In Template-Datei definierte Variablen auslesen
210
211 $this->get_defined_vars();
212
213 # Variablen ersetzen
214
215 if(($vars = $this->get_var()) !== false && is_array($vars)) {
216 $this->parse_if_blocks();
217 $this->replace_vars();
218 }
219
220 # {TRIM}-Bloecke entfernen
221
222 $this->parse_trim_blocks();
223 }
224
225 # parse_old()
226 #
227 # In der Template definierte Variablen auslesen, Variablen
228 # ersetzen, {IF}- und {TRIM}-Bloecke parsen
229 # (alte Methode)
230 #
231 # Parameter: -nichts-
232 #
233 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
234
235 function parse_old() {
236 # Zuerst die Schleifen parsen
237
238 if(is_array($this->loop_vars) && ($loops = array_keys($this->loop_vars))) {
239 foreach($loops as $loop) {
240 $this->parse_loop($loop);
241 }
242 }
243
244 # Normale Variablen durchgehen
245
246 if(($vars = $this->get_var()) !== false && is_array($vars)) {
247 foreach($vars as $var) {
248 $val = $this->get_var($var);
249
250 $this->parse_if_block($var,$val);
251
252 if(is_array($val)) {
253 $this->fillin_array($var,$val);
254 }
255 else {
256 $this->fillin($var,$val);
257 }
258
259 unset($val);
260 }
261 }
262
263 # Jetzt dasselbe mit denen, die direkt in der Template-Datei definiert
264 # sind, machen. Ich weiss, dass das eine ziemlich unsaubere Loesung ist,
265 # aber es funktioniert
266
267 $this->get_defined_vars();
268
269 foreach($this->defined_vars as $var) {
270 $val = $this->get_var($var);
271
272 $this->parse_if_block($var,$val);
273 $this->fillin($var,$val);
274
275 unset($val);
276 }
277
278 # {TRIM}-Bloecke entfernen
279
280 $this->parse_trim_blocks();
281 }
282
283 # fillin()
284 #
285 # Variablen durch Text ersetzen
286 #
287 # Parameter: 1. Variable zum Ersetzen
288 # 2. Text, durch den die Variable ersetzt werden soll
289 #
290 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
291
292 function fillin($var,$text) {
293 $template = $this->get_template();
294 $template = str_replace('{'.$var.'}',$text,$template);
295
296 $this->set_template($template);
297 }
298
299 # fillin_array()
300 #
301 # Variable durch Array ersetzen
302 #
303 # Parameter: 1. Variable zum Ersetzen
304 # 2. Array, durch das die Variable ersetzt werden soll
305 # 3. Zeichenkette, mit der das Array verbunden werden soll
306 # (Standard: '')
307 #
308 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
309
310 function fillin_array($var,$array,$glue='') {
311 $this->fillin($var,implode($glue,$array));
312 }
313
314 # replace_vars()
315 #
316 # Variablen eine nach der anderen ersetzen. Sollte in einer Variable eine
317 # andere Variable auftauchen, so wird diese nicht ersetzt.
318 #
319 # Parameter: Array mit zu parsenden Variablen (optional)
320 #
321 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
322
323 function replace_vars($valid=array()) {
324 $template = $this->get_template();
325
326 $valid_vars = (empty($valid)) ? $this->get_var() : $valid;
327
328 for($x=0;$x<strlen($template);$x++) {
329 if($template[$x] == '{') {
330 foreach($valid_vars as $var) {
331 # Pruefen, ob hier eine gueltige Variable beginnt
332
333 if(substr($template,$x+1,strlen($var)+1) == $var.'}') {
334 if(is_array($this->get_var($var))) {
335 $content = implode('',$this->get_var($var));
336 }
337 else {
338 $content = $this->get_var($var);
339 }
340
341 # Daten vor und nach der Variable
342
343 $pre = substr($template,0,$x);
344 $post = substr($template,strlen($pre)+2+strlen($var));
345
346 # Alles neu zusammensetzen
347
348 $template = $pre.$content.$post;
349
350 # Zaehler aendern
351
352 $x = strlen($pre.$content)-1;
353 }
354 }
355 }
356 }
357
358 $this->set_template($template);
359 }
360
361 # to_file()
362 #
363 # Template in Datei schreiben
364 #
365 # Parameter: Datei-Handle
366 #
367 # Rueckgabe: Status-Code (Boolean)
368
369 function to_file($handle) {
370 return @fwrite($handle,$this->get_template());
371 }
372
373 # reset()
374 #
375 # Den gesicherten Stand des Template-Textes wiederherstellen
376 #
377 # Parameter: -nichts-
378 #
379 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
380
381 function reset() {
382 $this->template = $this->original;
383 }
384
385 # save_state()
386 #
387 # Aktuellen Stand des Template-Textes sichern
388 # (alte Sicherung wird ueberschrieben)
389 #
390 # Parameter: -nichts-
391 #
392 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
393
394 function save_state() {
395 $this->original = $this->template;
396 }
397
398 # parse_loop()
399 #
400 # Eine Schleife parsen
401 #
402 # Parameter: Name der Schleife
403 #
404 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
405
406 function parse_loop($name) {
407 $template = $this->get_template();
408 if(strpos($template,'{LOOP '.$name.'}') === false) return;
409
410 $offset = 0;
411 $name_len = strlen($name);
412
413 while(($begin = strpos($template,'{LOOP '.$name.'}',$offset)) !== false) {
414 if(($end = strpos($template,'{ENDLOOP}',$begin+6+$name_len)) !== false) {
415 $block = substr($template,$begin,$end+9-$begin);
416 $content = substr($block,$name_len+7,-9);
417
418 $parsed_block = '';
419
420 for($x=0;$x<count($this->loop_vars[$name]);$x++) {
421 $loop_data = $this->loop_vars[$name][$x];
422 $loop_vars = array_keys($loop_data);
423
424 $ctpl = new Template;
425 $ctpl->set_template($content);
426
427 foreach($loop_vars as $loop_var) {
428 $ctpl->set_var($name.'.'.$loop_var,$loop_data[$loop_var]);
429 }
430
431 if($this->old_parsing) {
432 $ctpl->parse_old();
433 }
434 else {
435 $ctpl->parse();
436 }
437
438 $parsed_block .= $ctpl->get_template();
439
440 unset($ctpl);
441 }
442
443 $template = str_replace($block,$parsed_block,$template);
444 $offset = $begin+strlen($parsed_block);
445 }
446 else break;
447 }
448
449 $this->set_template($template);
450 }
451
452 # get_defined_vars()
453 #
454 # In der Template-Datei definierte Variablen auslesen
455 #
456 # Parameter: -nichts-
457 #
458 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
459
460 function get_defined_vars() {
461 $template = $this->get_template();
462 if(strpos($template,'{DEFINE ') === false) return;
463
464 $offset = 0;
465
466 while(strpos($template,'{DEFINE ',$offset) !== false) {
467 $begin = strpos($template,'{DEFINE ',$offset)+8;
468 $offset = $begin;
469
470 $name = '';
471 $content = '';
472
473 $var_open = 0;
474 $name_found = 0;
475 $define_block = 0;
476
477 for($x=$begin;$x<strlen($template);$x++) {
478 if($template[$x] == "\012" || $template[$x] == "\015") {
479 # Wenn in einem {DEFINE}-Block ein Zeilenumbruch gefunden wird,
480 # brechen wir mit dem Parsen des Blockes ab
481
482 break;
483 }
484
485 if($var_open == 1) {
486 if($template[$x] == '"') {
487 # Der Inhalt der Variable ist hier zu Ende
488
489 $var_open = 0;
490
491 if($template[$x+1] == '}') {
492 # Hier ist der Block zu Ende
493
494 if($this->get_var($name) === false) {
495 # Die Variable wird nur gesetzt, wenn sie nicht bereits gesetzt ist
496
497 $this->set_var($name,$content);
498 array_push($this->defined_vars,$name);
499 }
500
501 # {DEFINE}-Block entfernen
502
503 $pre = substr($template,0,$begin-8);
504 $post = substr($template,$x+2);
505
506 $template = $pre.$post;
507
508 # Fertig!
509
510 $offset = strlen($pre);
511 break;
512 }
513 }
514 elseif($template[$x] == '\\') {
515 # Ein Backslash wurde gefunden, er dient zum Escapen von Zeichen
516
517 if($template[$x+1] == 'n') {
518 # "\n" in Zeilenumbrueche umwandeln
519
520 $content .= "\n";
521 }
522 else $content .= $template[$x+1];
523
524 $x++;
525 }
526 else $content .= $template[$x];
527 }
528 else {
529 if($name_found == 1) {
530 if($var_open == 0) {
531 if($template[$x] == '"') $var_open = 1;
532 else break;
533 }
534 }
535 else {
536 # Variablennamen auslesen
537
538 if($template[$x] == '}' && $name != '') {
539 # Wir haben einen {DEFINE}-Block
540
541 $name_found = 1;
542 $define_block = 1;
543
544 # Alles ab hier sollte mit dem Teil verbunden werden, der das
545 # {DEFINE} in einer Zeile verarbeitet
546
547 # Der Parser fuer {DEFINE}-Bloecke ist nicht rekursiv, was auch
548 # nicht noetig sein sollte
549
550 if(($end = strpos($template,'{ENDDEFINE}',$x)) !== false) {
551 $x++;
552
553 $content = substr($template,$x,$end-$x);
554
555 if($this->get_var($name) === false) {
556 # Die Variable wird nur gesetzt, wenn sie nicht bereits gesetzt ist
557
558 $this->set_var($name,$content);
559 array_push($this->defined_vars,$name);
560 }
561
562 $pre = substr($template,0,$begin-8);
563 $post = substr($template,$end+11);
564
565 $template = $pre.$post;
566
567 # Fertig!
568
569 $offset = strlen($pre);
570 break;
571 }
572 else break;
573 }
574 elseif($template[$x] != ' ') {
575 $name .= $template[$x];
576 }
577 elseif($name != '') {
578 $name_found = 1;
579 }
580 else break;
581 }
582 }
583 }
584 }
585
586 $this->set_template($template);
587 }
588
589 # parse_if_block()
590 #
591 # IF-Bloecke verarbeiten
592 #
593 # Parameter: 1. Name des IF-Blocks (das, was nach dem IF steht)
594 # 2. Status-Code (true => Inhalt anzeigen
595 # false => Inhalt nicht anzeigen
596 # 3. true => Verneinten Block nicht parsen
597 # false => Verneinten Block parsen (Standard)
598 #
599 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
600
601 function parse_if_block($name,$state,$no_negate=0) {
602 $template = $this->get_template();
603
604 $count = 0;
605
606 while(strpos($template,'{IF '.$name.'}') !== false) {
607 # Das alles hier ist nicht wirklich elegant geloest...
608 # ... aber solange es funktioniert... ;-)
609
610 $count++;
611
612 $start = strpos($template,'{IF '.$name.'}');
613 $tpl_tmp = substr($template,$start);
614 $splitted = explode('{ENDIF}',$tpl_tmp);
615
616 $block = ''; # Kompletter bedingter Block
617 $ifs = 0; # IF-Zaehler (wird fuer jedes IF erhoeht und fuer jedes ENDIF erniedrigt)
618
619 # {IF}
620
621 for($x=0;$x<count($splitted);$x++) {
622 if($x == count($splitted)-1) die('Nesting error found while parsing IF block "'.$name.'" nr. '.$count.' in template file "'.$this->file.'"');
623
624 $ifs += substr_count($splitted[$x],'{IF '); # Zum Zaehler jedes Vorkommen von IF hinzuzaehlen
625 $ifs--; # Zaehler um 1 erniedrigen
626 $block .= $splitted[$x].'{ENDIF}'; # Daten zum Block hinzufuegen
627
628 if($ifs == 0) {
629 # Zaehler wieder 0, also haben wir das Ende des IF-Blocks gefunden :-))
630
631 break;
632 }
633 }
634
635 $if_block = substr($block,strlen($name)+5,-7); # Alles zwischen {IF} und {ENDIF}
636
637 # {ELSE}
638
639 $else_block = ''; # Alles ab {ELSE}
640 $ifs = 0; # IF-Zaehler
641
642 $splitted = explode('{ELSE}',$if_block);
643
644 for($x=0;$x<count($splitted);$x++) {
645 $ifs += substr_count($splitted[$x],'{IF '); # Zum Zaehler jedes Vorkommen von IF hinzuzaehlen
646 $ifs -= substr_count($splitted[$x],'{ENDIF}'); # Vom Zaehler jedes Vorkommen von ENDIF abziehen
647
648 if($ifs == 0) {
649 # Zaehler 0, also haben wir das Ende des IF-Abschnitts gefunden
650
651 # Aus dem Rest den ELSE-Block zusammenbauen
652
653 for($y=$x+1;$y<count($splitted);$y++) {
654 $else_block .= '{ELSE}'.$splitted[$y];
655 }
656
657 if($else_block) {
658 $if_block = substr($if_block,0,strlen($if_block)-strlen($else_block));
659 $else_block = substr($else_block,6);
660 }
661
662 break;
663 }
664 }
665
666 # Block durch die jeweiligen Daten ersetzen
667
668 $replacement = ($state) ? $if_block : $else_block;
669
670 $template = str_replace($block,$replacement,$template);
671 }
672
673 $this->set_template($template);
674
675 # Evtl. verneinte Form parsen
676
677 if(!$no_negate) {
678 $this->parse_if_block('!'.$name,!$state,1);
679 }
680 }
681
682 # parse_if_blocks()
683 #
684 # IF-Bloecke zu allen definierten Variablen verarbeiten
685 #
686 # Parameter: Array mit zu verarbeitenden IF-Bloecken (optional)
687 #
688 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
689
690 function parse_if_blocks($valid=array()) {
691 $valid_vars = (empty($valid)) ? $this->get_var() : $valid;
692
693 foreach($valid_vars as $valid_var) {
694 $this->parse_if_block($valid_var,$this->get_var($valid_var));
695 }
696 }
697
698 # parse_trim_blocks()
699 #
700 # {TRIM}-Bloecke parsen
701 #
702 # Dieser Parser ist nicht rekursiv, was auch nicht
703 # noetig sein sollte.
704 #
705 # Parameter: -nichts-
706 #
707 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
708
709 function parse_trim_blocks() {
710 $template = $this->get_template();
711 if(strpos($template,'{TRIM}') === false) return;
712
713 $offset = 0;
714
715 while(($begin = strpos($template,'{TRIM}',$offset)) !== false) {
716 if(($end = strpos($template,'{ENDTRIM}',$begin+6)) !== false) {
717 $block = substr($template,$begin,$end+9-$begin);
718 $content = substr($block,6,-9);
719
720 $trimmed = trim($content);
721
722 $template = str_replace($block,$trimmed,$template);
723
724 $offset = $begin+strlen($trimmed);
725 }
726 else break;
727 }
728
729 $this->set_template($template);
730 }
731
732 # parse_condtag()
733 #
734 # Bedingungstags in einem Vorlagentext verarbeiten
735 #
736 # Parameter: 1. Tagname
737 # 2. Status-Code (true => Tag-Inhalt anzeigen
738 # false => Tag-Inhalt nicht anzeigen
739 #
740 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
741
742 function parse_condtag($condtag,$state) {
743 $template = $this->get_template();
744
745 while(strpos($template,'<'.$condtag.'>') !== false) {
746 $start = strpos($template,'<'.$condtag.'>'); # Beginn des Blocks
747 $end = strpos($template,'</'.$condtag.'>')+strlen($condtag)+3; # Ende des Blocks
748
749 $extract = substr($template,$start,$end-$start); # Kompletten Bedingungsblock extrahieren...
750
751 $replacement = ($state) ? substr($extract,strlen($condtag)+2,0-strlen($condtag)-3) : '';
752
753 $template = str_replace($extract,$replacement,$template); # Block durch neue Daten ersetzen
754 }
755
756 $this->set_template($template);
757 }
758
759 # parse_includes()
760 #
761 # {INCLUDE}-Anweisungen verarbeiten
762 #
763 # Parameter: -nichts-
764 #
765 # Rueckgabe: -nichts- (Template-Objekt wird modifiziert)
766
767 function parse_includes() {
768 $template = $this->get_template();
769 if(strpos($template,'{INCLUDE ') === false) return;
770
771 $offset = 0;
772
773 $y = 0;
774
775 while(($begin = strpos($template,'{INCLUDE ',$offset)) !== false) {
776 $y++;
777
778 $start = $begin+9;
779 $offset = $start;
780 $long = 0;
781
782 if($template[$start] == '"') {
783 $long = 1;
784 $start++;
785 }
786
787 $file = '';
788 $skip = 0;
789
790 for($x=$start;$x<strlen($template);$x++) {
791 if($template[$x] == "\012" || $template[$x] == "\015") {
792 $skip = 1;
793 break;
794 }
795 elseif($long == 0 && $template[$x] == ' ') {
796 $skip = 1;
797 break;
798 }
799 elseif($long == 1 && $template[$x] == '"') {
800 if($template[$x+1] != '}') $skip = 1;
801 break;
802 }
803 elseif($long == 0 && $template[$x] == '}') {
804 break;
805 }
806 else {
807 $file .= $template[$x];
808 }
809 }
810
811 if($skip == 1) continue;
812
813 if($file != '') {
814 $filepath = $file;
815
816 $is_absolute = (strtoupper(substr(PHP_OS,0,3)) === 'WIN')
817 ? preg_match('!^([a-z]:)?/!i',$file)
818 : preg_match('!^/!',$file);
819
820 if(!$is_absolute) {
821 if(!empty($this->file)) $dir = dirname($this->file);
822 else $dir = '.';
823
824 $dir = str_replace('\\','/',$dir);
825
826 if(!preg_match('!/+$!',$dir)) $dir .= '/';
827
828 $filepath = $dir.$file;
829 }
830
831 if(is_file($filepath)) {
832 $inc = new Template;
833 $inc->read_file($filepath);
834
835 $end = ($long == 1)
836 ? $start + strlen($file) + 2
837 : $start + strlen($file) + 1;
838
839 $pre = substr($template,0,$begin);
840 $post = substr($template,$end);
841
842 $template = $pre.$inc->get_template().$post;
843 $offset = strlen($pre)+strlen($inc->get_template());
844
845 unset($inc);
846 }
847 }
848 }
849
850 $this->set_template($template);
851 }
852 }
853
854 #
855 ### Ende ###
856
857 ?>

patrick-canterino.de