Source for file class.Template.inc.php

Documentation is available at class.Template.inc.php

  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.     }

Documentation generated on Mon, 17 Nov 2008 01:10:26 +0100 by phpDocumentor 1.4.0