Source for file system/helpers/HTMLInputElement.php

Documentation is available at system/helpers/HTMLInputElement.php

  1. <?php
  2. /**
  3.  * This application is free software; you can redistribute
  4.  * it and/or modify it under the terms of the GNU
  5.  * General Public License as published by the Free
  6.  * Software Foundation; either version 3 of the License,
  7.  * or (at your option) any later version.
  8.  * 
  9.  * This application is distributed in the hope that it will
  10.  * be useful, but WITHOUT ANY WARRANTY; without even the
  11.  * implied warranty of MERCHANTABILITY or FITNESS FOR A
  12.  * PARTICULAR PURPOSE.  See the GNU General Public
  13.  * License for more details.
  14.  *
  15.  *
  16.  * @author Andrew Judd <contact@andrewjudd.ca>
  17.  * @copyright Andrew Judd, 2010
  18.  * @license http://www.gnu.org/licenses/gpl-3.0.txt GPLv3
  19.  *
  20.  * @project Mini MVC
  21.  * @version 1.0.4
  22.  * @name system/helpers/HTMLInputElement.php
  23.  * @description This class provides both the abstract class and various other
  24.  *               HTML input element oriented classes.
  25.  */
  26.  
  27. /* Check if attempting for direct access */
  28. if !defined '__FULLPATH__' ) )
  29. {
  30.     die header 'HTTP/1.0 404 Not Found' ) );
  31. }
  32.  
  33. /**
  34.  * The base class for each of the HTML input elements.  This will provide core
  35.  * functionality which is common to all input types and the declarations of
  36.  * functions which need to be implemented individually.
  37.  */
  38. abstract class HTMLInputElement
  39. {
  40.     /**
  41.      * A list of all of the error messages possible for the form builder.
  42.      */
  43.     protected static $errors NULL;
  44.  
  45.     /**
  46.      * The name which is associated with the input element.
  47.      */
  48.     protected $name = NULL;
  49.  
  50.     /**
  51.      * The type of input element wrapped by this.
  52.      */
  53.     protected $type = NULL;
  54.  
  55.     /**
  56.      * The default value for this input element.
  57.      */
  58.     protected $value = NULL;
  59.  
  60.     /**
  61.      * The name of the form which is being submitted (to resolve naming collisions)
  62.      */
  63.     protected $form = NULL;
  64.  
  65.     /**
  66.      * The input values which the form will use (only used in some classes).
  67.      */
  68.     protected $values = array ();
  69.  
  70.     /**
  71.      * The text which a label being generated for the corresponding input field.
  72.      */
  73.     protected $label = NULL;
  74.  
  75.     /**
  76.      * The unique ID for this form element.
  77.      */
  78.     protected $id = NULL;
  79.  
  80.     /**
  81.      * The attributes which will be associated with the form element.
  82.      */
  83.     protected $attributes = array ();
  84.  
  85.     /**
  86.      * Whether or not this field should be remembered on post / get.
  87.      */
  88.     protected $remember = TRUE;
  89.  
  90.     /**
  91.      * The only constructor for the HTMLInputElement abstract class.  This should
  92.      * be called through all of the sub classesin order to set all properties
  93.      * accordingly.
  94.      * @param string $name - The name and ID for the form element
  95.      * @param string $type - The type of field which will be used
  96.      * @param string $value - The default value for the input field
  97.      * @param string $form - The name of the form that the input element is in
  98.      */
  99.     public function __construct $name$type$value ''$form '' )
  100.     {
  101.         /* Load the Errors XML file */
  102.         Base::__loadXML __HTMLINPUTELEMENTERRORFILE__HTMLInputElement::$errors__HTMLINPUTELEMENTERRORSCHEMA__ );
  103.  
  104.         /* Set all of the values */
  105.         $this -> setName $name );
  106.         $this -> setInputType $type );
  107.         $this -> setValue $value );
  108.         $this -> setForm $form );
  109.  
  110.         /* Default the CSS Class */
  111.         $this -> attributes 'class' '';
  112.         $this -> attributes 'label_class' '';
  113.     }
  114.  
  115.     /**
  116.      * This function is used in order to convert the class which was
  117.      * created into the raw HTML form.
  118.      * @param string $formMD5 - The unique MD5 for the form
  119.      * @return string - The HTML which corresponds to the object created.
  120.      */
  121.     public function toHTML $formMD5 )
  122.     {
  123.         $arr $this -> toHTMLArray $formMD5 );
  124.         return ( ( isset $arr FormBuilder::LABEL $arr FormBuilder::LABEL '' $arr FormBuilder::HTML )
  125.     }
  126.  
  127.     /**
  128.      * This abstract function is used in order to convert the object's HTML
  129.      * information into an array which will then be used later on.  The array
  130.      * will contain either ONE (1) or TWO (2) elements:
  131.      *  - HTML - the HTML relating to the actual input field
  132.      *  - LABEL - the label associated with the input field
  133.      * @param string $formMD5 - The unique MD5 for the form
  134.      * @return array - The array containing all of the information
  135.      */
  136.     public abstract function toHTMLArray $formMD5 );
  137.  
  138.     /**
  139.      * This abstract function is used in order to set the default list of values
  140.      * for particular input types.
  141.      * @param $values - List of values which the input field may use
  142.      * @param boolen $append - Whether the value should be appended to the list or not
  143.      */
  144.     public abstract function setValues $values$append FALSE );
  145.  
  146.     /**
  147.      * The setter for the label which can be created along with the rest of the
  148.      * form element.
  149.      * @param string $label - The text which the label will contain (NULL if no
  150.      *                         label is desired.
  151.      */
  152.     public function setLabel $label )
  153.     {
  154.         $this -> label = $label;
  155.     }
  156.  
  157.     /**
  158.      * The getter for the label being created with the form element.
  159.      * @returns string - The label text
  160.      */
  161.     public function getLabel ()
  162.     {
  163.         return $this -> label );
  164.     }
  165.  
  166.     /**
  167.      * The setter for the CSS class
  168.      * @param string $class - The new CSS class to be set for the input element
  169.      */
  170.     public function setCSSClass $class )
  171.     {
  172.         $this -> attributes 'class' $class;
  173.     }
  174.  
  175.     /**
  176.      * The getter for the CSS class for the form element.
  177.      * @returns string - The associated CSS class
  178.      */
  179.     public function getCSSClass ()
  180.     {
  181.         return $this -> attributes 'class' );
  182.     }
  183.  
  184.     /**
  185.      * The setter for the label's CSS class
  186.      * @param string $class - The new CSS class to be set for the input element
  187.      */
  188.     public function setLabelCSSClass $class )
  189.     {
  190.         $this -> attributes 'label_class' $class;
  191.     }
  192.  
  193.     /**
  194.      * The getter for the CSS class for the form element.
  195.      * @returns string - The associated CSS class
  196.      */
  197.     public function getLabelCSSClass ()
  198.     {
  199.         return $this -> attributes 'label_class' );
  200.     }
  201.  
  202.     /**
  203.      * The setter for each of the attributes of the form element.
  204.      * @param string $name - The name of the attribute being added
  205.      * @param string $value - The value associated with the attribute
  206.      * @returns string - If previously set, the value which it was or NULL
  207.      *                    if the value was not set
  208.      */
  209.     public function setAttribute $name$value '' )
  210.     {
  211.         /* Determine the value to return */
  212.         $retVal = isset $this -> attributes $name $this -> attributes $name NULL;
  213.  
  214.         /* Set the new value */
  215.         $this -> attributes $name $value;
  216.  
  217.         return $retVal );
  218.     }
  219.  
  220.     /**
  221.      * The getter for each of the attributes of the form element.
  222.      * @param string $name - The name of the attribute being searched for
  223.      * @returns string - The value associated with the attribute, or NULL if
  224.      *                    attribute was unset
  225.      */
  226.     public function getAttribute $name )
  227.     {
  228.         $retVal NULL;
  229.  
  230.         /* Check if the attribute exists */
  231.         if isset $this -> attributes $name ) )
  232.         {
  233.             /* Not set, so error */
  234.             Base::$errors [sprintf HTMLInputElement::$errors 'attributenotset' ]$name$this -> name );
  235.         }
  236.         else
  237.         {
  238.             $retVal $this -> attributes $name ];
  239.         }
  240.  
  241.         return $retVal )
  242.     }
  243.  
  244.     /**
  245.      * This is the setter for the form name of an element.  This will also
  246.      * propagate any changes to the unique identifier.
  247.      * @param string $form - The new form name
  248.      */
  249.     public function setForm $form )
  250.     {
  251.         $this -> form = $form;
  252.  
  253.         /* Update the field id */
  254.         $this -> updateId ();
  255.     }
  256.  
  257.     /**
  258.      * The getter for the form name of an input element.
  259.      * @returns - The form name
  260.      */
  261.     public function getForm ()
  262.     {
  263.         return $this -> form );
  264.     }
  265.  
  266.     /**
  267.      * The getter for the set of default values for an input element.
  268.      * @returns - The default list of possible values
  269.      */
  270.     public function getValues ()
  271.     {
  272.         return $this -> values );
  273.     }
  274.  
  275.     /**
  276.      * The setter for the default value of the input field.
  277.      * @param $value - The value which the field should start out as
  278.      */
  279.     public function setValue $value )
  280.     {
  281.         $this -> value = $value;
  282.     }
  283.  
  284.     /**
  285.      * The getter for the value of the input field.
  286.      * @param string $formMD5 - The unique id for the form
  287.      * @returns string - The value associated with this input field
  288.      */
  289.     public function getValue $formMD5 )
  290.     {
  291.         /* Generate the unique identifier for the field */
  292.         $uniqueId $this -> form . '_' $formMD5 '_' $this -> name;
  293.  
  294.         /* Check if the field was posted */
  295.         if isset $_POST $uniqueId ) )
  296.         {
  297.             $this -> value = $_POST $uniqueId ];
  298.         }
  299.  
  300.         return $this -> value );
  301.     }
  302.  
  303.     /**
  304.      * This function is run by the form in order to re-initialize the value
  305.      * for a particular input field if a post was completed for that particular
  306.      * form.
  307.      * @param string $formMD5 - The unique form identifier which is included
  308.      *                           in the unique name of the HTML element.
  309.      */
  310.     public function initializeValue $formMD5&$array )
  311.     {
  312.         /* Generate the unique identifier for the field */
  313.         $uniqueId $this -> form . '_' $formMD5 '_' $this -> name;
  314.  
  315.         /* Check if the field was posted */
  316.         if isset $array $uniqueId ) )
  317.         {
  318.             /* See if the value was supposed to be remembered */
  319.             if $this -> remember )
  320.             {
  321.                 $this -> value = $array $uniqueId ];
  322.             }
  323.  
  324.             /* Set the post value */
  325.             $array $this -> name $array $uniqueId ];
  326.         }
  327.     }
  328.  
  329.     /**
  330.      * The setter for the name and id attribute of the input element.
  331.      * @param string $name - The name which will be used to identify this object
  332.      */
  333.     public function setInputType $type )
  334.     {
  335.         /* Make sure it is one of the acceptable types */
  336.         if isset FormBuilder::$inputTypes $type ) )
  337.         {
  338.             $this -> type = $type;
  339.         }
  340.         /* Invalid form input type, so provide error */
  341.         else
  342.         {
  343.             /* Otherwise, don't set the input type and add in an error message */
  344.             Base::$errors [sprintf HTMLInputElement::$errors 'invalidinputtype' ]$type );
  345.         }
  346.     }
  347.  
  348.     /**
  349.      * The getter for the name and id attribute of the input element
  350.      * @returns string - The name of the html element
  351.      */
  352.     public function getInputType  ()
  353.     {
  354.         return $this -> type );
  355.     }
  356.  
  357.     /**
  358.      * This function is used internally to update the field element's id if the
  359.      * form or name elements are changed.
  360.      */
  361.     protected function updateId ()
  362.     {
  363.         $this -> id = '';
  364.  
  365.         /* Check if the form name is included */
  366.         if $this -> form != NULL )
  367.         {
  368.             /* Prefix id with the form name */
  369.             $this -> id = $this -> form . '_';
  370.         }
  371.  
  372.         /* Add the name to it */
  373.         $this -> id .= $this -> name;
  374.     }
  375.  
  376.     /**
  377.      * The getter for the field element's id
  378.      * @returns string - The field's unique id
  379.      */
  380.     public function getId ()
  381.     {
  382.         return $this -> id );
  383.     }
  384.  
  385.     /**
  386.      * The setter for the name and id attribute of the input element.
  387.      * @param string $name - The name which will be used to identify this object
  388.      */
  389.     public function setName $name )
  390.     {
  391.         /* Make sure there is at least one character in the name */
  392.         if isset $name ) )
  393.         {
  394.             /* Check if the name contained any whitespace (invalid) */
  395.             if preg_match '/\s/'$name == )
  396.             {
  397.                 /* It's fine, so just set it */
  398.                 $this -> name = $name;
  399.             }
  400.             /* Otherwise, change the name and provide the error */
  401.             else
  402.             {
  403.                 /* Change any whitespace to an underscore */
  404.                 $this -> name = preg_replace '/\s/''_'$name );
  405.  
  406.                 /* Provide an error message */
  407.                 Base::$errors [sprintf 
  408.                     HTMLInputElement::$errors 'fieldnamecontainedspaces' ],
  409.                     $name );
  410.             }
  411.             
  412.             /* Name has changed, so update the id */
  413.             $this -> updateId ();
  414.         }
  415.     }
  416.  
  417.     /**
  418.      * The getter for the name and id attribute of the input element
  419.      * @returns string - The name of the html element
  420.      */
  421.     public function getName ()
  422.     {
  423.         return $this -> name );
  424.     }
  425.  
  426.     /**
  427.      * This function is used in order to set or unset the 'remember' flag
  428.      * which is used in the post-submission processing of a form.
  429.      * @param boolean $remember - TRUE if the value should be remembered
  430.      *                             FALSE otherwise
  431.      */
  432.     public function setRemember $remember )
  433.     {
  434.         /* Validate the type */
  435.         if $remember === TRUE || $remember === FALSE )
  436.         {
  437.             /* It is an acceptable type, so save it */
  438.             $this -> remember = $remember;
  439.         }
  440.         /* Otherwise, it is invalid, so provide an error */
  441.         else
  442.         {
  443.             Base::$errors [sprintf 
  444.                 HTMLInputElement::$errors 'invalideremembervalue' ],
  445.                 $remember );
  446.         }
  447.     }
  448.  
  449.     /**
  450.      * This function is used in order to return whether or not the 'remember'
  451.      * flag has been enabled.
  452.      * @returns boolean - TRUE if the value will be remembered from the
  453.      *                     submission, FALSE otherwise
  454.      */
  455.     public function getRemember ()
  456.     {
  457.         return $this -> remember );
  458.     }
  459.  
  460.     /**
  461.      * This function is used in order to list all of the attributes which are
  462.      * associated with the corresponding input element.
  463.      * @returns string - The list of attributes for the specified input element
  464.      */
  465.     protected function getAttributes $formMD5$includeType TRUE )
  466.     {
  467.         $buff '';
  468.  
  469.         /* Determine if the type should be included */
  470.         if $includeType )
  471.         {
  472.             $buff 'type = "' $this -> type . '"';
  473.         }
  474.  
  475.         $buff .= ' name = "' $this -> 
  476.             . '_' $formMD5 '_' $this -> 
  477.                 . '" id = "form_' $formMD5 '_' $this -> id . '" ';
  478.       
  479.         /* Iterate through all of the attributes to add it to the buffer */
  480.         foreach $this -> attributes as $key => $value )
  481.         {
  482.             /* Ignore the label's class attribute */
  483.             if $key != 'label_class' )
  484.             {
  485.                 $buff .= ' ' $key ' = ' '"' $value .'" ';
  486.             }
  487.         }
  488.  
  489.         return $buff );
  490.     }
  491.  
  492.     /**
  493.      * This function is used in order to build the label if required for the HTML
  494.      * element.
  495.      * @param string $formMD5 - The unique MD5 for the form
  496.      * @return string - The HTML tag for the label
  497.      */ 
  498.     protected function buildLabel $formMD5 )
  499.     {
  500.         return '<label for = "form_'
  501.                 . $formMD5 '_' $this -> id . '" class = "' 
  502.                 . $this -> attributes 'label_class' .'">' $this -> 
  503.                 . '</label>' );
  504.     }
  505. }
  506.  
  507. {
  508.     /**
  509.      * This constructor overrides the default constructor for the HTMLNormalInput
  510.      * class in order to make sure that the password field doesn't automatically
  511.      * remember the value which was submitted.
  512.      * @param string $name - The name and ID for the form element
  513.      * @param string $type - The type of field which will be used
  514.      * @param string $value - The default value for the input field
  515.      * @param string $form - The name of the form that the input element is in
  516.      */
  517.     public function __construct $name$type$value ''$form '' )
  518.     {
  519.         /* Call the parent's constructor */
  520.         parent::__construct $name$type$value$form );
  521.  
  522.         /* Check if this field is a password field */
  523.         if $type == FormBuilder::INPUT_PASSWORD )
  524.         {
  525.             /* If it is, default the auto-remember to FALSE (don't auto-remember) */
  526.             $this -> remember = FALSE;
  527.         }
  528.     }
  529.  
  530.     /**
  531.      * This function is used in order to convert the object's HTML
  532.      * information into an array which will then be used later on.  The array
  533.      * will contain either ONE (1) or TWO (2) elements:
  534.      *  - FormBuilder::HTML - the HTML relating to the actual input field
  535.      *  - FormBuilder::LABEL - the label associated with the input field
  536.      * @param string $formMD5 - The unique MD5 for the form
  537.      * @return array - The array containing all of the information
  538.      */
  539.     public function toHTMLArray $formMD5 )
  540.     {
  541.         $arr array ();
  542.  
  543.         /* Create the section for a label if it exists */
  544.         if $this -> label != NULL )
  545.         {
  546.             $arr FormBuilder::LABEL $this -> buildLabel $formMD5 );
  547.         }
  548.  
  549.         $buff '<input type = "' $this -> type . '" ';
  550.  
  551.         /* Only include the value field if needed */
  552.         if empty $this -> value ) )
  553.         {
  554.             $buff .= ' value = "' htmlentities $this -> value '" ';
  555.         }
  556.  
  557.         $buff .= $this -> getAttributes $formMD5FALSE ' >';
  558.  
  559.         $arr FormBuilder::HTML $buff;
  560.  
  561.         return $arr );
  562.     }
  563.  
  564.     /**
  565.      * This abstract function is used in order to set the default list of values
  566.      * for particular input types.
  567.      * @param $values - List of values which the input field may use
  568.      * @param boolen $append - Whether the value should be appended to the list or not
  569.      */
  570.     public function setValues $values$append FALSE )
  571.     {
  572.         /* Provide error */
  573.         Base::$errors [sprintf HTMLInputElement::$errors 'novaluestoset' ],
  574.             $this -> type );
  575.     }
  576. }
  577.  
  578. {
  579.     /**
  580.      * This function is used in order to convert the object's HTML
  581.      * information into an array which will then be used later on.  The array
  582.      * will contain either ONE (1) or TWO (2) elements:
  583.      *  - FormBuilder::HTML - the HTML relating to the actual input field
  584.      *  - FormBuilder::LABEL - the label associated with the input field
  585.      * @param string $formMD5 - The unique MD5 for the form
  586.      * @return array - The array containing all of the information
  587.      */
  588.     public function toHTMLArray $formMD5 )
  589.     {
  590.         $arr array ();
  591.  
  592.         /* Create the section for a label if it exists */
  593.         if $this -> label != NULL )
  594.         {
  595.             $arr FormBuilder::LABEL $this -> buildLabel $formMD5 );
  596.         }
  597.  
  598.         $buff '<textarea ' $this -> getAttributes $formMD5FALSE '>';
  599.  
  600.         /* Only include the value field if needed */
  601.         if empty $this -> value ) )
  602.         {
  603.             $buff .= htmlentities $this -> value );
  604.         }
  605.        
  606.         $buff .= '</textarea>';
  607.  
  608.         $arr FormBuilder::HTML $buff;
  609.  
  610.         return $arr );
  611.     }
  612.  
  613.     /**
  614.      * This abstract function is used in order to set the default list of values
  615.      * for particular input types.
  616.      * @param $values - List of values which the input field may use
  617.      * @param boolen $append - Whether the value should be appended to the list or not
  618.      */
  619.     public function setValues $values$append FALSE )
  620.     {
  621.         /* Provide error */
  622.         Base::$errors [sprintf HTMLInputElement::$errors 'novaluestoset' ],
  623.             $this -> type );
  624.     }
  625. }
  626.  
  627. {
  628.     /**
  629.      * This function is used in order to convert the object's HTML
  630.      * information into an array which will then be used later on.  The array
  631.      * will contain either ONE (1) or TWO (2) elements:
  632.      *  - FormBuilder::HTML - the HTML relating to the actual input field
  633.      *  - FormBuilder::LABEL - the label associated with the input field
  634.      * @param string $formMD5 - The unique MD5 for the form
  635.      * @return array - The array containing all of the information
  636.      */
  637.     public function toHTMLArray $formMD5 )
  638.     {
  639.         $arr array ();
  640.  
  641.         /* Create the section for a label if it exists */
  642.         if $this -> label != NULL )
  643.         {
  644.             $arr FormBuilder::LABEL $this -> buildLabel $formMD5 );
  645.         }
  646.  
  647.         $buff '<select ' $this -> getAttributes $formMD5FALSE '>' __NEWLINE__;
  648.  
  649.         /* Loop through all of the values and add them in */
  650.         foreach $this -> values as $key => $value )
  651.         {
  652.             $buff .= '<option value = "' $key '" ';
  653.             
  654.             /* See if the value has been set (based on the value) */
  655.             if strcmp $key$this -> value == )
  656.             {
  657.                 /* The value matches, so mark it as selected */
  658.                 $buff .= ' selected = "selected" ';
  659.             }
  660.  
  661.             $buff .= '>' $value '</option>' __NEWLINE__;
  662.         }
  663.  
  664.         $buff .= '</select>';
  665.  
  666.         $arr FormBuilder::HTML $buff;
  667.  
  668.         return $arr );
  669.     }
  670.  
  671.  
  672.     /**
  673.      * This abstract function is used in order to set the default list of values
  674.      * for particular input types.
  675.      * @param $values - List of values which the input field may use
  676.      * @param boolen $append - Whether the value should be appended to the list or not
  677.      */
  678.     public function setValues $values$append FALSE )
  679.     {
  680.         /* Check if they chose to append the value to the current list */
  681.         if $append )
  682.         {
  683.             /* Check if it is an array */
  684.             if is_array $value ) )
  685.             {
  686.                 /* If it is an array, then iterate through all elements adding */
  687.                 foreach $value as $key => $new )
  688.                 {
  689.                     $this -> values $key $new;
  690.                 }
  691.             }
  692.             else
  693.             {
  694.                 /* Not an array, so just throw it on the end */
  695.                 $this -> values [$value;
  696.             }
  697.         }
  698.         else
  699.         {
  700.             /* They didn't choose to append it */
  701.             if is_array $values ) )
  702.             {
  703.                 /* We are an array, so the just use it */
  704.                 $this -> values = $values;
  705.             }
  706.             else
  707.             {
  708.                 /* Otherwise, it is an element, so just set it */
  709.                 $this -> values = array $values );
  710.             }
  711.         }
  712.     }
  713. }

Documentation generated on Sat, 30 Oct 2010 09:50:12 -0400 by phpDocumentor 1.4.3