root/plugins/sfFormBuilderPlugin/lib/BasesfFormBuilder.class.php

<?php
/**
 * This file is part of the sfFormBuilderPlugin package.
 * (c) 2006-2007 Jonathan H. Wage <jonwage@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

/**
 * Base Symfony Form Builder Class
 *
 * Class used to easily generate forms in Symfony
 * 
 * <code>
 * $sfFormBuilder = new sfFormBuilder('ModelName');
 * $sfFormBuilder->output(); // would output a blank form
 * </code>
 * 
 * @package     sfFormBuilderPlugin
 * @version     SVN: $Id: BasesfFormBuilder.class.php 3285 2007-02-28 20:01:09Z jwage $
 * @author      Jonathan H. Wage <jonwage@gmail.com> 
 */
class BasesfFormBuilder
{
    /**
     * Module Name
     *
     * Name of the module this form builder instance is in. Auto loaded but can be manually set after instantiated.
     * 
     * <code>
     * $sfFormBuilder->setModuleName('module_name');
     * $sfFormBuilder->getModuleName();
     * </code>
     * 
     * @var string
     * @access public
     */
    public $moduleName = '';
    
    /**
     * Action Name
     *
     * Name of the action this form builder instance is in. Auto loaded but can be manually set after instantiated. 
     * 
     * <code>
     * $sfFormBuilder->setActionName('action_name');
     * $sfFormBuilder->getActionName();
     * </code>
     * 
     * @var string
     * @access public
     */
    public $actionName = '';
    
    /**
     * Form Builder Id
     * 
     * Unique id for this form
     *
     * <code>
     * $sfFormBuilder->setId('unique_form_builder_id');
     * $sfFormBuilder->getId();
     * </code>
     * 
     * @var string
     * @access public
     */
    public $id = '';
    
    /**
     * Model Name 
     * 
     * Main model name the form is based off of. Not required.
     * 
     * <code>
     * $sfFormBuilder->setModelName('Model');
     * $sfFormBuilder->getModelName();
     * </code>
     * 
     * @var string
     * @access public
     */
    public $modelName = '';

        
    /**
     * Model Peer Name 
     * 
     * Automatically set from the model name passed to the constructor but can be manually set like the others
     *
     * <code>
     * $sfFormBuilder->setModelPeerName('ModelPeer');
     * $sfFormBuilder->getModelPeerName();
     * </code>
     *  
     * @var string
     * @access public
     */
    public $modelPeerName = '';
    
    /**
     * Form Builder Name
     *
     * Name of the actual <form> tag. Automatically generated when setId() but can be manually set with setName()
     * 
     * <code>
     * $sfFormBuilder->setName('name_of_form');
     * $sfFormBuilder->getName();
     * </code>
     * 
     * @var string
     * @access public
     */
    public $name = '';
    
    /**
     * Form Builder Title(uses sfContentGetter plugin)
     *
     * Title/header of the form builder. Set by setTitle() and can accept html/string, a partial name(_partial_name), or a component name(__component_name)
     *
     * <code>
     * $formBuilder->setTitle('Title');   // will render as a simple string "Title"
     * $formBuilder->setTitle('_title');  // will render the partial template _title.php
     * $formBuilder->setTitle('__title'); // will render the component __title in components.class.php executeTitle() and _title.php for the component template
     *
     * $formBuilder->getTitle(); // returns the content string to be parsed
     * $formBuilder->getRenderedTitle(); // parses and returns the content evaluated string
     * </code>
     * 
     * @var string
     * @access public
     */
    public $title = null;
    
  /**
   * titleRowContentGetter 
   * 
   * @var mixed
   * @access public
   */
  public $titleRowContentGetter = null;
  
  /**
   * footerRowContentGetter 
   * 
   * @var mixed
   * @access public
   */
  public $footerRowContentGetter = null;

    /**
     * Show Title (true/false)
     * 
     * <code>
     * $sfFormBuilder->setShowTitle(false);
     * $sfFormBuilder->getShowTitle();
     * </code>
     * 
     * @var mixed
     * @access public
     */
    public $showTitle = true;
    
    /**
     * Show Footer (true/false)
     * 
     * <code>
     * $sfFormBuilder->setShowFooter(false);
     * $sfFormBuilder->getShowFooter();
     * </code>
     * 
     * @var mixed
     * @access public
     */
    public $showFooter = true;
    
    /**
     * Show Submit Buttons (true/false)
     *
     * <code>
     * $sfFormBuilder->setShowSubmitButton(false);
     * $sfFormBuilder->getShowSubmitButtons();
     * </code>
     * 
     * @var mixed
     * @access public
     */
    public $showSubmitButtons = true;
    
    /**
     * Form Builder Action (url/route)
     * 
     * Url or route for the form builder action to submit to
     *
     * <code>
     * $sfFormBuilder->setAction('module/action');
     * $sfFormBuilder->setAction('@route');
     * $sfFormBuilder->setAction('http://www.domain.com');
     * $sfFormBuilder->getAction();
     * </code>
     * 
     * @var string
     * @access public
     */
    public $action = '';
    
    /**
     * Form Builder Action Method
     *
     * The method the form should be submitted with. (GET or POST)
     * 
     * <code>
     * $sfFormBuilder->setActionMethod('POST');
     * $sfFormBuilder->setAction('@route', 'POST'); // 2nd argument of setAction can optionally be the method to use for the action
     * $sfFormBuilder->getActionMethod();
     * </code>
     * 
     * @var string
     * @access public
     */
    public $actionMethod = 'POST';
    
    /**
     * Form Builder Extra
     *
     * Any extra html parameters for the <form> tag
     *
     * <code>
     * // Will alert 'test' when the form submits
     * // Use this to set an extra parameters on the <form> tag
     * $sfFormBuilder->setExtra('onSubmit="javscript: alert(\'test\');"');
     * $sfFormBuilder->getExtra();
     * </code>
     * 
     * @var string
     * @access public
     */
    public $extra = '';
    
    /**
     * Form Builder Hidden Fields
     *
     * Array of the hidden fields to be included in the form
     * 
     * <code>
     * $sfFormBuilder->addHiddenField('name', 'value');
     * $sfFormBuilder->getHiddenFields();
     * </code>
     * 
     * @var array
     * @access public
     */
    public $hiddenFields = array();
    
    /**
     * Form Builder Submit Buttons
     *
     * Array of the submit buttons to be included at the bottom of the form
     * 
     * <code>
     * $sfFormBuilder->addSubmitButton('name', array()); // 2nd argument accepts default arguments for a form submit button. Can either be an array or string. http://www.symfony-project.com/api/symfony/helper/FormHelper.html
     * $sfFormBuilder->getSubmitButtons();
     * </code>
     * 
     * @var array
     * @access public
     */
    public $submitButtons = array();    
    
    /**
     * Form Builder Elements
     *
     * Array of all the elements of the form builder
     * 
     * <code>
     * $sfFormBuilder->addCheckboxTag('Checkbox', 'checkbox_1', 1, true, array()); 
     * // If a module is not specified it inherits the module you are in
     * $sfFormBuilder->addContentGetter('Content Getter', '_content_getter', array()); // partial _content_getter_1.php
     * $sfFormBuilder->addContentGetter('Content Getter', '__content_getter', array()); // partial _content_getter_1.php
     * $sfFormBuilder->addContentGetter('Content Getter', '___content_getter', array()); // partial _content_getter_1.php
     * $sfFormBuilder->addContentGetter('Content Getter', 'module_name/{any of the content_getter strings used above}', array()); // partial _content_getter_1.php
     * $sfFormBuilder->addFiller(); // simply adds a blank form element to take a space in the form
     * </code>
     * 
     * http://www.symfony-project.com/api/symfony/helper/FormHelper.html
     * Method exists for each one of the default symfony form helpers. Same arguments except the first argument of our function is the label of the element.
     *
     * http://www.symfony-project.com/api/symfony/helper/ObjectHelper.html
     * Object tags can be added with:
     * <code>
     * $sfFormBuilder->addObjectTag('Label', 'object_helper_function_name', 'Object', 'getMethod', array());
     *
     * $sfFormBuilder->getElements();
     * </code> 
     * 
     * @var array
     * @access public
     */
    public $elements = array();
    
    /**
     * Element Groups
     *
     * Array of the element groups for this form builder
     * 
     * <code>
     * // 2nd argument is an array/string of options. sfContentGetter plugin for parsing the title to allow content to be result of an action, partial, or component.
     * // _partial
     * // __component
     * // ___action
     * // module_name/any_of_the_above
     * $sfFormBuilder->startElementGroup('unique_group_name', 'title=content_getter_string');
     * $sfFormBuilder->getElementGroups();
     * </code>
     * 
     * @var array
     * @access public
     */
    public $elementGroups = array();
    
    /**
     * Current Element Group
     *
     * Var to hold the name of the current element group
     * 
     * <code>
     * $this->setCurrentElementGroup('unique_group_name');
     * $this->getCurrentElementGroup();;
     * </code>
     * 
     * @var mixed
     * @access public
     */
    protected $currentElementGroup;
    
    /**
     * Show Element Groups
     *
     * Flag for whether or not to show the element groups
     * 
     * <code>
     * $sfFormBuilder->setShowElementGroups(false);
     * $sfFormBuilder->getShowElementGroups();
     * </code>
     * 
     * @var mixed
     * @access public
     */
    public $showElementGroups = true;
    
    /**
     * Form Builder Collapsible
     * 
     * Bool value for whether or not the form is collapsible
     * 
     * <code>
     * $sfFormBuilder->setCollapsible(false);
     * $sfFormBuilder->getCollapsible();
     * </code>
     * 
     * @var bool
     * @access public
     */
    public $collapsible = true;
    
    /**
     * Groups Collapsible 
     * 
     * @var mixed
     * @access public
     */
    public $groupsCollapsible = true;
    
    /**
     * Fill In Form
     *
     * This is an alternate method to using the sfFillInFormFilter
     * 
     * <code>
     * $sfFormBuilder->setFillInForm(false);
     * $sfFormBuilder->getFillInForm();
     * </code>
     * 
     * @var mixed
     * @access public
     */
    public $fillInForm = true;
    
    /**
     * Rounder Corners
     *
     * Bool value for whether or not to use sfNiftyCorners plugin to round the corns of our form tables
     * 
     * <code>
     * $sfFormBuilder->setRoundCorners(false);
     * $sfFormBuilder->getRoundCorners();
     * </code>
     * 
     * @var mixed
     * @access public
     */
    public $roundCorners = true;
    
    /**
     * Label Style 
     * 
     * over, left
     *
     * <code>
     * $sfFormBuilder->setLabelStyle('left');
     * $sfFormBuilder->setLabelStyle('over');
     * $sfFormBuilder->setStyle('over', 1);
     * $sfFormBuilder->getLabelStyle();
     * // over - the label is over the form element
     * // left - the label is to the left of the form element
     * </code>
     * 
     * @var string
     * @access public
     */
    public $labelStyle = 'over';
    
    /**
     * Label Width 
     *
     * Manually override the css label width for this form instance
     *
     * <code>
     * $sfFormBuilder->setLabelWidth('300px');
     * $sfFormBuilder->getLabelWidth();
     * </code>
     * 
     * @var mixed
     * @access public
     */
    public $labelWidth;
    
    /**
     * Number of Element Columns
     *
     * <code>
     * $sfFormBuilder->setNumberOfElementColumns(1); // max number of 3 columns
     * $sfFormBuilder->getNumberOfElementColumns();
     * $sfFormBuilder->setStyle('over', 1);
     * </code>
     * 
     * @var string
     * @access public
     */
    public $numberOfElementColumns = 2;
    
    /**
     * Filler Count
     *
     * Var to keep count of the number of fillers used
     * 
     * <code>
     * $sfFormBuilder->setFillerCount((int) 1);
     * $sfFormBuilder->getFillerCount();
     * $sfFormBuilder->incrementFillerCount(); // increment filler count by 1
     * </code>
     * 
     * @var float
     * @access public
     */
    protected $fillerCount = 0;
    
    /**
     * Html
     *
     * Var to hold final html output of the form builder
     *
     * <code>
     * $sfFormBuilder->setHtml('html content');
     * $sfFormBuilder->getHtml();
     * </code>
     * 
     * @var string
     * @access public
     */
    public $html = '';
    
    /**
     * __construct
     * 
     * Set up all the information needed for the form builder from the model name passed
     * 
     * <code>
     * $sfFormBuilder = new sfFormBuilder('Model');
     * echo $sfFormBuilder->output();
     * </code>
     * 
     * @param string $modelName 
     * @access public
     * @return void
     */
    public function __construct($modelName = null)
    {
        $this->loadDefaultsFromConfig();
        
        $this->setModuleName($this->getRequest()->getParameter('module'));    
        $this->setActionName($this->getRequest()->getParameter('action'));
        $this->setId(sfInflector::underscore($modelName).'_form_builder');
        
        if( $modelName )
        {
            $this->setModelName($modelName);
            $this->setModelPeerName($modelName.'Peer');
        }

        $this->setAction($this->getRequest()->getPathInfo());
    }
    
    /**
     * Load Defaults From Configuration
     * 
     * @access protected
     * @return void
     */
    protected function loadDefaultsFromConfig()
    {
        foreach($this AS $key => $value)
        {
      $name = 'app_form_builder_'.sfInflector::underscore($key);

            $newValue = sfConfig::get($name);

            if( isset($newValue) && $newValue != $value )
            {
                $funcName = 'set'.ucfirst($key);
                $this->$funcName($newValue);;
            }
        }
    }

    /**
     * Set Module Action 
     * 
     * @param mixed $module 
     * @param mixed $action 
     * @access public
     * @return void
     */
    public function setModuleAction($module, $action)
    {
        $this->setModuleName($module);
        $this->setActionName($action);
    }

    /**
     * Set Action
     * 
     * @param mixed $action 
     * @param mixed $method 
     * @access public
     * @return void
     */
    public function setAction($action, $method = null)
    {
        $this->action = $action;

        if( $method )
        {
            $this->actionmethod = $method;
        }
    }

    /**
     * Set Style
     *
     * Set the overall style for this form builder instance. Controlled via css.
     * 
     * <code>
     * $sfFormBuilder->setStyle('left', 1'); // normal form with 1 column of elements, with the label to the left of the elements, listed vertically
     * // Max of 3 columns, and the style can be 'left' or 'over'
     * </code>
     * 
     * @param mixed $labelStyle 
     * @param mixed $numberOfElementColumns 
     * @access public
     * @return void
     */
    public function setStyle($labelStyle, $numberOfElementColumns = null)
    {
        $this->setLabelStyle($labelStyle);
        
        if( $numberOfElementColumns )
        {
            $this->setNumberOfElementColumns($numberOfElementColumns);
        }
    }
    
    /**
     * Set Number of Element Columns
     *
     * Set the number of element columns to display the form elements in
     * 
     * <code>
     * $sfFormBuilder->setNumberOfElementColumns(3); // maximum of 3 columns
     * </code>
     * 
     * @param mixed $num 
     * @access public
     * @return void
     */
    public function setNumberOfElementColumns($num)
    {
        if( $num > 3 )
        {
            throw new Exception('sfFormBuilder does not support any more than 3 element columns');
        }
        
        $this->numberOfElementColumns = $num;
    }



    /**
     * Get Form Builder Collapsed Status
     *
     * Retrieve the current saved collapsed status value
     * 
     * @access protected
     * @return bool $status
     */
    protected function getCollapsedStatus()
    {
         return $this->getUser()->getAttribute($this->getId().'_collapsed_status');
    }

    /**
     * Is Form Builder Collapsed
     *
     * Check to see if the current form is collapsed or not
     * 
     * @access protected
     * @return bool $status
     */
    protected function isCollapsed()
    {
        return $this->getCollapsedStatus();
    }

    /**
     * Get Request
     *
     * Get the current sfRequest object instance
     * 
     * @access protected
     * @return object $request
     */
    protected function getRequest()
    {
        return sfContext::getInstance()->getRequest();
    }

    /**
     * Get Response
     *
     * Get the current sfResponse object instance
     * 
     * @access protected
     * @return object $response
     */
    protected function getResponse()
    {
        return sfContext::getInstance()->getResponse();
    }

    /**
     * Get User
     *
     * Get the current sfUser object instance
     * 
     * @access protected
     * @return $object $user
     */
    protected function getUser()
    {
        return sfContext::getInstance()->getUser();
    }

    /**
     * Enable File Uploading
     *
     * Calling this function will automatically add enctype="multipart/form-data" to the <form> tag. This function is called when you add a input file tag to the form
     * 
     * @access public
     * @return void
     */
    public function enableFileUploading()
    {
        $extra = $this->getExtra();
        
        if( !strstr($extra, 'multipart/form-data') )
        {
            $this->setExtra('enctype="multipart/form-data"');
        }
    }

    /**
     * Disable File Uploading
     *
     * Remove the enctype="multipart/form-data" from the <form> tag and disable file uploading from this form
     * 
     * @access public
     * @return void
     */
    public function disableFileUploading()
    {
        $this->setExtra(str_replace('enctype="multipart/form-data"', '', $this->getExtra()));
    }
    
  /**
     * Increment Filler Count
     *
     * Keep track of how many fillers we have added because it is needed for some the name of the filler.
     * 
     * @access protected
     * @return void
     */
    protected function incrementFillerCount()
    {
        $fillerCount = $this->getFillerCount();
        $fillerCount++;
        
        $this->setFillerCount($fillerCount);
    }
    
    /**
     * Start Element Group 
     * 
     * Call this before adding form elements, and it will grouped in this "element group"
     *
     * <code>
     * // title uses the sfContentGetter plugin for parsing an rendering the title.
     * $sfFormBuilder->startElementGroup('group_name', 'title=content_getter_string');
     * $sfFormBuilder->getElementGroups();
     * </code>
     * 
     * @param mixed $name 
     * @access public
     * @return void
     */
    public function startElementGroup($name, $options = array())
    {
        $options = _parse_attributes($options);
        
        $title = array_key_exists('title', $options) ? $options['title']:ucwords(sfInflector::humanize($name));
        $options['title'] = $title;

        $this->elementGroups[$name] = $options;

        $this->setCurrentElementGroup($name);
    }
    
    /**
     * Add Form Builder Object Tag
     *
     * Add a form builder element that uses one of the object_tag helpers
     * 
     * <code>
     * $sfFormBuilder->addObjectTag('User', 'select_tag', 'User', 'getChildId', 'related_class=User peer_method=retrieveChildren()');
     * </code>
     * 
     * @param string $label Label to be used for the form element
     * @param string $formHelper Name of the object_tag helper to be used
     * @param mixed $object Name of the object to instantiate or an already instaniated Model
     * @param string $method Method to use to call on the object to get the value and name of field
     * @param array $options Array or string of options accepted by the object input tag.
     * @access public
     * @return void
     */
    public function addObjectTag($label, $formHelper, $object, $method, $tagOptions = array(), $defaultValue = null, $options = array())
    {
    $tagOptions = _parse_attributes($tagOptions);
      $options = _parse_attributes($options);

        // Supports submitting the object helper method without the object_ prefixed to it
        if( !strstr($formHelper, 'object_') )
        {
            $formHelper = 'object_'.$formHelper;
        }
        
        use_helper('Object');
        
        // Attempt to convert the method to the html field name/control name
        $options['control_name'] = _convert_method_to_name($method, $options);
        
        $element = array('label' => $label, 'name' => $options['control_name'], 'form_helper' => $formHelper, 'helper_arguments' => array('object' => $object, array('get', array($options['control_name'])), 'options' => $tagOptions, 'default_value' => $defaultValue), 'options' => $options);

    $this->addRawElement($element);
    }

    /**
     * Add Content Getter
     * 
     * Add an element to the form that uses the sfContentGetter plugin to pull in content from anywhere in symfony
     *
     * <code>
     * $sfFormBuilder->addContentGetter('Content Getter', 'content_getter_string');
     * </code>
     * 
     * @param mixed $label 
     * @param mixed $content 
     * @param array $vars 
     * @access public
     * @return void
     */
    public function addContentGetter($label, $name, $content, $getterOptions = array(), $options = array())
    {
    $element = array('label' => $label, 'form_helper' => 'content_getter', 'helper_arguments' => array('content' => $content, 'options' => $getterOptions, 'current_module' => $this->getModuleName()), 'name' => $name, 'options' => $options);
        
    $this->addRawElement($element);
    }
    
    /**
     * Add Filler
     *
     * Add a blank form element "filler" to the elements. Takes up the space of an element, but is blank.
     *
     * <code>
     * $sfFormBuilder->addFiller();
     * </code>
     * 
     * @access public
     * @return void
     */
    public function addFiller()
    {
        $this->incrementFillerCount();

        $currentElementGroup = $this->getCurrentElementGroup();
        $element['group'] = $currentElementGroup;
        $key = 'filler_'.$this->getFillerCount();
        $element['name'] = $key;
        $element['label'] = '&nbsp;';
        $element['form_helper'] = 'content_getter';
        $element['helper_arguments']['content'] = '&nbsp;';
        $element['helper_arguments']['current_module'] = $this->getModuleName();
        $element['helper_arguments']['options'] = array();
        $element['label_style'] = $this->getLabelStyle();
        $element['number_of_element_columns'] = $this->getNumberOfElementColumns();
        $element['options'] = array();

        $this->elements[$currentElementGroup][$key] = $element;
    }
    
    /**
     * Add Form Builder Input Tag
     *
     * Add a form builder element that uses the input_tag form helper
     * 
     * <code>
     * $sfFormBuilder->addInputTag('Input Tag', 'input_tag', 'default value');
     * </code>
     * 
     * @param string $label Label for the input tag
     * @param string $name Name of the input tag
     * @param string $value Value of the input tag
     * @param mixed $tagOptions Array/string of options accepted by the input_tag form helper
   * @param mixed $options Array/string of options for the form element
     * @access public
     * @return void
     */
    public function addInputTag($label, $name, $value = null, $tagOptions = array(), $options = array())
    {
        $tagOptions = _parse_attributes($tagOptions);

    $this->addElement('input_tag', $label, array('name' => $name, 'value' => $value, 'options' => $tagOptions), $options);
    }

    /**
     * Add Form Builder Checkbox Tag
     *
     * Add a form builder element that uses the checkbox_tag form helper
     * 
     * <code>
     * $sfFormBuilder->addCheckboxTag('Checkbox', 'checkbox', 1, false);
     * </code>
     * 
     * @param string $label Label for the checkbox tag
     * @param mixed $name Name of the checkbox tag
     * @param string $value Value of the checkbox tag
     * @param bool $checked Whether or not the checkbox is checked
     * @param mixed $options Array/string of options accepted by the checkbox_tag form helper
     * @access public
     * @return void
     */
    public function addCheckboxTag($label, $name, $value = '1', $checked = false, $tagOptions = array(), $options = array())
    {
    $tagOptions = _parse_attributes($tagOptions);
        
    $this->addElement('checkbox_tag', $label, array('name' => $name, 'value' => $value, 'checked' => $checked, 'options' => $tagOptions), $options);
    }

    /**
     * Add Form Builder Input Date Range Tag
     *
     * Add a form builder element that uses the input_date_range_tag form helper
     * 
     * <code>
     * $sfFormBuilder->addInputDateRangeTag('Input Date Range Tag', 'date', 'from=0000-00-00 to=0000-00-00');
     * </code>
     * 
     * @param string $label Label for the input date range tag 
     * @param mixed $name Name of the input date range tag
     * @param mixed $value Value of the input date range tag
     * @param string $tagOptions Array/string of options accepted by the input_date_range_tag form helper
   * @param string $options Array/string of options for
     * @access public
     * @return void
     */
    public function addInputDateRangeTag($label, $name, $value, $tagOptions = array(), $options = array())
    {
        $tagOptions = _parse_attributes($tagOptions);

    $this->addElement('input_date_range_tag', $label, array('name' => $name, 'value' => $value, 'options' => $tagOptions), $options);
    }

    /**
     * Add Form Builder Input Date Tag
     *
     * Add a form builder element that uses the input_date_tag form helper
     * 
     * <code>
     * $sfFormBuilder->addInputDateTag('Input Date Tag', 'date', '0000-00-00');
     * </code>
     * 
     * @param string $label Label for the input_date_tag
     * @param string $name Name of the input_date_tag
     * @param string $value Value of the input_date_tag
     * @param mixed $options Array/string of options accepted by the input_date_tag form helper
     * @access public
     * @return void
     */
    public function addInputDateTag($label, $name, $value = null, $tagOptions = array(), $options = array())
    {
    $tagOptions = _parse_attributes($tagOptions);
        
    $this->addElement('input_date_tag', $label, array('name' => $name, 'value' => $value, 'options' => $tagOptions), $options);
    }

    /**
     * Add Form Builder Input File Tag
     *
     * Add a form builder element that uses the input_file_tag form helper
     * 
     * <code>
     * $sfFormBuilder->addInputFileTag('File', 'file1');
     * </code>
     * 
     * @param string $label Label for the input_file_tag
     * @param string $name Name of the input_file_tag
     * @param mixed $options Array/string of options accepted by the input_file_tag
     * @access public
     * @return void
     */
    public function addInputFileTag($label, $name, $tagOptions = array(), $options = array())
    {
    $tagOptions = _parse_attributes($tagOptions);
        
    $this->addElement('input_file_tag', $label, array('name' => $name, 'options' => $tagOptions), $options);
        
        // Enable file uploading since we are using an input file tag
        $this->enableFileUploading();
    }

    /**
     * Add Form Builder Input Password Tag
     *
     * Add a form builder element that uses the input_password_tag form helper
     * 
     * <code>
     * $sfFormBuilder->addInputPasswordTag('Password', 'password');
     * </coe>
     * 
     * @param string $label Label for the input_password_tag 
     * @param string $name Name of the input_password_tag
     * @param mixed $value Value of the input_password_tag
     * @param mixed $options Array/string of options accepted by the input_password_tag
     * @access public
     * @return void
     */
    public function addInputPasswordTag($label, $name = 'password', $value = null, $tagOptions = array(), $options = array())
    {
    $tagOptions = _parse_attributes($tagOptions);

    $this->addElement('input_password_tag', $label, array('name' => $name, 'value' => $value, 'options' => $tagOptions), $options);
    }

    /**
     * Add Form Builder Radio Button Tag
     *
     * Add a form builder element that uses the radio_button_tag form helper
     * 
     * <code>
     * $sfFormBuilder->addRadioButtonTag('Radio Button', 'radio', 'value', false);
     * </code>
     * 
     * @param string $label Label for the radio button tag
     * @param string $name Name of the radio button tag
     * @param string $value Value of the radio button tag
     * @param bool $checked Whether or not the radio is checked
     * @param string $options Array/string of options accepted by the radio_button_tag
     * @access public
     * @return void
     */
    public function addRadioButtonTag($label, $name, $value, $checked = false, $tagOptions = array(), $options = array())
    {
    $tagOptions = _parse_attributes($tagOptions);
        
    $this->addElement('radiobutton_tag', $label, array('name' => $name, 'value' => $value, 'checked' => $checked, 'options' => $tagOptions), $options);
    }

    /**
     * Add Form Builder Select Country Tag
     *
     * Add a form builder element that uses the select_country_tag form helper
     * 
     * <code>
     * $sfFormBuilder->addSelectCountryTag('Country', 'country', 'US');
     * </code>
     * 
     * @param string $label Label for the select country tag
     * @param string $name Name of the selet country tag
     * @param string $selected The value/country to auto select
     * @param mixed $options Array/string of options accepted by the select_country_tag
     * @access public
     * @return void
     */
    public function addSelectCountryTag($label, $name, $selected = null, $tagOptions = array(), $options = array())
    {
    $tagOptions = _parse_attributes($tagOptions);

    $this->addElement('select_country_tag', $label, array('name' => $name, 'selected' => $selected, 'options' => $tagOptions), $options);
    }

    /**
     * Add Form Builder Select Language Tag
     * 
     * Add a form builder element that uses the select_language_tag form helper
     *
     * <code>
     * $sfFormBuilder->addSelectLanguageTag('Language', 'language', 'English');
     * </code>
     * 
     * @param string $label Label for the select language tag
     * @param string $name Name of the select language tag
     * @param string $selected Value to pre-select in the language tag
     * @param mixed $options Array/string of options accepted by the select_language_tag
     * @access public
     * @return void
     */
    public function addSelectLanguageTag($label, $name, $selected = null, $tagOptions = array(), $options = array())
    {
    $tagOptions = _parse_attribute($tagOptions);
        
    $this->addElement('select_language_tag', $label, array('name' => $name, 'selected' => $selected, 'options' => $tagOptions), $options);
    }

    /**
     * Add Form Builder Select Tag
     *
     * Add a form builder element that uses the select_tag form helper
     * 
     * <code>
     * // 3rd argument can be a string of html options, or it can accept an array of arguments for the objects_for_select() function in symfony.
     * $sfFormBuilder->addSelectTag('Select', 'select', '<option></option>');
     * $sfFormBuilder->addSelectTag('Select, 'select', array($modelArray, 'getValueMethod', 'getTextMethod', 'selected_value'));
     * </code>
     * 
     * @param string $label Label for the select tag
     * @param string $name Name of the select tag
     * @param mixed $option_tags Array of options to be generated using options_for_select() or an already built string of options
     * @param mixed $options Array/string of options accepted by the select_tag form helper
     * @access public
     * @return void
     */
    public function addSelectTag($label, $name, $option_tags = null, $tagOptions = array(), $options = array())
    {
    $tagOptions = _parse_attributes($tagOptions);

        if( is_array($option_tags) )
        {
            $option_tags = call_user_func_array('options_for_select', $option_tags);
        }
        
        $this->addElement('select_tag', $label, array('name' => $name, 'option_tags' => $option_tags, 'options' => $tagOptions), $options);
    }

    /**
     * Add Form Builder Text Area Tag
     *
     * Add form builder element that uses the text_area_tag form helper
     * 
     * <code>
     * $sfFormBuilder->addTextAreaTag('Text Area', 'textarea', 'content for text area');
     * </code>
     * 
     * @param string $label Label for the text area
     * @param string $name Name of the text area
     * @param string $content Content/value of the text area
     * @param mixed $options Array/string of options accepted by the textarea_tag helper
     * @access public
     * @return void
     */
    public function addTextAreaTag($label, $name, $content = null, $tagOptions = array(), $options = array())
    {
    $tagOptions = _parse_attributes($tagOptions);
        
    $this->addElement('textarea_tag', $label, array('name' => $name, 'content' => $content, 'options' => $tagOptions), $options);
    }
    
    /**
     * Add Form Builder Element
     *
     * Method used by the other public add form builder element to build and add the element to the base array of elements
     * 
     * @param string $formHelper Name of the form helper to use for this element
     * @param string $label Label of the element
     * @param array $helperArguments Array of the arguments needed for the helper
     * @access protected
     * @return void
     */
    protected function addElement($formHelper, $label, $helperArguments, $options = array())
    {
    $element = array('label' => $label, 'name' => $helperArguments['name'], 'form_helper' => $formHelper, 'helper_arguments' => $helperArguments, 'options' => $options);
        
    $this->addRawElement($element);
    }

    /**
     * Add Raw Element 
     * 
     * @param mixed $element 
     * @access protected
     * @return void
     */
    protected function addRawElement($element)
    {
        $currentElementGroup = $this->getCurrentElementGroup();
        $element['group'] = $currentElementGroup;    
        $element['label_style'] = $this->getLabelStyle();
        $element['number_of_element_columns'] = $this->getNumberOfElementColumns();
          
        $element['options'] = _parse_attributes($element['options']);
        
    $this->elements[$currentElementGroup][$element['name']] = $element;
    }    
    
    /**
     * Set Form Builder Id
     *
     * Setup the form builder by setting a unique id. Other class values will be set based on this id if they have not been set yet
     * 
     * <code>
     * $sfFormBuilder->setId('form_id');
     * </code>
     * 
     * @param string $id 
     * @access public
     * @return void
     */
    public function setId($id)
    {
        $this->id = $id;
        
        if( !$this->getTitle() )
        {
            $this->setTitle(ucwords(sfInflector::humanize($id)));
        }

        if( !$this->getName() )
        {
            $this->setName($this->getId().'_form_name');
        }
    }
    
    /**
     * Set Title
     *
     * <code>
     * // Uses sfContentGetter plugin for parsing and rendering the title
     * $sfFormBuilder->setTitle('content_getter_string');
     * echo $sfFormBuilder->getRenderedTitle(); // will parse, and return rendered title with sfContentGetter
     * </code>
     * 
     * @param mixed $title 
     * @access public
     * @return void
     */
    public function setTitle($title)
    {
        if( $title == false )
        {
            $this->setShowTitle(false);
            $this->title = null;
        } else {
            $this->title = $title;
            $this->setShowTitle(true);
        }
    }
    
    /**
     * Get Form Builder Rendered Title
     *
     * Process the set title and get the partial, component, or return the title string
     * 
     * <code>
     * echo $sfFormBuilder->getRenderedTitle();
     * </code>
     * 
     * @access public
     * @return string $title
     */
    public function getRenderedTitle()
    {
        return sfContentGetter::getInstance($this->getTitle(), array(), $this->getModuleName())->output();
    }
    
    /**
     * Add Form Builder Hidden FIeld
     * 
     * Add a form builder hidden field
     * 
     * <code>
     * $sfFormBuilder->addHiddenField('name', 'value');
     * </code>
     * 
     * @param string $name Name of the hidden field
     * @param string $value Value of the hidden field
     * @access public
     * @return void
     */
    public function addHiddenField($name, $value)
    {
        $this->hiddenFields[$name] = $value;
    }
    
    /**
     * Add Form Builder Submit Button
     *
     * Add a submit button to the form builder
     * 
     * <code>
     * // uses symfony submit_tag() so 2nd argument can be an array or string of options
     * $sfFormBuilder->addSubmitButton('name');
     * </code>
     * 
     * @param string $name Name of the submit button
     * @param mixed $options Array/string of options accepted by the submit_tag form helper
     * @access public
     * @return void
     */
    public function addSubmitButton($name, $options = array())
    {
        $options = _parse_attributes($options);
        $options['value'] = array_key_exists('value', $options) ? $options['value']:sfInflector::humanize($name);
        $options['name'] = $name;
        
        $this->submitButtons[$name] = $options;
    }
        
    /**
     * Get Form Builder Header Html
     *
     * Get the form header html, includes hidden fields and opening <form> tag
     * 
     * @access public
     * @return string $html
     */
    public function getHeaderHtml()
    {
        $html  = "\n\n".'<form name="'.$this->getName().'" id="'.$this->getId().'" action="'.sfContext::getInstance()->getController()->genUrl($this->getAction()).'" method="'.$this->getActionMethod().'" '.$this->getExtra().'>';
        $html .= $this->getHiddenFieldsHtml()."\n";
        
        return $html;
    }

    /**
     * Ge Form Builder Hidden Fields html
     *
     * Loop over array of hidden fields and generate html
     * 
     * @access public
     * @return string $html
     */
    public function getHiddenFieldsHtml()
    {
        $hiddenFields = $this->getHiddenFields();
        
        if( is_array($hiddenFields) AND !empty($hiddenFields) )
        {
            $html = '';
            foreach($hiddenFields AS $name => $value)
            {
                $html .= '<input type="hidden" name="'.$name.'" value="'.$value.'" />'."\n";
            }
            
            return $html;
        }
    }

    /**
     * Get Form Builder Footer Html
     *
     * Get the html for the form builder footer. Inlcudes submit buttons and closing form tag
     * 
     * @access public
     * @return void
     */
    public function getFooterRowHtml()
    {
        $html = '';

        if( $this->getShowFooter() )
        {
      if( $this->getFooterRowContentGetter() )
      {
            $html .=  sfContentGetter::getInstance($this->getFooterRowContentGetter(), array('formBuilder' => $this), $this->getModuleName())->output();
      } else {
              $html .= "\n\n".'<div class="form_builder_footer"  id="'.$this->getId().'_footer">'."\n";
            
              if( $this->getShowSubmitButtons() )
              {
                  $html .= $this->getSubmitButtonsHtml();
              }

              $html .= '</div>'."\n\n";
          }
    }
        
        $html .= '</form>'."\n\n";
        
        return $html;
    }
    
    /**
     * getSubmitButtonsHtml 
     * 
     * @access public
     * @return void
     */
    public function getSubmitButtonsHtml()
    {
        $submitButtons = $this->getSubmitButtons();
        
        if( is_array($submitButtons) AND !empty($submitButtons) )
        {
            $html = '';
            foreach($submitButtons AS $name => $options)
            {
                $options['name'] = $name;
                $options['class'] = 'button';
                $html .= submit_tag($options['value'], $options);
            }

            $output  = "\t".'<div class="form_builder_footer_submit_buttons" id="'.$this->getId().'_footer_submit_buttons">'."\n";
            $output .= "\t\t".$html;
            $output .= "\n\t".'</div>'."\n";
            
            return $output;
        }
    }

    /**
     * Generate Form Builder
     * 
     * Alias to generate the form builder, calls generateHtml()
     * 
     * @access public
     * @return void
     */
    public function generate()
    {
        $this->generateHtml();
    }
    
    /**
     * Get Form Builder Element Input
     *
     * Get the input part of a form element. Will either be a partial, component, or a form helper
     * 
     * @param array $element Array of element properties for the element input
     * @param array $helperArguments Array of arguments for the helper
     * @access public
     * @return void
     */
    public function getElementInput($element, $helperArguments)
    {
        // Simple form fillin feature
        $request = $this->getRequest();
        
        $formHelper = _get_option($element, 'form_helper');

    if( $this->getFillInForm() AND $request->hasParameter($element['name']) AND !strstr($formHelper, 'password') )
        {
      if( $formHelper == 'checkbox_tag' )
      {
              $helperArguments['checked'] = $request->getParameter($element['name']) == $helperArguments['value'] ? true:false;  
      } else {
              $helperArguments['value'] = $request->getParameter($element['name']);
        $helperArguments['default_value'] = $helperArguments['value'];
      }
    }
        
        if( $formHelper == 'content_getter' )
        {
      $vars = array_merge($helperArguments['options'], array('name' => $element['name']));
            return sfContentGetter::getInstance($helperArguments['content'], $vars, $helperArguments['current_module'])->output();
        }
        else
        {
            if( $formHelper )
            {
                if( function_exists($formHelper) )
                {
                    // If just a string was passed, lets instantiate a object with that string
                    if( array_key_exists('object', $helperArguments) && $helperArguments['object'] && !is_object($helperArguments['object']) )
                    {
                        $object = $helperArguments['object'];

                        // Make sure class exists before creating it
                        if( class_exists($object) )
                        {
                            $helperArguments['object'] = new $object();
                        } else {
                            throw new Exception($object." class could not be found. Please pass a valid model name or an already instantiated model");
                        }
                    }
                    
                    $formElement = call_user_func_array($formHelper, $helperArguments);
                } else {
                    throw new Exception("$formHelper does not exist");
                }
                
                return $formElement;
            }
        }
    }
    
    /**
     * Get Form Builder Element Label
     *
     * Get the label html for a form element
     * 
     * @param string $name Name of the <label> tag
     * @param string $label Label/value to put in <label> tag
     * @access public
     * @return string $html
     */
    public function getElementLabel($name, $label)
    {
        if( $label )
        {
            $options  = 'accesskey='.strtolower($label[0]);
            
            $label = sfContentGetter::getInstance($label, array(), $this->getModuleName())->output();
            
            return label_for($name, $label, $options);
        }
    }

  /**
   * getElementHelp 
   * 
   * @param mixed $element 
   * @access public
   * @return void
   */
  public function getElementHelp($fieldName, $options)
  {
    if( array_key_exists('help', $options) )
    {
      return '<span class="form_builder_help_icon" onMouseOver="javascript: document.getElementById(\''.$fieldName.'_help\').className = \'form_builder_help_box_show\';" onMouseOut="javascript: document.getElementById(\''.$fieldName.'_help\').className = \'form_builder_help_box\';">?</span> <span id="'.$fieldName.'_help" class="form_builder_help_box">'.$options['help'].'</span>';
    }
  }

        
    /**
     * Has Elements
     *
     * Returns true/false for whether or not the form builder has any elements
     * 
     * @access public
     * @return bool
     */
    public function hasElements()
    {
        return (isset($this->elements) AND !empty($this->elements) ) ? true:false;
    }
    
    /**
     * Get Form Builder Elements Html
     *
     * Loop over all the form builder elements and generate the majority of the form
     * 
     * @access public
     * @return string $formElementHtml
     */
    public function getElementsHtml()
    {
        $formElementsHtml = '';
        $formElementsHtml .= $this->getHeaderHtml();
        
        $groups = $this->getElements();
        
        $count = 0;
        foreach($groups AS $group => $elements)
        {
            $formElementsHtml .= $this->getElementGroupHeaderHtml($group);
            
            $groupElements = '';
            foreach($elements AS $element)
            {
                $count++;
                $groupElements .= $this->getElementHtml($element, $count);
            }
            
            if( $this->getGroupsCollapsible() AND $group AND $this->getShowElementGroups() )
            {
                $formElementsHtml .= sfCollapsibleContent::wrapContent($this->getId().'_element_group_'.$group, $groupElements);
            } else {
                $formElementsHtml .= $groupElements;
            }

            $formElementsHtml .= $this->getElementGroupFooterHtml($group);
        }
        
        $formElementsHtml .= $this->getFooterRowHtml();
        
        return $formElementsHtml;
    }

    public function getElementHtml($element, $count)
    {
        $numberOfElementColumns = $element['number_of_element_columns'];
      $labelStyle = $element['label_style'];

    $helperArguments = _get_option($element, 'helper_arguments', array());
        
        $elementInput = $this->getElementInput($element, $helperArguments);
        
        $fieldName = _get_option($element, 'name');
        $label = _get_option($element, 'label');
        $required = _get_option($element['options'], 'required');

        $passHelperArguments = $helperArguments;
        
        $helperArgumentName = _get_option($helperArguments, 'name');
        
        $formElementsHtml  = "\t".'<div class="form_builder_row_'.$numberOfElementColumns.'" id="'.$this->getId().'_row_'.$fieldName.'">'."\n";
        
        $formElementsHtml .= "\t\t".'<div class="form_builder_row_element" id="'.$this->getId().'_row_element_'.$fieldName.'">'."\n";
    
        $error = sfContext::getInstance()->getRequest()->hasError($fieldName) ? true:false;
        
    $errorHtml = '';
        if( $error )
        {
            $errorHtml = '<span class="form_builder_error_'.$labelStyle.'"><span class="error_icon" onMouseOver="javascript: document.getElementById(\''.$fieldName.'_error_holder\').style.display = \'block\';" onMouseOut="javascript: document.getElementById(\''.$fieldName.'_error_holder\').style.display = \'none\';">?</span><span class="error_holder" id="'.$fieldName.'_error_holder">'.sfContext::getInstance()->getRequest()->getError($fieldName).'</span></span>';
        } else {
      if( $required )
      {
        $errorHtml = '<font style="font-weight: bold; color: red;">*</font>';
      }
    }
            
        $labelWidth = '';
        if( $width = $this->getLabelWidth() )
        {
            $labelWidth = ' style="width: '.$width.';"';
        }    
        
        $formElementsHtml .= "\t\t\t".'<div '.$labelWidth.' class="form_builder_element_label_'.$labelStyle.'" id="'.$this->getId().'_row_element_label_'.$fieldName.'">'.$this->getElementHelp($fieldName, $element['options']).$this->getElementLabel($fieldName, $label)." ".$errorHtml."</div>\n";
        $formElementsHtml .= "\t\t\t".'<div class="form_builder_element_input_'.$labelStyle.'" id="'.$this->getId().'_row_element_input_'.$fieldName.'">'.$elementInput.'</div>'."\n";
        
        $formElementsHtml .= "\t\t</div>\n";
        
        $formElementsHtml .= "\t".'</div>'."\n";
        
        return $formElementsHtml;
    }
    
    public function getElementGroupHeaderHtml($group)
    {
        $title  = "\n".'<fieldset class="form_builder_field_set" id="'.$this->getId().'_field_set_'.$group.'">'."\n";
        
        if( $group )
        {
            $options = $this->elementGroups[$group];
            $options['title'] = sfContentGetter::getInstance($options['title'], array(), $this->getModuleName())->output();
            
            $title .= "<legend>\n";
            $title .= $this->getElementHelp($group, $options);
            if( $this->getGroupsCollapsible() )
            {
                $title .= sfCollapsibleContent::getWrapperController($this->getId().'_element_group_'.$group, null, $options['title']);
            } else {
                $title = $options['title'];
            }
        
            $title .= "\n</legend>\n";
        }
        
        return $title;
    }
    
    public function getElementGroupFooterHtml()
    {
      return "</fieldset>\n";
    }

    /**
     * Get Form Builder Collapse Icon Html
     * 
     * Get the html block for the form builder collapse icon
     * 
     * @access public
     * @return string $html
     */
    public function getCollapseIconHtml()
    {
        if( $this->getCollapsible() )
        {
            return '<div class="form_builder_collapse_icon">'.sfCollapsibleContent::getWrapperController($this->getId(), $this->isCollapsed()).'</div>';
        }
    }

    /**
     * Get Form Builder Title Row
     *
     * Get the html for the form builder title row
     * 
     * @access public
     * @return string $html
     */
    public function getTitleRow()
    {
    if( $this->getTitleRowContentGetter() )
    {
          return sfContentGetter::getInstance($this->getTitleRowContentGetter(), array('formBuilder' => $this), $this->getModuleName())->output();
    } else {
      return '<div class="form_builder_title_row" id="'.$this->getId().'_title_row">'.$this->getCollapseIconHtml().'<div id="form_builder_title_wrapper">'.$this->getRenderedTitle($this->getTitle()).'</div></div>';
      }
  }
    
    /**
     * Generate Form Builder Html
     *
     * Generate all the form builder html and set it in the class
     * 
     * @access public
     * @return void
     */
    public function generateHtml()
    {
        $html  = '<div class="form_builder_wrapper" id="'.$this->getId().'_wrapper">';    
        
        if( $this->getShowTitle() )
        {
            $html .= $this->getTitleRow();
        }

        $elementsHtml = $this->getElementsHtml();
        
        $html .= sfCollapsibleContent::wrapContent($this->getId(), $elementsHtml);
        
        $html .= '</div>';
            
        $this->setHtml($html);
    }

    /**
     * Output 
     * 
     * Do everything here, and return the output of the form builder
     * 
     * @access public
     * @return string
     */
    public function output()
    {
        use_helper('Validation');
        
    $this->getResponse()->addStylesheet('/sfFormBuilderPlugin/css/form_builder');
    $this->getResponse()->addJavascript('/sfFormBuilderPlugin/js/form_builder');
      $this->getResponse()->addJavascript(sfConfig::get('sf_prototype_web_dir').'/js/prototype');
        
    $this->generate();
        
        $html = "\n<!--- sfFormBuilder - ".$this->getId()."--->\n\n";
        
        $html .= $this->getHtml();
        
        if( $this->getRoundCorners() )
        {
            use_helper('Javascript');
            use_helper('nifty');
            
        $this->getResponse()->addJavascript('/sfNiftyPlugin/js/niftycube');
        $this->getResponse()->addStylesheet('/sfNiftyPlugin/css/niftyCorners');   
            
            $html .= javascript_tag("Rounded('div#".$this->getId()."_wrapper','');");
        }
        
        return $html;
    }
    
    /**
     * __call 
     * 
     * @param mixed $method 
     * @param mixed $arguments 
     * @access protected
     * @return void
     */
    protected function __call($method, $arguments)
    {
        if( substr($method, 0, 2) == 'is' )
        {
            $property = substr($method, 2);
            $property = strtolower($property[0]).substr($property, 1);
            
            if( property_exists($this, $property) )
            {
                return $this->$property;
            } else {
                throw new Exception("$property does not exist on ".get_class($this));
            }
        }
        else if( substr($method, 0, 3) == 'get' )
        {
            $property = substr($method, 3);
            $property = strtolower($property[0]).substr($property, 1);    
            
            if( property_exists($this, $property) )
            {
                return $this->$property;
            } else {
                throw new Exception("$property does not exist on ".get_class($this));
            }
        }
        else if( strtolower(substr($method, 0, 3)) == 'set' )
        {
            $property = substr($method, 3);
            $property = strtolower($property[0]).substr($property, 1);    
            
            if( property_exists($this, $property) )
            {
                if( array_key_exists(0, $arguments) )
                {
                    $this->$property = $arguments[0];
                } else {
                    $this->$property = NULL;
                }
            } else {
                throw new Exception("$property does not exist on ".get_class($this));
            }
        } else {
            throw new Exception("$method does not exist on ".get_class($this));
        }
    }    
}