home *** CD-ROM | disk | FTP | other *** search
/ Cricao de Sites - 650 Layouts Prontos / WebMasters.iso / Servidores / xampp-win32-1.6.7-installer.exe / php / PEAR / HTML / Template / Flexy.php next >
Encoding:
PHP Script  |  2008-07-02  |  28.6 KB  |  823 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP Version 4                                                        |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2003 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.02 of the PHP license,      |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Author:  Alan Knowles <alan@akbkhome.com>
  17. // | Original Author: Wolfram Kriesing <wolfram@kriesing.de>             |
  18. // +----------------------------------------------------------------------+
  19. //
  20.  
  21. /**
  22. *   @package    HTML_Template_Flexy
  23. */
  24. // prevent disaster when used with xdebug! 
  25. @ini_set('xdebug.max_nesting_level', 1000);
  26.  
  27. /*
  28. * Global variable - used to store active options when compiling a template.
  29. */
  30. $GLOBALS['_HTML_TEMPLATE_FLEXY'] = array(); 
  31.  
  32. // ERRORS:
  33.  
  34. /**
  35.  * Workaround for stupid depreciation of is_a...
  36.  */
  37. function HTML_Template_Flexy_is_a($obj, $class)  // which f***wit depreciated is_a....
  38. {
  39.     if (version_compare(phpversion(),"5","<")) {
  40.        return is_a($obj, $class);
  41.        
  42.     } 
  43.     $test=false; 
  44.     @eval("\$test = \$obj instanceof ".$class.";");
  45.     return $test;
  46.  
  47. }
  48.  
  49.  
  50.  
  51. define('HTML_TEMPLATE_FLEXY_ERROR_SYNTAX',-1);  // syntax error in template.
  52. define('HTML_TEMPLATE_FLEXY_ERROR_INVALIDARGS',-2);  // bad arguments to methods.
  53. define('HTML_TEMPLATE_FLEXY_ERROR_FILE',-2);  // file access problem
  54.  
  55. define('HTML_TEMPLATE_FLEXY_ERROR_RETURN',1);  // RETURN ERRORS
  56. define('HTML_TEMPLATE_FLEXY_ERROR_DIE',8);  // FATAL DEATH
  57. /**
  58. * A Flexible Template engine - based on simpletemplate  
  59. *
  60. * @abstract Long Description
  61. *  Have a look at the package description for details.
  62. *
  63. * usage: 
  64. * $template = new HTML_Template_Flexy($options);
  65. * $template->compiler('/name/of/template.html');
  66. * $data =new StdClass
  67. * $data->text = 'xxxx';
  68. * $template->outputObject($data,$elements)
  69. *
  70. * Notes:
  71. * $options can be blank if so, it is read from 
  72. * PEAR::getStaticProperty('HTML_Template_Flexy','options');
  73. *
  74. * the first argument to outputObject is an object (which could even be an 
  75. * associateve array cast to an object) - I normally send it the controller class.
  76. * the seconde argument '$elements' is an array of HTML_Template_Flexy_Elements
  77. * eg. array('name'=> new HTML_Template_Flexy_Element('',array('value'=>'fred blogs'));
  78. * 
  79. *
  80. *
  81. *
  82. * @version    $Id: Flexy.php,v 1.100 2008/02/27 05:56:32 alan_k Exp $
  83. */
  84.  
  85.  
  86.  
  87. class HTML_Template_Flexy  
  88. {
  89.  
  90.     /* 
  91.     *   @var    array   $options    the options for initializing the template class
  92.     */
  93.     var $options = array(   
  94.         'compileDir'    =>  '',         // where do you want to write to.. (defaults to session.save_path)
  95.         'templateDir'   =>  '',         // where are your templates
  96.         
  97.         // where the template comes from. ------------------------------------------
  98.         'multiSource'   => false,       // Allow same template to exist in multiple places
  99.                                         // So you can have user themes....
  100.         'templateDirOrder' => '',       // set to 'reverse' to assume that first template
  101.         
  102.          
  103.         'debug'         => false,       // prints a few messages
  104.         
  105.         
  106.         // compiling conditions ------------------------------------------
  107.         'compiler'      => 'Flexy',  // which compiler to use. (Flexy,Regex, Raw,Xipe)
  108.         'forceCompile'  =>  false,      // only suggested for debugging
  109.  
  110.         // regex Compiler       ------------------------------------------
  111.         'filters'       => array(),     // used by regex compiler.
  112.         
  113.         // standard Compiler    ------------------------------------------
  114.         'nonHTML'       => false,       // dont parse HTML tags (eg. email templates)
  115.         'allowPHP'      => false,       // allow PHP in template (use true=allow, 'delete' = remove it.)
  116.         
  117.         'flexyIgnore'   => 0,           // turn on/off the tag to element code
  118.         'numberFormat'  => ",2,'.',','",  // default number format  {xxx:n} format = eg. 1,200.00 
  119.         
  120.         'url_rewrite'   => '',          // url rewriting ability:
  121.                                         // eg. "images/:test1/images/,js/:test1/js"
  122.                                         // changes href="images/xxx" to href="test1/images/xxx"
  123.                                         // and src="js/xxx.js" to src="test1/js/xxx.js"
  124.                                         
  125.         'compileToString' => false,     // should the compiler return a string 
  126.                                         // rather than writing to a file.
  127.         'privates'      => false,       // allow access to _variables (eg. suido privates
  128.         'globals'       => false,       // allow access to _GET/_POST/_REQUEST/GLOBALS/_COOKIES/_SESSION
  129.  
  130.         'globalfunctions' => false,     // allow GLOBALS.date(#d/m/Y#) to have access to all PHP's methods
  131.                                         // warning dont use unless you trust the template authors
  132.                                         // exec() becomes exposed.
  133.          
  134.         // get text/transalation suppport ------------------------------------------
  135.         //  (flexy compiler only)
  136.         'locale'        => 'en',        // works with gettext or File_Gettext
  137.         'textdomain'    => '',          // for gettext emulation with File_Gettext
  138.                                         // eg. 'messages' (or you can use the template name.
  139.         'textdomainDir' => '',          // eg. /var/www/site.com/locale
  140.                                         // so the french po file is:
  141.                                         // /var/www/site.com/local/fr/LC_MESSAGE/{textdomain}.po
  142.         
  143.         'Translation2'  => false,       // to make Translation2 a provider.
  144.                                         // rather than gettext.
  145.                                         // set to:
  146.                                         //  'Translation2' => array(
  147.                                         //         'driver' => 'dataobjectsimple',
  148.                                         //         'options' => array()
  149.                                         //  );
  150.                                         // or the slower way.. 
  151.                                         //   = as it requires loading the code..
  152.                                         //
  153.                                         //  'Translation2' => new Translation2('dataobjectsimple','')
  154.                                         
  155.       
  156.         'charset'       => 'ISO-8859-1',    // charset used with htmlspecialchars to render data.
  157.                                             // experimental
  158.         
  159.         // output options           ------------------------------------------
  160.         'strict'        => false,       // All elements in the template must be defined - 
  161.                                         // makes php E_NOTICE warnings appear when outputing template.
  162.                                         
  163.         'fatalError'    => HTML_TEMPLATE_FLEXY_ERROR_DIE,       // default behavior is to die on errors in template.
  164.         
  165.         'plugins'       => array(),     // load classes to be made available via the plugin method
  166.                                         // eg. = array('Savant') - loads the Savant methods.
  167.                                         // = array('MyClass_Plugins' => 'MyClass/Plugins.php')
  168.                                         //    Class, and where to include it from..
  169.     ); 
  170.     /**
  171.     * The compiled template filename (Full path)
  172.     *
  173.     * @var string
  174.     * @access public
  175.     */
  176.     var $compiledTemplate;
  177.     /**
  178.     * The source template filename (Full path)
  179.     *
  180.     * @var string
  181.     * @access public
  182.     */
  183.     
  184.     
  185.     var $currentTemplate;
  186.     
  187.     /**
  188.     * The getTextStrings Filename
  189.     *
  190.     * @var string
  191.     * @access public
  192.     */
  193.     var $getTextStringsFile;
  194.     /**
  195.     * The serialized elements array file.
  196.     *
  197.     * @var string
  198.     * @access public
  199.     */
  200.     var $elementsFile;
  201.     
  202.      
  203.     /**
  204.     * Array of HTML_elements which is displayed on the template
  205.     * 
  206.     * Technically it's private (eg. only the template uses it..)
  207.     * 
  208.     *
  209.     * @var array of  HTML_Template_Flexy_Elements
  210.     * @access private
  211.     */
  212.     var $elements = array();
  213.     /**
  214.     *   Constructor 
  215.     *
  216.     *   Initializes the Template engine, for each instance, accepts options or
  217.     *   reads from PEAR::getStaticProperty('HTML_Template_Flexy','options');
  218.     *
  219.     *   @access public
  220.     *   @param    array    $options (Optional)
  221.     */
  222.       
  223.     function HTML_Template_Flexy( $options=array() )
  224.     {
  225.         
  226.         $baseoptions = array();
  227.         if (class_exists('PEAR')) {
  228.             $baseoptions = &PEAR::getStaticProperty('HTML_Template_Flexy','options');
  229.         }
  230.         if ($baseoptions ) {
  231.             foreach( $baseoptions as  $key=>$aOption)  {
  232.                 $this->options[$key] = $aOption;
  233.             }
  234.         }
  235.         
  236.         foreach( $options as $key=>$aOption)  {
  237.            $this->options[$key] = $aOption;
  238.         }
  239.         
  240.         $filters = $this->options['filters'];
  241.         if (is_string($filters)) {
  242.             $this->options['filters']= explode(',',$filters);
  243.         }
  244.         
  245.         if (is_string($this->options['templateDir'])) {
  246.             $this->options['templateDir'] = explode(PATH_SEPARATOR,$this->options['templateDir'] );
  247.         }
  248.          
  249.        
  250.     }
  251.  
  252.    
  253.       
  254.  
  255.  
  256.     /**
  257.     *   compile the template
  258.     *
  259.     *   @access     public
  260.     *   @version    01/12/03
  261.     *   @author     Wolfram Kriesing <wolfram@kriesing.de>
  262.     *   @param      string  $file   relative to the 'templateDir' which you set when calling the constructor
  263.     *   @return     boolean true on success. (or string, if compileToString) PEAR_Error on failure..
  264.     */
  265.     function compile( $file )
  266.     {
  267.         if (!$file) {
  268.             return $this->raiseError('HTML_Template_Flexy::compile no file selected',
  269.                 HTML_TEMPLATE_FLEXY_ERROR_INVALIDARGS,HTML_TEMPLATE_FLEXY_ERROR_DIE);
  270.         }
  271.         
  272.         if (!@$this->options['locale']) {
  273.             $this->options['locale']='en';
  274.         }
  275.         
  276.         
  277.         //Remove the slash if there is one in front, just to be safe.
  278.         $file = ltrim($file,DIRECTORY_SEPARATOR);
  279.         
  280.         
  281.         if (strpos($file,'#')) {
  282.             list($file,$this->options['output.block']) = explode('#', $file);
  283.         }
  284.         
  285.         $parts = array();
  286.         $tmplDirUsed = false;
  287.         
  288.         // PART A mulitlanguage support: ( part B is gettext support in the engine..) 
  289.         //    - user created language version of template.
  290.         //    - compile('abcdef.html') will check for compile('abcdef.en.html') 
  291.         //       (eg. when locale=en)
  292.         
  293.         $this->currentTemplate  = false;
  294.         
  295.         if (preg_match('/(.*)(\.[a-z]+)$/i',$file,$parts)) {
  296.             $newfile = $parts[1].'.'.$this->options['locale'] .$parts[2];
  297.             foreach ($this->options['templateDir'] as $tmplDir) {
  298.                 if (@!file_exists($tmplDir . DIRECTORY_SEPARATOR .$newfile)) {
  299.                     continue;
  300.                 }
  301.                 $file = $newfile;
  302.                 $this->currentTemplate = $tmplDir . DIRECTORY_SEPARATOR .$newfile;
  303.                 $tmplDirUsed = $tmplDir;
  304.             }
  305.         }
  306.         
  307.         // look in all the posible locations for the template directory..
  308.         if ($this->currentTemplate  === false) {
  309.             $dirs = array_unique($this->options['templateDir']);
  310.             if ($this->options['templateDirOrder'] == 'reverse') {
  311.                 $dirs = array_reverse($dirs);
  312.             }
  313.             foreach ($dirs as $tmplDir) {
  314.                 if (!@file_exists($tmplDir . DIRECTORY_SEPARATOR . $file))  {
  315.                     continue;
  316.                 }
  317.                  
  318.                     
  319.                 if (!$this->options['multiSource'] && ($this->currentTemplate  !== false)) {
  320.                     return $this->raiseError("You have more than one template Named {$file} in your paths, found in both".
  321.                         "<BR>{$this->currentTemplate }<BR>{$tmplDir}" . DIRECTORY_SEPARATOR . $file,  
  322.                         HTML_TEMPLATE_FLEXY_ERROR_INVALIDARGS , HTML_TEMPLATE_FLEXY_ERROR_DIE);
  323.                     
  324.                 }
  325.                 
  326.                 $this->currentTemplate = $tmplDir . DIRECTORY_SEPARATOR . $file;
  327.                 $tmplDirUsed = $tmplDir;
  328.             }
  329.         }
  330.         if ($this->currentTemplate === false)  {
  331.             // check if the compile dir has been created
  332.             return $this->raiseError("Could not find Template {$file} in any of the directories<br>" . 
  333.                 implode("<BR>",$this->options['templateDir']) ,
  334.                 HTML_TEMPLATE_FLEXY_ERROR_INVALIDARGS, HTML_TEMPLATE_FLEXY_ERROR_DIE);
  335.         }
  336.         
  337.         
  338.         // Savant compatible compiler 
  339.         
  340.         if ( is_string( $this->options['compiler'] ) && ($this->options['compiler'] == 'Raw')) {
  341.             $this->compiledTemplate = $this->currentTemplate;
  342.             $this->debug("Using Raw Compiler");
  343.             return true;
  344.         }
  345.         
  346.         
  347.         
  348.         
  349.         // now for the compile target 
  350.         
  351.         //If you are working with mulitple source folders and $options['multiSource'] is set
  352.         //the template folder will be:
  353.         // compiled_tempaltes/{templatedir_basename}_{md5_of_dir}/
  354.         
  355.         
  356.         $compileSuffix = ((count($this->options['templateDir']) > 1) && $this->options['multiSource']) ? 
  357.             DIRECTORY_SEPARATOR  .basename($tmplDirUsed) . '_' .md5($tmplDirUsed) : '';
  358.         
  359.         
  360.         $compileDest = @$this->options['compileDir'];
  361.         
  362.         $isTmp = false;
  363.         // Use a default compile directory if one has not been set. 
  364.         if (!@$compileDest) {
  365.             // Use session.save_path + 'compiled_templates_' + md5(of sourcedir)
  366.             $compileDest = ini_get('session.save_path') .  DIRECTORY_SEPARATOR . 'flexy_compiled_templates';
  367.             if (!file_exists($compileDest)) {
  368.                 require_once 'System.php';
  369.                 System::mkdir(array('-p',$compileDest));
  370.             }
  371.             $isTmp = true;
  372.         
  373.         }
  374.         
  375.          
  376.         
  377.         // we generally just keep the directory structure as the application uses it,
  378.         // so we dont get into conflict with names
  379.         // if we have multi sources we do md5 the basedir..
  380.         
  381.        
  382.         $base = $compileDest . $compileSuffix . DIRECTORY_SEPARATOR .$file;
  383.         $fullFile = $this->compiledTemplate    = $base .'.'.$this->options['locale'].'.php';
  384.         $this->getTextStringsFile  = $base .'.gettext.serial';
  385.         $this->elementsFile        = $base .'.elements.serial';
  386.         if (isset($this->options['output.block'])) {
  387.             $this->compiledTemplate    .= '#'.$this->options['output.block'];
  388.         }
  389.           
  390.         $recompile = false;
  391.         
  392.         $isuptodate = file_exists($this->compiledTemplate)   ?
  393.             (filemtime($this->currentTemplate) == filemtime( $this->compiledTemplate)) : 0;
  394.             
  395.         if( @$this->options['forceCompile'] || !$isuptodate ) {
  396.             $recompile = true;
  397.         } else {
  398.             $this->debug("File looks like it is uptodate.");
  399.             return true;
  400.         }
  401.         
  402.         
  403.         
  404.         
  405.         if( !@is_dir($compileDest) || !is_writeable($compileDest)) {
  406.             require_once 'System.php';
  407.             
  408.             System::mkdir(array('-p',$compileDest));
  409.         }
  410.         if( !@is_dir($compileDest) || !is_writeable($compileDest)) {
  411.             return $this->raiseError(   "can not write to 'compileDir', which is <b>'$compileDest'</b><br>".
  412.                             "Please give write and enter-rights to it",
  413.                             HTML_TEMPLATE_FLEXY_ERROR_FILE, HTML_TEMPLATE_FLEXY_ERROR_DIE);
  414.         }
  415.         
  416.         if (!file_exists(dirname($this->compiledTemplate))) {
  417.             require_once 'System.php';
  418.             System::mkdir(array('-p','-m', 0770, dirname($this->compiledTemplate)));
  419.         }
  420.          
  421.         // Compile the template in $file. 
  422.         
  423.         require_once 'HTML/Template/Flexy/Compiler.php';
  424.         $compiler = HTML_Template_Flexy_Compiler::factory($this->options);
  425.         $ret = $compiler->compile($this);
  426.         if (HTML_Template_Flexy_is_a($ret,'PEAR_Error')) {
  427.             return $this->raiseError('HTML_Template_Flexy fatal error:' .$ret->message,
  428.                 $ret->code,  HTML_TEMPLATE_FLEXY_ERROR_DIE);
  429.         }
  430.         return $ret;
  431.         
  432.         //return $this->$method();
  433.         
  434.     }
  435.  
  436.      /**
  437.     *  compiles all templates
  438.     *  Used for offline batch compilation (eg. if your server doesn't have write access to the filesystem).
  439.     *
  440.     *   @access     public
  441.     *   @author     Alan Knowles <alan@akbkhome.com>
  442.     *
  443.     */
  444.     function compileAll($dir = '',$regex='/.html$/')
  445.     {
  446.         
  447.         require_once 'HTML/Template/Flexy/Compiler.php';
  448.         $c = new HTML_Template_Flexy_Compiler;
  449.         $c->compileAll($this,$dir,$regex);
  450.     } 
  451.     
  452.     /**
  453.     *   Outputs an object as $t 
  454.     *
  455.     *   for example the using simpletags the object's variable $t->test
  456.     *   would map to {test}
  457.     *
  458.     *   @version    01/12/14
  459.     *   @access     public
  460.     *   @author     Alan Knowles
  461.     *   @param    object   to output  
  462.     *   @param    array  HTML_Template_Flexy_Elements (or any object that implements toHtml())
  463.     *   @return     none
  464.     */
  465.     
  466.     
  467.     function outputObject(&$t,$elements=array()) 
  468.     {
  469.         if (!is_array($elements)) {
  470.             return $this->raiseError(
  471.                 'second Argument to HTML_Template_Flexy::outputObject() was an '.gettype($elements) . ', not an array',
  472.                 HTML_TEMPLATE_FLEXY_ERROR_INVALIDARGS ,HTML_TEMPLATE_FLEXY_ERROR_DIE);
  473.         }
  474.         if (@$this->options['debug']) {
  475.             echo "output $this->compiledTemplate<BR>";
  476.         }
  477.   
  478.         // this may disappear later it's a Backwards Compatibility fudge to try 
  479.         // and deal with the first stupid design decision to not use a second argument
  480.         // to the method.
  481.        
  482.         if (count($this->elements) && !count($elements)) {
  483.             $elements = $this->elements;
  484.         }
  485.         // end depreciated code
  486.         
  487.         
  488.         $this->elements = $this->getElements();
  489.         
  490.         // Overlay values from $elements to $this->elements (which is created from the template)
  491.         // Remove keys with no corresponding value.
  492.         foreach($elements as $k=>$v) {
  493.             // Remove key-value pair from $this->elements if hasn't a value in $elements.
  494.             if (!$v) {
  495.                 unset($this->elements[$k]);
  496.             }
  497.             // Add key-value pair to $this->$elements if it's not there already.
  498.             if (!isset($this->elements[$k])) {
  499.                 $this->elements[$k] = $v;
  500.                 continue;
  501.             }
  502.             // Call the clever element merger - that understands form values and 
  503.             // how to display them...
  504.             $this->elements[$k] = $this->mergeElement($this->elements[$k] ,$v);
  505.         }
  506.         //echo '<PRE>'; print_r(array($elements,$this->elements));
  507.       
  508.         
  509.         // we use PHP's error handler to hide errors in the template.
  510.         // use $options['strict'] - if you want to force declaration of
  511.         // all variables in the template
  512.         
  513.         
  514.         $_error_reporting = false;
  515.         if (!$this->options['strict']) {
  516.             $_error_reporting = error_reporting(E_ALL ^ E_NOTICE);
  517.         }
  518.         if (!is_readable($this->compiledTemplate)) {
  519.               return $this->raiseError( "Could not open the template: <b>'{$this->compiledTemplate}'</b><BR>".
  520.                             "Please check the file permissions on the directory and file ",
  521.                             HTML_TEMPLATE_FLEXY_ERROR_FILE, HTML_TEMPLATE_FLEXY_ERROR_DIE);
  522.         }
  523.         
  524.         // are we using the assign api!
  525.         
  526.         if (isset($this->assign)) {
  527.             if (!$t) {
  528.                 $t = (object) $this->assign->variables;
  529.             }
  530.             extract($this->assign->variables);
  531.             foreach(array_keys($this->assign->references) as $_k) {
  532.                 $$_k = &$this->assign->references[$_k];
  533.             }
  534.         }
  535.         // used by Flexy Elements etc..
  536.         $GLOBALS['_HTML_TEMPLATE_FLEXY']['options']  = $this->options;
  537.         
  538.         include($this->compiledTemplate);
  539.         
  540.         // Return the error handler to its previous state. 
  541.         
  542.         if ($_error_reporting !== false) {
  543.             error_reporting($_error_reporting);
  544.         }
  545.     }
  546.     /**
  547.     *   Outputs an object as $t, buffers the result and returns it.
  548.     *
  549.     *   See outputObject($t) for more details.
  550.     *
  551.     *   @version    01/12/14
  552.     *   @access     public
  553.     *   @author     Alan Knowles
  554.     *   @param      object object to output as $t
  555.     *   @return     string - result
  556.     */
  557.     function bufferedOutputObject(&$t,$elements=array()) 
  558.     {
  559.         ob_start();
  560.         $this->outputObject($t,$elements);
  561.         $data = ob_get_contents();
  562.         ob_end_clean();
  563.         return $data;
  564.     }
  565.     /**
  566.     * static version which does new, compile and output all in one go.
  567.     *
  568.     *   See outputObject($t) for more details.
  569.     *
  570.     *   @version    01/12/14
  571.     *   @access     public
  572.     *   @author     Alan Knowles
  573.     *   @param      object object to output as $t
  574.     *   @param      filename of template
  575.     *   @return     string - result
  576.     */
  577.     function &staticQuickTemplate($file,&$t) 
  578.     {
  579.         $template = new HTML_Template_Flexy;
  580.         $template->compile($file);
  581.         $template->outputObject($t);
  582.     }
  583.     
  584.     /**
  585.     *   if debugging is on, print the debug info to the screen
  586.     *
  587.     *   @access     public
  588.     *   @author     Alan Knowles <alan@akbkhome.com>
  589.     *   @param      string  $string       output to display
  590.     *   @return     none
  591.     */
  592.     function debug($string) 
  593.     {  
  594.         
  595.         
  596.         if (HTML_Template_Flexy_is_a($this,'HTML_Template_Flexy')) {
  597.             if (!$this->options['debug']) {
  598.                 return;
  599.             }
  600.         } else if (empty($GLOBALS['_HTML_TEMPLATE_FLEXY']['debug'])) {
  601.             return;
  602.         }
  603.         
  604.         echo "<PRE><B>FLEXY DEBUG:</B> $string</PRE>";
  605.         
  606.     }
  607.  
  608.    
  609.  
  610.     
  611.     /**
  612.      * A general Utility method that merges HTML_Template_Flexy_Elements
  613.      * Static method - no native debug avaiable..
  614.      *
  615.      * @param    HTML_Template_Flexy_Element   $original  (eg. from getElements())
  616.      * @param    HTML_Template_Flexy_Element   $new (with data to replace/merge)
  617.      * @return   HTML_Template_Flexy_Element   the combined/merged data.
  618.      * @static
  619.      * @access   public
  620.      */
  621.      
  622.     function mergeElement($original,$new)
  623.     {
  624.      
  625.         // no original - return new
  626.         if (!$original) {
  627.             return $new;
  628.         }
  629.         // no new - return original
  630.         if (!$new) {
  631.             return $original;
  632.         }
  633.         // If the properties of $original differ from those of $new and 
  634.         // they are set on $new, set them to $new's. Otherwise leave them 
  635.         // as they are.
  636.  
  637.         if ($new->tag && ($new->tag != $original->tag)) {
  638.             $original->tag = $new->tag;
  639.         }
  640.         
  641.         if ($new->override !== false) {
  642.             $original->override = $new->override;
  643.         }
  644.         
  645.         if (count($new->children)) {
  646.             //echo "<PRE> COPY CHILDREN"; print_r($from->children);
  647.             $original->children = $new->children;
  648.         }
  649.         
  650.         if (is_array($new->attributes)) {
  651.         
  652.             foreach ($new->attributes as $key => $value) {
  653.                 $original->attributes[$key] = $value;
  654.             }
  655.         }
  656.         // originals never have prefixes or suffixes..
  657.         $original->prefix = $new->prefix;
  658.         $original->suffix = $new->suffix;  
  659.  
  660.         if ($new->value !== null) {
  661.             $original->setValue($new->value);
  662.         } 
  663.        
  664.         return $original;
  665.         
  666.     }  
  667.      
  668.      
  669.     /**
  670.     * Get an array of elements from the template
  671.     *
  672.     * All <form> elements (eg. <input><textarea) etc.) and anything marked as 
  673.     * dynamic  (eg. flexy:dynamic="yes") are converted in to elements
  674.     * (simliar to XML_Tree_Node) 
  675.     * you can use this to build the default $elements array that is used by
  676.     * outputObject() - or just create them and they will be overlayed when you
  677.     * run outputObject()
  678.     *
  679.     *
  680.     * @return   array   of HTML_Template_Flexy_Element sDescription
  681.     * @access   public
  682.     */
  683.     
  684.     function getElements() {
  685.     
  686.         if ($this->elementsFile && file_exists($this->elementsFile)) {
  687.             require_once 'HTML/Template/Flexy/Element.php';
  688.             return unserialize(file_get_contents($this->elementsFile));
  689.         }
  690.         return array();
  691.     }
  692.     
  693.     
  694.     /**
  695.     * Lazy loading of PEAR, and the error handler..
  696.     * This should load HTML_Template_Flexy_Error really..
  697.     * 
  698.     * @param   string message
  699.     * @param   int      error type.
  700.     * @param   int      an equivalant to pear error return|die etc.
  701.     *
  702.     * @return   object      pear error.
  703.     * @access   public
  704.     */
  705.   
  706.     
  707.     function raiseError($message, $type = null, $fatal = HTML_TEMPLATE_FLEXY_ERROR_RETURN ) 
  708.     {
  709.         HTML_Template_Flexy::debug("<B>HTML_Template_Flexy::raiseError</B>$message");
  710.         require_once 'PEAR.php';
  711.         if (HTML_Template_Flexy_is_a($this,'HTML_Template_Flexy') &&  ($fatal == HTML_TEMPLATE_FLEXY_ERROR_DIE)) {
  712.             // rewrite DIE!
  713.             return PEAR::raiseError($message, $type, $this->options['fatalError']);
  714.         }
  715.         if (isset($GLOBALS['_HTML_TEMPLATE_FLEXY']['fatalError']) &&  ($fatal == HTML_TEMPLATE_FLEXY_ERROR_DIE)) {
  716.             
  717.             return PEAR::raiseError($message, $type,$GLOBALS['_HTML_TEMPLATE_FLEXY']['fatalError']);
  718.         }
  719.         return PEAR::raiseError($message, $type, $fatal);
  720.     }
  721.  
  722.  
  723.     /**
  724.     * 
  725.     * Assign API - 
  726.     * 
  727.     * read the docs on HTML_Template_Flexy_Assign::assign()
  728.     *
  729.     * @param   varargs ....
  730.     * 
  731.     *
  732.     * @return   mixed    PEAR_Error or true?
  733.     * @access   public
  734.     * @see  HTML_Template_Flexy_Assign::assign()
  735.     * @status alpha
  736.     */
  737.   
  738.     function setData() {
  739.         require_once 'HTML/Template/Flexy/Assign.php';
  740.         // load assigner..
  741.         if (!isset($this->assign)) {
  742.             $this->assign = new HTML_Template_Flexy_Assign;
  743.         }
  744.         return $this->assign->assign(func_get_args());
  745.     }
  746.     /**
  747.     * 
  748.     * Assign API - by Reference
  749.     * 
  750.     * read the docs on HTML_Template_Flexy_Assign::assign()
  751.     *
  752.     * @param  key  string
  753.     * @param  value mixed
  754.     * 
  755.     * @return   mixed    PEAR_Error or true?
  756.     * @access   public
  757.     * @see  HTML_Template_Flexy_Assign::assign()
  758.     * @status alpha
  759.     */
  760.         
  761.     function setDataByRef($k,&$v) {
  762.         require_once 'HTML/Template/Flexy/Assign.php';
  763.         // load assigner..
  764.         if (!isset($this->assign)) {
  765.             $this->assign = new HTML_Template_Flexy_Assign;
  766.         }
  767.         $this->assign->assignRef($k,$v);
  768.     } 
  769.     /**
  770.     * 
  771.     * Plugin (used by templates as $this->plugin(...) or {this.plugin(#...#,#....#)}
  772.     * 
  773.     * read the docs on HTML_Template_Flexy_Plugin()
  774.     *
  775.     * @param  varargs ....
  776.     * 
  777.     * @return   mixed    PEAR_Error or true?
  778.     * @access   public
  779.     * @see  HTML_Template_Flexy_Plugin
  780.     * @status alpha
  781.     */
  782.     function plugin() {
  783.         require_once 'HTML/Template/Flexy/Plugin.php';
  784.         // load pluginManager.
  785.         if (!isset($this->plugin)) {
  786.             $this->plugin = new HTML_Template_Flexy_Plugin;
  787.             $this->plugin->flexy = &$this;
  788.         }
  789.         return $this->plugin->call(func_get_args());
  790.     } 
  791.     /**
  792.     * 
  793.     * output / display ? - outputs an object, without copy by references..
  794.     * 
  795.     * @param  optional mixed object to output
  796.     * 
  797.     * @return   mixed    PEAR_Error or true?
  798.     * @access   public
  799.     * @see  HTML_Template_Flexy::ouptutObject
  800.     * @status alpha
  801.     */
  802.     function output($object = false) 
  803.     {
  804.         return $this->outputObject($object);
  805.     }
  806.     
  807.     /**
  808.     * 
  809.     * render the template with data..
  810.     * 
  811.     * @param  optional mixed object to output
  812.     * 
  813.     * @return   mixed    PEAR_Error or true?
  814.     * @access   public
  815.     * @see  HTML_Template_Flexy::ouptutObject
  816.     * @status alpha
  817.     */
  818.     function toString($object = false) 
  819.     {
  820.         return $this->bufferedOutputObject($object);
  821.     }
  822.     
  823. }