tangra logo
   
[ class tree: tangra_lib ] [ index: tangra_lib ] [ all elements ]
 

Source for file static_html_form_generator.class.php

Documentation is available at static_html_form_generator.class.php

  1. <?php
  2. // *** Tangra (Application Framework and Tools for PHP)
  3. //  $Id$
  4. //
  5.  
  6.  
  7. /**
  8.  * Contains class Static_HTML_Form_Generator
  9.  *
  10.  * @package  tangra_lib
  11.  * @subpackage  form
  12.  */
  13.  
  14.  
  15. /**
  16.  *
  17.  */
  18. require_once(TANGRA_MAIN_DIR.'form/fields/hidden/form_field_hidden.class.php');
  19.  
  20. /**
  21.  *
  22.  */
  23. require_once(TANGRA_MAIN_DIR.'exceptions/te_key_already_exists.class.php');
  24.  
  25. /**
  26.  *
  27.  */
  28. require_once(TANGRA_MAIN_DIR.'exceptions/te_key_not_exists.class.php');
  29.  
  30.  
  31. /**
  32.  * Generates HTML for "static" forms
  33.  *
  34.  * Static forms are forms that once created remain the same in temrs of count of fields and their type.
  35.  * In contrary, dynamic form may can be manipulated at runtime and receive new fields (with usual add_field() method), or remove fields from it.
  36.  *
  37.  * @package  tangra_lib
  38.  * @subpackage  form
  39.  */
  40. class Static_HTML_Form_Generator extends Tangra_Class {
  41.     /**
  42.      * Form object
  43.      *
  44.      * @var Form 
  45.      * @internal
  46.      */
  47.     private $form;
  48.  
  49.     /**
  50.      * Path to template dir
  51.      *
  52.      * @var string 
  53.      */
  54.     private $tpl_path;
  55.  
  56.     /**
  57.      * Form language (in term of native language)
  58.      *
  59.      * @var string 
  60.      */
  61.     private $language;
  62.  
  63.     /**
  64.      * Map for fields templates
  65.      *
  66.      * @var array 
  67.      */
  68.     private $fields_tpl_map  = array();
  69.  
  70.     /**
  71.      * Map for fields' errors templates
  72.      *
  73.      * @var array 
  74.      */
  75.     private $errs_tpl_map = array();
  76.  
  77.  
  78.     /**
  79.      * Constructor
  80.      *
  81.      * @param Form $form 
  82.      * @param string $tpl_path 
  83.      * @param string $language 
  84.      */
  85.     function __construct(Form $form, $tpl_path, $language) {
  86.         $this->tpl_path = tangra_normalize_path($tpl_path);
  87.         $this->form = $form;
  88.         $this->language = $language;
  89.     }
  90.  
  91.  
  92.     /**
  93.      * Returns template path
  94.      *
  95.      * @return unknown 
  96.      */
  97.     public function get_tpl_path() {
  98.         return $this->tpl_path;
  99.     }
  100.  
  101.  
  102.     /**
  103.      * Returns Form object
  104.      *
  105.      * @return Form 
  106.      */
  107.     public function get_form() {
  108.         return $this->form;
  109.     }
  110.  
  111.  
  112.     /**
  113.      * Returns form language
  114.      *
  115.      * @return string 
  116.      */
  117.     public function get_language() {
  118.         return $this->language;
  119.     }
  120.  
  121.  
  122.     /**
  123.      * Returns generated HTML code
  124.      *
  125.      * @return string 
  126.      */
  127.     public function get_static_html() {
  128.         $tple = new Tple();
  129.  
  130.         $fields = $this->form->get_fields();
  131.         $fields = $this->sort_fields($fields);
  132.  
  133.         $c = 0;
  134.         $f_arr = array();
  135.         foreach($fields as $f) {
  136.             $tmp_arr = $f->get_properties_array();
  137.             $tmp_arr['tpl_file'] = $this->get_fields_tpl_map_entry_value($f->get_name());
  138.             $tmp_arr['err_tpl_file_arr'] = $this->errs_tpl_map[$f->get_name()];
  139.             $f_arr[$c] = $tmp_arr;
  140.  
  141.             $c++;
  142.         }
  143.  
  144.         $tple->set_delimiters('{@', '@}');
  145.  
  146.  
  147. //        print_r_pre($f_arr);
  148.  
  149.         $tple->assign('fields', $f_arr);
  150.         $tple->assign('form_name', $this->form->get_name());
  151.         $tple->assign('submit', $this->form->get_submit_name());
  152.         $method = $this->form->get_method() ==  Tangra_Form_Submit_Method::GET
  153.                                 ? 'get'
  154.                                 : 'post';
  155.         $tple->assign('method', $method);
  156.         $tple->assign('enctype', $this->form->get_enctype());
  157.         $tple->assign('action', $this->form->get_action());
  158.         $tple->assign('_language', $this->get_language());
  159.  
  160.         $path = $this->get_tpl_path();
  161.  
  162.         $tple->assign('path', $path);
  163.  
  164.  
  165.         return $tple->fetch($path.'form.tpl');
  166.     }
  167.  
  168.  
  169.     /**
  170.      * Creates default template maps for fields and fields potential errors
  171.      *
  172.      */
  173.     public function create_default_tpl_maps() {
  174.         $fields = $this->form->get_fields();
  175.  
  176.         foreach($fields as $f) {
  177.             $field_tpl_path = $this->get_tpl_path().'/fields/'.strtolower($f->get_type()).'.tpl';
  178.             $this->add_tpl_map_entry($f->get_name(), $field_tpl_path);
  179.  
  180.             $this->errs_tpl_map[$f->get_name()] = $this->create_field_errors_tpl_map($f);
  181.         }
  182.     }
  183.  
  184.  
  185.     /**
  186.      * Changes existying map entry for template
  187.      *
  188.      * @param unknown_type $field_name 
  189.      * @param unknown_type $tpl_path 
  190.      */
  191.     public function change_tpl_map_entry($field_name, $tpl_path) {
  192.         if (array_key_exists($field_name, $this->fields_tpl_map)) {
  193.             $this->fields_tpl_map[$field_name] = $tpl_path;
  194.         } else {
  195.             throw new TE_Key_Not_Exists($field_name);
  196.         }
  197.     }
  198.  
  199.  
  200.     /**
  201.      * Changes map entry for field error template
  202.      *
  203.      * @param string $field_name Name of the field
  204.      * @param string $p_error_name Name of the error
  205.      * @param string $tpl_path  Path to template file
  206.      */
  207.     public function change_field_p_error_map_entry($field_name, $p_error_name, $tpl_path) {
  208.         if (array_key_exists($field_name, $this->errs_tpl_map)) {
  209.             if (array_key_exists($p_error_name, $this->errs_tpl_map[$field_name])) {
  210.                 $this->errs_tpl_map[$field_name][$p_error_name] = $tpl_path;
  211.  
  212.             } else {
  213.                 throw new TE_Key_Not_Exists('Field name: '.$field_name.'. Potential error name: '.$p_error_name);
  214.             }
  215.         } else {
  216.             throw new TE_Key_Not_Exists('Field name: '.$field_name);
  217.         }
  218.     }
  219.  
  220.  
  221.     /**
  222.      * Enter description here...
  223.      *
  224.      * @param unknown_type $field_name 
  225.      * @return unknown 
  226.      */
  227.     public function get_fields_tpl_map_entry_value($field_name) {
  228.         $ret = false;
  229.  
  230.         if (array_key_exists($field_name, $this->fields_tpl_map)) {
  231.             $ret = $this->fields_tpl_map[$field_name];
  232.         } else {
  233.             throw new TE_Key_Not_Exists($field_name);
  234.         }
  235.  
  236.         return $ret;
  237.     }
  238.  
  239.  
  240.     /**
  241.      * Adds new map entry for templates
  242.      *
  243.      * @param unknown_type $field_name 
  244.      * @param unknown_type $tpl_path 
  245.      * @internal
  246.      */
  247.     protected function add_tpl_map_entry($field_name, $tpl_path) {
  248.         if (!array_key_exists($field_name, $this->fields_tpl_map)) {
  249.             $this->fields_tpl_map[$field_name] = $tpl_path;
  250.         } else {
  251.             throw new TE_Key_Already_Exists($field_name);
  252.         }
  253.     }
  254.  
  255.  
  256.     /**
  257.      * Sorts fields array
  258.      *
  259.      * Purpose is to move all hidden fields at the end of the result array. That way hidden
  260.      * fields does not bother the sequence of odd/even rows when HTML is generated (e.g. if
  261.      * diferent styles are used for odd and even rows (and if template uses one row per field))
  262.      *
  263.      * @param array $fields 
  264.      * @return array 
  265.      * @internal
  266.      */
  267.     protected function sort_fields(&$fields) {
  268.         $normal_fields = array();
  269.         $hidden_fields = array();
  270.  
  271.         foreach ($fields as $key => $value) {
  272.             if ($value instanceof Form_Field_Hidden) {
  273.                 $hidden_fields[$key] = $value;
  274.             } else {
  275.                 $normal_fields[$key] = $value;
  276.             }
  277.         }
  278.  
  279.         $ret = array_merge($normal_fields, $hidden_fields);
  280.  
  281.         return $ret;
  282.     }
  283.  
  284.  
  285.     /**
  286.      * Creates default map for fields' potential errors
  287.      *
  288.      * @return unknown 
  289.      * @internal
  290.      */
  291.     private function create_field_errors_tpl_map($f) {
  292.         $ret = array();
  293.  
  294.         $f_p_arr = $f->get_properties_array();
  295.         $f_err_arr = $f_p_arr['p_errors'];
  296.         foreach($f_err_arr as $err) {
  297.             $ret[$err] = $this->get_tpl_path().'/fields/stock_errors/'.$err.'.tpl';
  298.         }
  299.  
  300.         return $ret;
  301.     }
  302. }