Source for file FormBuilder.php

Documentation is available at FormBuilder.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/FormBuilder.php
  23.  * @description This file is used to create a form builder which will allow
  24.  *               for the rapid creation for any forms on a website.
  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. /* Require the configuration file */
  34. require_once __PLUGINCONFIG__ 'formbuilder.php' );
  35.  
  36. /* Require the input base class */
  37. require_once 'HTMLInputElement.php' );
  38.  
  39. {
  40.     /**
  41.      * A list of all of the error messages possible for the form builder.
  42.      */
  43.     private static $errors NULL;
  44.  
  45.     /**
  46.      * The unique MD5 for this form instance.
  47.      */
  48.     private $formMD5 = '';
  49.  
  50.     /**
  51.      * Constant for the form method.for a form POST
  52.      */
  53.     const POST 'post';
  54.  
  55.     /**
  56.      * Constant for the form method.for a form GET
  57.      */
  58.     const GET 'get';
  59.  
  60.     /**
  61.      * Form input types - list of all acceptable and what they map to.
  62.      */
  63.     const INPUT_TEXT 'text';
  64.     const INPUT_PASSWORD 'password';
  65.     const INPUT_HIDDEN 'hidden';
  66.     const INPUT_FILE 'file';
  67.     const INPUT_TEXTAREA 'textarea';
  68.     const INPUT_DROPDOWNLIST 'dropdownlist';
  69.     const INPUT_MULTISELECT 'multiselect';
  70.     const INPUT_RADIO 'radio';
  71.     const INPUT_CHECKBOX 'checkbox';
  72.     const INPUT_SUBMIT 'submit';
  73.     const INPUT_CLEAR 'clear';
  74.     const INPUT_BUTTON 'button';
  75.  
  76.     public static $inputTypes array 
  77.          FormBuilder::INPUT_TEXT => 'HTMLNormalInput'
  78.          FormBuilder::INPUT_PASSWORD => 'HTMLNormalInput',
  79.          FormBuilder::INPUT_HIDDEN => 'HTMLNormalInput',
  80.          FormBuilder::INPUT_FILE => 'HTMLNormalInput',
  81.          FormBuilder::INPUT_TEXTAREA => 'HTMLTextAreaInput',
  82.          FormBuilder::INPUT_DROPDOWNLIST => 'HTMLSelectList',
  83.          FormBuilder::INPUT_MULTISELECT => 'HTMLSelectList',
  84.          FormBuilder::INPUT_RADIO => 'HTMLNormalInput',
  85.          FormBuilder::INPUT_CHECKBOX => 'HTMLNormalInput',
  86.          FormBuilder::INPUT_SUBMIT => 'HTMLNormalInput',
  87.          FormBuilder::INPUT_CLEAR => 'HTMLNormalInput',
  88.          FormBuilder::INPUT_BUTTON => 'HTMLNormalInput'
  89.     );
  90.  
  91.     /**
  92.      * Constants for the form builder output array.
  93.      */
  94.     const HTML 'HTML';
  95.     const LABEL 'LABEL';
  96.  
  97.     /**
  98.      * The form method type which will be used.
  99.      */
  100.     private $method = NULL;
  101.  
  102.     /**
  103.      * The form action which will be used.
  104.      */
  105.     private $action = NULL;
  106.  
  107.     /**
  108.      * The name attribute for the form.  If set, this will automatically
  109.      * prefix any form fields in order to eliminate the chance of naming
  110.      * collisions between this form and other parts of the application.
  111.      * It will also be used as the form's ID for any form related javascript
  112.      * tasks which need to be done.
  113.      */
  114.     private $name = NULL;
  115.  
  116.     /**
  117.      * The count of how many elements are currently within the form object.
  118.      */
  119.     private $elementCount = 0;
  120.  
  121.     /**
  122.      * An array of all of the elements which will be components included in the
  123.      * form being created.
  124.      */
  125.     private $formElements = array ();
  126.  
  127.     /**
  128.      * The mapping table for each of the HTML elements (the names).
  129.      */
  130.     private $formMapping = array ();
  131.  
  132.     /**
  133.      * The three-argument constructor for the Form Builder class which will
  134.      * initialize values which are required components of the form.
  135.      * @param string $name The name which the form goes by.
  136.      * @param string $method The method which the form will be used for
  137.      *                          the form.  This defaults to empty but should
  138.      *                          either be 'post' or 'get'.
  139.      * @param string $action The action which the form will take (i.e.
  140.      *                          where the page will be sent to)
  141.      */
  142.     public function __construct $name ''$method ''$action '' )
  143.     {
  144.         /* Load the Errors XML file */
  145.         Base::__loadXML __FORMBUILDERERRORFILE__FormBuilder::$errors__FORMBUILDERERRORSCHEMA__ );
  146.  
  147.         /* Apply all verification before setting the name */
  148.         $this -> setName $name );
  149.  
  150.         /* Apply all verification before setting the method */
  151.         $this -> setMethod $method );
  152.  
  153.         /* Set the action (doesn't matter) */
  154.         $this -> action = $action;
  155.     }
  156.  
  157.     /**
  158.      * This function is used in order to create a new input element which will be
  159.      * displayed on the view.
  160.      * @param $name The name of the new HTML element being added
  161.      * @param $type The HTML element type which is being added
  162.      * @param $value If provided, the default value for the input field
  163.      * @param $labelText If provided, a label will be generated for the input element
  164.      */
  165.     public function addElement $name$type$value ''$labelText NULL )
  166.     {
  167.         /* Make sure the input type is valid */
  168.         if isset FormBuilder::$inputTypes $type ) )
  169.         {
  170.             $obj new FormBuilder::$inputTypes $type (
  171.                 $name$type$value$this -> name );
  172.  
  173.             /* Add more to the MD5 */
  174.             $this -> formMD5 = md5 $this -> formMD5 );
  175.  
  176.             /* Valid input type, create the object */
  177.             $this -> formElements [$obj;
  178.  
  179.             /* Add in the label if provided */
  180.             if $labelText != NULL )
  181.             {
  182.                 $obj -> setLabel $labelText );
  183.             }
  184.  
  185.             /* Add it to the mapping table */
  186.             $this -> formMapping $name $this -> elementCount;
  187.  
  188.             /* Increment the element count */
  189.             $this -> elementCount++;
  190.         }
  191.     }
  192.  
  193.     /**
  194.      * This function is used in order to set the CSS class for the specified
  195.      * input field (overwrites the pre-existing CSS class).
  196.      * @param string $field The input field which the CSS class is being set
  197.      * @param string $class The new CSS class
  198.      */
  199.     public function setCSSClass $field$class )
  200.     {
  201.         /* Verify that the field exists */
  202.         if isset $this -> formMapping $field ) )
  203.         {
  204.             /* No match, error */
  205.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  206.         }
  207.         else
  208.         {
  209.             /* Match, so set it */
  210.             $this -> formElements $this -> formMapping $field ] ]
  211.                 -> setCSSClass $class );
  212.         }
  213.     }
  214.  
  215.     /**
  216.      * This function is used in order to set the CSS class for the specified
  217.      * input field (appends to the pre-existing CSS class).
  218.      * @param string $field The input field which the CSS class is being set
  219.      * @param string $class The CSS class to be added
  220.      */
  221.     public function addCSSClass $field$class )
  222.     {
  223.         /* Verify that the field exists */
  224.         if isset $this -> formMapping $field ) )
  225.         {
  226.             /* No match, error */
  227.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  228.         }
  229.         else
  230.         {
  231.             $obj $this -> formElements $this -> formMapping $field ] ];
  232.  
  233.             /* Match, so set it */
  234.             $obj -> setCSSClass $obj -> getCSSClass (' ' $class );
  235.         }
  236.     }
  237.  
  238.     /**
  239.      * This function is used in order to clear the CSS information from a field.
  240.      * @param string $field - The input field which the CSS class is being cleared
  241.      */
  242.     public function clearCSSClass $field$class )
  243.     {
  244.         /* Verify that the field exists */
  245.         if isset $this -> formMapping $field ) )
  246.         {
  247.             /* No match, error */
  248.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  249.         }
  250.         else
  251.         {
  252.             /* Match, so clear it */
  253.             $this -> formElements $this -> formMapping $field ] ] -> setCSSClass '' );
  254.         }
  255.     }
  256.  
  257.     /**
  258.      * The getter for the CSS class for a particular field.
  259.      * @param string $field The input field which the CSS class is being retreived
  260.      * @return The current CSS class for the field
  261.      */
  262.     public function getCSSClass $field )
  263.     {
  264.         $class '';
  265.  
  266.         /* Verify that the field exists */
  267.         if isset $this -> formMapping $field ) )
  268.         {
  269.             /* No match, error */
  270.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  271.         }
  272.         else
  273.         {
  274.             /* Match, so clear it */
  275.             $class $this -> formElements $this -> formMapping $field ] ] -> getCSSClass ();
  276.         }
  277.  
  278.         return $class );
  279.     }
  280.  
  281.     /**
  282.      * This function is used in order to set the CSS class for the specified
  283.      * input field (overwrites the pre-existing CSS class).
  284.      * @param string $field The input field which the CSS class is being set
  285.      * @param string $class The new CSS class
  286.      */
  287.     public function setLabelCSSClass $field$class )
  288.     {
  289.         /* Verify that the field exists */
  290.         if isset $this -> formMapping $field ) )
  291.         {
  292.             /* No match, error */
  293.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  294.         }
  295.         else
  296.         {
  297.             /* Match, so set it */
  298.             $this -> formElements $this -> formMapping $field ] ]
  299.                 -> setLabelCSSClass $class );
  300.         }
  301.     }
  302.  
  303.     /**
  304.      * This function is used in order to set the CSS class for the specified
  305.      * input field (appends to the pre-existing CSS class).
  306.      * @param string $field The input field which the CSS class is being set
  307.      * @param string $class The CSS class to be added
  308.      */
  309.     public function addLabelCSSClass $field$class )
  310.     {
  311.         /* Verify that the field exists */
  312.         if isset $this -> formMapping $field ) )
  313.         {
  314.             /* No match, error */
  315.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  316.         }
  317.         else
  318.         {
  319.             $obj $this -> formElements $this -> formMapping $field ] ];
  320.  
  321.             /* Match, so set it */
  322.             $obj -> setLabelCSSClass $obj -> getLabelCSSClass (' ' $class );
  323.         }
  324.     }
  325.  
  326.     /**
  327.      * This function is used in order to clear the CSS information from a field.
  328.      * @param string $field The input field which the CSS class is being cleared
  329.      */
  330.     public function clearLabelCSSClass $field$class )
  331.     {
  332.         /* Verify that the field exists */
  333.         if isset $this -> formMapping $field ) )
  334.         {
  335.             /* No match, error */
  336.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  337.         }
  338.         else
  339.         {
  340.             /* Match, so clear it */
  341.             $this -> formElements $this -> formMapping $field ] ] -> setLabelCSSClass '' );
  342.         }
  343.     }
  344.  
  345.     /**
  346.      * The getter for the CSS class for a particular label.
  347.      * @param string $field The input field which the CSS class is being retreived
  348.      * @returns The current CSS class for the label
  349.      */
  350.     public function getLabelCSSClass $field )
  351.     {
  352.         $class '';
  353.  
  354.         /* Verify that the field exists */
  355.         if isset $this -> formMapping $field ) )
  356.         {
  357.             /* No match, error */
  358.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  359.         }
  360.         else
  361.         {
  362.             /* Match, so clear it */
  363.             $class $this -> formElements $this -> formMapping $field ] ] -> getLabelCSSClass ();
  364.         }
  365.  
  366.         return $class );
  367.     }
  368.  
  369.  
  370.     /**
  371.      * This function is used in order to add an attribute to the corresponding field.
  372.      * @param string $field The input field which the attribute is being applied to
  373.      * @param string $attribute The name of the attribute to add to the field
  374.      * @param string $value The value which is associated with the attribute
  375.      */
  376.     public function addAttribute $field$attribute$value '' )
  377.     {
  378.         /* Verify that the field exists */
  379.         if isset $this -> formMapping $field ) )
  380.         {
  381.             /* No match, error */
  382.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  383.         }
  384.         else
  385.         {
  386.             $obj $this -> formElements $this -> formMapping $field ] ];
  387.  
  388.             /* Match, so add it */
  389.             $obj -> setAttribute $attribute$value );
  390.         }
  391.     }
  392.  
  393.     /**
  394.      * This function is used in order to clear the attribute to the corresponding field.
  395.      * @param string $field The input field which the attributes will be cleared
  396.      */
  397.     public function clearAttributes $field )
  398.     {
  399.         /* Verify that the field exists */
  400.         if isset $this -> formMapping $field ) )
  401.         {
  402.             /* No match, error */
  403.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  404.         }
  405.         else
  406.         {
  407.             $obj $this -> formElements $this -> formMapping $field ] ] -> clearAttributes ();
  408.         }
  409.     }
  410.  
  411.     /**
  412.      * This function is used to set the value associated with the specified input
  413.      * field.
  414.      * @param string $field The input field which the values will be added to
  415.      * @param string $value The value which will be set for / added to the field
  416.      * @param boolean $append TRUE if the values should be appened, FALSE otherwise
  417.      */
  418.     public function setValue $field$value )
  419.     {
  420.         /* Verify that the field exists */
  421.         if isset $this -> formMapping $field ) )
  422.         {
  423.             /* No match, error */
  424.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  425.         }
  426.         else
  427.         {
  428.             $obj $this -> formElements $this -> formMapping $field ] ];
  429.  
  430.             /* Match, so add it */
  431.             $obj -> setValue $values );
  432.         }
  433.     }
  434.  
  435.     /**
  436.      * This function is used to set the value associated with the specified input
  437.      * field.
  438.      * @param string $field The input field which the values will be added to
  439.      * @param mixed $values The values which will be set for / added to the field
  440.      * @param boolean $append TRUE if the values should be appened, FALSE otherwise
  441.      */
  442.     public function setValues $field$values$append FALSE )
  443.     {
  444.         /* Verify that the field exists */
  445.         if isset $this -> formMapping $field ) )
  446.         {
  447.             /* No match, error */
  448.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  449.         }
  450.         else
  451.         {
  452.             $obj $this -> formElements $this -> formMapping $field ] ];
  453.  
  454.             /* Match, so add it */
  455.             $obj -> setValues $values$append );
  456.         }
  457.     }
  458.  
  459.     /**
  460.      * This function is used to clear the values associated with any specified input
  461.      * field.
  462.      * @param string $field The input field which the values will be cleared
  463.      */
  464.     public function clearValues $field )
  465.     {
  466.         /* Verify that the field exists */
  467.         if isset $this -> formMapping $field ) )
  468.         {
  469.             /* No match, error */
  470.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  471.         }
  472.         else
  473.         {
  474.             $obj $this -> formElements $this -> formMapping $field ] ];
  475.  
  476.             /* Match, so set the value to an empty array */
  477.             $obj -> setValues array ()FALSE );
  478.         }
  479.     }
  480.  
  481.     /**
  482.      * This function is used to retrieve the values associated with any specified input
  483.      * field.
  484.      * @param string $field The input field which the values will be retrieved
  485.      */
  486.     public function getValues $field )
  487.     {
  488.         $retVal NULL;
  489.  
  490.         /* Verify that the field exists */
  491.         if isset $this -> formMapping $field ) )
  492.         {
  493.             /* No match, error */
  494.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  495.         }
  496.         else
  497.         {
  498.             $retVal $this -> formElements $this -> formMapping $field ] ] -> getValues ();
  499.         }
  500.  
  501.         return $retVal );
  502.     }
  503.  
  504.     /**
  505.      * This function is used in order to retrieve the value which is associated
  506.      * the specified field (posted or default).
  507.      * @param string $field The input field which will have the value retrieved
  508.      */
  509.     public function getValue $field )
  510.     {
  511.         $retVal NULL;
  512.  
  513.         /* Verify that the field exists */
  514.         if isset $this -> formMapping $field ) )
  515.         {
  516.             /* No match, error */
  517.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  518.         }
  519.         else
  520.         {
  521.             $retVal $this -> formElements $this -> formMapping $field ] ]
  522.                 -> getValue ();
  523.         }
  524.  
  525.         return $retVal );
  526.     }
  527.  
  528.     /**
  529.      * This function is used in order to retrieve whether or not a value will
  530.      * be remembered after processing the form.
  531.      * @param string $field The input field which will have the value retrieved
  532.      */
  533.     public function getRemember $field )
  534.     {
  535.         $retVal NULL;
  536.  
  537.         /* Verify that the field exists */
  538.         if isset $this -> formMapping $field ) )
  539.         {
  540.             /* No match, error */
  541.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  542.         }
  543.         else
  544.         {
  545.             $retVal $this -> formElements $this -> formMapping $field ] ]
  546.                 -> getRemember ();
  547.         }
  548.  
  549.         return $retVal );
  550.     }
  551.  
  552.     /**
  553.      * This function is used in order to set whether or not a value will
  554.      * be remembered after processing the form.
  555.      * @param string $field The input field which will have the value retrieved
  556.      * @param boolean $remember Whether the value should be remembered each postback
  557.      */
  558.     public function setRemember $field$remember )
  559.     {
  560.         /* Verify that the field exists */
  561.         if isset $this -> formMapping $field ) )
  562.         {
  563.             /* No match, error */
  564.             Base::$errors [sprintf FormBuilder::$errors 'invalidfieldname' ]$field );
  565.         }
  566.         else
  567.         {
  568.             $this -> formElements $this -> formMapping $field ] ]
  569.                 -> setRemember $remember );
  570.         }
  571.     }
  572.  
  573.  
  574.     /**
  575.      * This function should be called in order to initialize all of the values
  576.      * for the form.  If the form has been submitted, then all of the variables
  577.      * in the corresponding request (either $_POST or $_GET will be set) based
  578.      * on the actual field names.  (i.e. it takes the unique names and converts
  579.      * it to the one specified by the developer so they can access the
  580.      * information from these fields as they normally would.)  If the option to
  581.      * remember the value for the field has been set, then the field will
  582.      * maintain the value after submission.
  583.      */
  584.     public function initializeValues ()
  585.     {
  586.         $sendArray NULL;
  587.  
  588.         /* Determine where the infomation should be retrieved from / set to */
  589.         if $this -> method == FormBuilder::POST )
  590.         {
  591.             $sendArray &$_POST;
  592.         }
  593.         else
  594.         {
  595.             $sendArray &$_GET;
  596.         }
  597.  
  598.         /* Iterate through all of the elements of the form */
  599.         foreach $this -> formElements as $element )
  600.         {
  601.             /* Initialize the values and send in the array to use */
  602.             $element -> initializeValue $this -> formMD5$sendArray );
  603.         }
  604.     }
  605.  
  606.     /**
  607.      * This function is used in order to return the HTML equivalent of the form
  608.      * which was created.
  609.      * @returns string The form which was created piece by piece
  610.      */
  611.     public function toHTML ()
  612.     {
  613.         /* Build up the form HTML */
  614.         $buff '<form method = \'' $this -> method . '\' action = \''
  615.                 . $this -> action . '\' name = \'' $this -> name . '\' id = \''
  616.                 . $this -> name . '\' enctype = \'multipart/form-data\'>';
  617.  
  618.         /*
  619.          * Add in each of the form elements one by one based on when they were
  620.          * added.
  621.          */
  622.         foreach $this -> formElements as $ele )
  623.         {
  624.             $buff .= __NEWLINE__ $ele -> toHTML $this -> formMD5 );
  625.         }
  626.  
  627.         $buff .= __NEWLINE__ '</form>';
  628.  
  629.         /* Return the full form */
  630.         return $buff );
  631.     }
  632.  
  633.     /**
  634.      * This function is used in order to return the HTML equivalent of the form
  635.      * which was created.
  636.      * @returns array The form which was created piece by piece each element
  637.      *                   as a part of an array
  638.      */
  639.     public function toHTMLArray ()
  640.     {
  641.         /* Build up the form HTML */
  642.         $buff[array 'HTML' =>  '<form method = \'' $this -> method . '\' action = \''
  643.                 . $this -> action . '\' name = \'' $this -> name . '\' id = \''
  644.                 . $this -> name . '\' enctype = \'multipart/form-data\'>' 
  645.             );
  646.  
  647.         /*
  648.          * Add in each of the form elements one by one based on when they were
  649.          * added.
  650.          */
  651.         foreach $this -> formElements as $ele )
  652.         {
  653.             $buff[$ele -> toHTMLArray $this -> formMD5 );
  654.         }
  655.  
  656.         $buff[array 'HTML' => __NEWLINE__ '</form>' );
  657.  
  658.         /* Return the full form */
  659.         return $buff );
  660.     }
  661.  
  662.     /**
  663.      * The setter for the form's name attribute.  The use of this field is
  664.      * extremely helpful because it will help to eliminate naming collisions
  665.      * by prefixing the name of input field with this name.
  666.      * @param string $name The name of the form
  667.      */
  668.     public function setName $name )
  669.     {
  670.         /* Check if the name contained any whitespace (invalid) */
  671.         if preg_match '/\s/'$name == )
  672.         {
  673.             /* It's fine, so just set it */
  674.             $this -> name = $name;
  675.         }
  676.         /* Otherwise, change the name and provide the error */
  677.         else
  678.         {
  679.             /* Change any whitespace to an underscore */
  680.             $this -> name = preg_replace '/\s/''_'$name );
  681.  
  682.             /* Provide an error message */
  683.             Base::$errors [sprintf FormBuilder::$errors 'invalidformname' ]$name );
  684.         }
  685.  
  686.         /* Update the fields */
  687.         $this -> updateFormElements $this -> formElements );
  688.     }
  689.  
  690.     /**
  691.      * This function is used in order to cycle through each of the input
  692.      * elements which were created for this form, and update each of their
  693.      * form attributes accordingly.
  694.      * @param array $elements An array of elements to iterate through
  695.      */
  696.     private function updateFormElements array $elements )
  697.     {
  698.         /* Update any of the field names */
  699.         foreach $elements as $element )
  700.         {
  701.             /* If it is an array, recurse */
  702.             if is_array $element ) )
  703.             {
  704.                 /* Recurse */
  705.                 updateFormElements $element );
  706.             }
  707.             /* Otherwise, update the element */
  708.             else
  709.             {
  710.                 $element -> setForm $this -> form );
  711.             }
  712.         }
  713.  
  714.     }
  715.  
  716.     /**
  717.      * The getter for the form's name attribute.
  718.      * @returns string The form's name attribute.
  719.      */
  720.     public function getName ()
  721.     {
  722.         return $this -> name );
  723.     }
  724.  
  725.     /**
  726.      * The setter for the form's action attribute.
  727.      * @param string $action The action to completed by the form
  728.      */
  729.     public function setAction $action )
  730.     {
  731.         $this -> action $action;
  732.     }
  733.  
  734.     /**
  735.      * The getter for the form's action attribute.
  736.      * @returns string The form's action attribute
  737.      */
  738.     public function getAction ()
  739.     {
  740.         return $this -> action );
  741.     }
  742.  
  743.     /**
  744.      * The setter for the form's method attribute.  It will verify that a valid
  745.      * method type has been porivded and one accept it if that is the case.
  746.      * @param string $method The method type which is desired
  747.      */
  748.     public function setMethod $method )
  749.     {
  750.         /* Ensure that the method is a valid one, otherwise don't add it */
  751.         if strcasecmp FormBuilder::POST$method == 
  752.                 || strcasecmp FormBuilder::POST$method == )
  753.         {
  754.             /* Valid method, so save it */
  755.             $this -> method $method;
  756.         }
  757.         else
  758.         {
  759.             /* Otherwise, invalid method, give an error */
  760.             Base::$errors [sprintf FormBuilder::$errors 'invalidformmethod' ]$method );
  761.         }
  762.     }
  763.  
  764.     /**
  765.      * The getter for the form's method attribute
  766.      * @returns string The form's method attribute
  767.      */
  768.     public function getMethod ()
  769.     {
  770.         return $this -> method );
  771.     }
  772. }

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