<?php
/**
* Form API documentation.
*
*/

/**
* Form property constants.
*
* These constants are defined to keep the namespace of the form tree available for elements.
* Properties are strings that start with '_' (underscore) and have special meaning for the form api.
*/

/**
* Keyword: type.
* Required: true
* Description: Used to specify the form element type. Form elements are defined by implementation of hook_elements.
*/
define('type', '_type');

/**
* Keyword: name.
* Internal: For use within the form api. Should not be set by the developer.
* Description: The form_builder function populates this property based on the location of the form element in the form tree.
*/
define('name', '_name');

/**
* Keyword: id.
* Internal: For use within the form api. Should not be set by the developer.
* Description: The form_builder function populates this property based on the location of the form element in the form tree.
*              This is used for the form_set_error notification, along with the stylesheets to be used.
*/
define('id', '_id');

/**
* Keyword: error
* Internal: For use within the form api. Should not be set by the developer.
* Description: Used by form_render to ascertain wether or not a form element has been printed yet
*/
define('printed', '_printed');

/**
* Keyword: id.
* Internal: For use within the form api. Should not be set by the developer.
* Description: The form_builder function uses this property to keep track of the parent form elements, and uses this to generate the id and name properties.
*/
define('parents', '_parents');

/**
* Keyword: input.
* Description: Wether or not an input is possible for this form element. True / False. Set in the hook_elements implementation.
*/
define('input', '_input');

/**
* Keyword: validated.
* Description: Wether or not an input has been validated.
*/
define('validated', '_validated');

/**
* Keyword: value.
* Used: For all form elements except 'textarea' and the 'default' fallback.
* Description: The value the form element should be set as. Setting this yourself is not required, although it might be a good idea for form elements that
*              don't change. See the default_value property.
*/
define('value', '_value');

/**
* Keyword: default_value.
* Used: For all form elements that have a value property.
* Description: The value the form element should be initialized as. If no submission for this element exists, the element will be set to this value.
*              This means that you do not have to set the value properties for form elements, as they will be automatically handled by the form api.
*/
define('default_value', '_default_value');

/**
* Keyword: title
* Used: For all form elements that have visible output.
* Description: The title of the form element. The developer should use the t() function to translate this property.
*/
define('title', '_title');

/**
* Keyword: description
* Used: For all form elements that have visible output.
* Description: The description of the form element. The developer should use the t() function to translate this property.
*/
define('description', '_description');

/**
* Keyword: required
* Used: For all form elements that have visible output.
* Description: Wether or not the element is required. This automatically validates for empty fields, and flags inputs as required.
*/
define('required', '_required');

/**
* Keyword: cols
* Used: textarea elements.
* Description: How many columns wide the textarea should be.
*/
define('cols', '_cols');

/**
* Keyword: rows
* Used: textarea elements.
* Description: How many rows high the textarea should be.
*/
define('rows', '_rows');

/**
* Keyword: size
* Used: textfield elements.
* Description: How many characters wide should the textfield be.
*/
define('size', '_size');

/**
* Keyword: maxlength
* Used: For textfield element types.
* Description: The maximum amount of characters to accept as input.
*/
define('maxlength', '_maxlength');

/**
* Keyword: valid
* Used: For all form elements that have the value property.
* Description: A list of validation functions that need to be passed.
*/
define('valid', '_valid');

/**
* Keyword: weight
* Used: all elements.
* Description: Used by the form_render function to sort the list of elements before being output.
*/
define('weight', '_weight');

/**
* Keyword: collapsible
* Used: fieldset elements.
* Description: Wether or not the fieldset can be collapsed with javascript.
*/
define('collapsible', '_collapsible');

/**
* Keyword: collapsed
* Used: fieldset elements.
* Description: Wether or not the fieldset is collapsed by default. See collapsible property.
*/
define('collapsed', '_collapsed');

/**
* Keyword: autocomplete_path
* Used: textfield elements.
* Description: The path the AJAX autocomplete script uses as the source for autocompletion.
*/
define('autocomplete_path', '_autocomplete_path');

/**
* Keyword: action
* Used: form elements.
* Description: The path to which the form will be submitted.
*/
define('action', '_action');

/**
* Keyword: method
* Used: form elements.
* Description: The HTTP method the form will be submitted with (GET/POST). Default is 'post'.
*/
define('method', '_method');

/**
* Keyword: attributes
* Used: all visible form elements.
* Description: Additional html attributes, such as 'class' can be set using this mechanism.
*/
define('attributes', '_attributes');

/**
* Keyword: options
* Used: select boxes, checkboxes and radios form elements.
* Description: An associative array containing the options to be used. In the format 'return_value' => 'Display Value'
*
* It is possible to group options together; to do this, change the format of
* $options to an associative array in which the keys are group labels, and the
* values are associative arrays in the normal $options format.
*/
define('options', '_options');

/**
* Keyword: extra
* Used: select boxes.
* Description: Additional HTML to inject into the select element tag.
*/
define('extra', '_extra');

/**
* Keyword: multiple
* Used: select boxes.
* Description: Wether the user may select more than one item.
*/
define('multiple', '_multiple');

/**
* Keyword: button_type
* Used: buttons.
* Description: The type of button to display (cancel or submit)
*/
define('button_type', '_button_type');


/**
* Keyword: error
* Used: All visible form elements.
* Description: Wether or not a form element has been flagged as having an error.
*/
define('error', '_error');


/**
* Multiple elements. For use in the poll module, and for file uploads.
*/

/**
* Keyword: multiple
*/
define('multiple', '_multiple');

/**
* Keyword: min
*/
define('min', '_min');

/**
* Keyword: max
*/
define('max', '_max');

/**
* Keyword: increment
*/
define('increment', '_increment');

function drupal_get_form($form_id, $form, $edit = array(), $callback = NULL) {
  $form = _form_builder($form, $edit);

  $form[type] = 'default';
  if ($content = theme($form_id, $form)) {
    // form_id theme function successful. Form specific theme function.
    $form[children] = $content;
  }
  elseif ($content = theme($callback, $form)) {
    // callback theme function successful. This allows multiple forms to share one theme function.
    $form[children] = $content;
  }

  $form[type] = 'form';
  $form[printed] = FALSE;
  //Set the form element.
  return form_render($form);
}

function drupal_validate_form($form_id, &$form, $edit = array(), $callback = NULL) {

  _form_validate($form, $edit);

  if (function_exists($form_id . '_validate', $edit)) {
    call_user_func($form_id . '_validate', $form_id, $edit);
  }
  if (function_exists($callback . '_validate', $edit)) {
    call_user_func($callback . '_validate', $form_id, $edit);
  }

}

function drupal_execute_form($form_id, $form, $edit = array(), $callback = NULL) {
  if (function_exists($form_id . '_execute', $edit)) {
    call_user_func($form_id . '_execute', $form_id, $edit);
  }
  elseif (function_exists($callback . '_execute', $edit)) {
    call_user_func($callback . '_execute', $form_id, $edit);
  }
}


function _form_validate(&$form, $edit) {
  // Recurse through all children.
  foreach ($elements as $key => $element) {
    if (substr($key, 0, 1) != '_') {
      _form_validate($element, $edit[$key]);
    }
  }

  /* Validate the current input */
  if (!$elements[validated] && $elements[input]) {
    if ($elements[required]) {
      if (!$elements[value]) {
        form_error($elements, t('%name field is required', array('%name' => $element[title])));
      }
      if ($elements[valid]) {
        if (is_array($elements[valid])) {
          foreach ($elements[valid] as $valid) {
            if (function_exists('valid_' . $valid))  {
              call_user_func('valid_' . $valid, $elements);
            }
          }
        }
        else {
          if (function_exists('valid_' . $elements[valid]))  {
            call_user_func('valid_' . $elements[valid], $elements);
          }
        }

      }
    }
    $elements[validated] = TRUE;
  }
}

/**
* Flag an element as having an error.
*/
function form_error(&$element, $message) {
  $element[error] = TRUE;
  $GLOBALS['form'][$element[name]] = $message;
  drupal_set_message($message, 'error');
}


/**
* Adds some required properties to each form element, which are used internally in the form api.
* This function also automatically assigns the value property from the $edit array, provided the
* element doesn't already have an assigned value.
*/
function _form_builder($form, $edit, $parents = array()) {
  if (sizeof($parents)) {
    if (!$form[name]) {
      // Always validate.
      $form[validated] = null;
      $form[name] = 'edit[' . implode('][', $parents) . ']';
      if (!$form[value]) {
        $form[value] = !is_array($edit) ? $edit : $form[default_value];
      }
      $form[parents] = $parents;
      $form[id] = 'edit-' . implode('-', $parents);
      $form[type] = $form[type] ? $form[type] : 'default';
      $form[weight] = $form[weight] ? $form[weight] : 0;
    }
  }

  // Cycle and recurse through all child elements.
  foreach ($form as $key => $element) {
    if (substr($key, 0, 1) != '_') {
      $form[$key] = _form_builder($element, $edit[$key], array_merge($parents, array($key)));
    }
  }
  return $form;
}


/**
* Renders a HTML form given an form tree.  Recursively iterates over each of
* each of the form elements generating HTML code.  This function is usually
* called from within a theme.  To render a form from within a module, use
* <code>drupal_get_form()</code>.
*
* @param $elements
*   The form tree describing the form.
* @return
*   The rendered HTML form.
*/
function form_render(&$elements) {
  $content = '';

  if (is_array($elements)) {
    uasort($elements, "_form_sort");
  }

  if (!$elements[children]) {
    foreach ($elements as $key => $element) {
      if (substr($key, 0, 1) != '_') {
        $content .= form_render($element);
      }
    }
    if ($content) {
      $elements[children] = $content;
    }
  }
  if ($elements[type]) {
    /* Use element defaults */
    $elements = array_merge(_element_info($elements[type]), $elements);
  }

  /* Call the form element renderer */
  if (!$elements[printed]) {
    $content = theme($elements[type], $elements);
    $elements[printed] = TRUE;
  }
  return $content;
}

/**
* Function used by uasort in form render to sort form via weight.
*/
function _form_sort($a, $b) {
  if ($a[weight] == $b[weight]) {
    return 0;
  }
  return ($a[weight] < $b[weight]) ? -1 : 1;
}

/**
* Retrieve the default properties for the defined element type.
*/
function _element_info($type = '', $refresh = null) {
  static $cache;
  $basic_defaults = array(
    description => NULL,
    attributes => NULL,
    required => FALSE
  );

  if ($refresh || !is_array($cache)) {
    $cache = array();
    foreach (module_implements('elements') as $module) {
      $elements = module_invoke($module, 'elements');
      if (is_array($elements)) {
        $cache = array_merge($cache, $elements);
      }
    }
    if (sizeof($cache)) {
      foreach ($cache as $type => $info) {
        $cache[$type] = array_merge($basic_defaults, $cache[$type]);
      }
    }
  }
  if ($type) {
    return $cache[$type];
  }
  else {
    return array_keys($cache);
  }
}

/**
* Format a dropdown menu or scrolling selection box.
*
* @param $element
*   An associative array containing the properties of the element.
*   Properties used : title, value, options, description, extra, multiple, required
* @return
*   A themed HTML string representing the form element.
*
* It is possible to group options together; to do this, change the format of
* $options to an associative array in which the keys are group labels, and the
* values are associative arrays in the normal $options format.
*/
function theme_select($element) {
  $select = '';
  foreach ($element[options] as $key => $choice) {
    if (is_array($choice)) {
      $select .= '<optgroup label="'. $key .'">';
      foreach ($choice as $key => $choice) {
        $select .= '<option value="'. $key .'"'. (is_array($elementp[value]) ? (in_array($key, $element[value]) ? ' selected="selected"' : '') : ($element[value] == $key ? ' selected="selected"' : '')) .'>'. check_plain($choice) .'</option>';
      }
      $select .= '</optgroup>';
    }
    else {
      $select .= '<option value="'. $key .'"'. (is_array($element[value]) ? (in_array($key, $element[value]) ? ' selected="selected"' : '') : ($element[value] == $key ? ' selected="selected"' : '')) .'>'. check_plain($choice) .'</option>';
    }
  }
  return theme('form_element', $element[title], '<select name="edit['. $element[name] .']'. ($element[multiple] ? '[]' : '') .'"'. ($element[multiple] ? ' multiple="multiple" ' : '') . ($element[extra] ? ' '. $element[extra] : '') .' id="' . $element[id] .'">'. $select .'</select>', $element[description], $element[name], $element[required], _form_get_error($element[name]));
}

/**
* Format a group of form items.
*
* @param $element
*   An associative array containing the properties of the element.
*   Properties used : attributes, title, description, children, collapsible, collapsed
* @return
*   A themed HTML string representing the form item group.
*/
function theme_fieldset($element) {
  if ($element[collapsible]) {
    drupal_add_js('misc/collapse.js');

    $element[attributes]['class'] .= ' collapsible';
    if ($element[collapsed]) {
     $element[attributes]['class'] .= ' collapsed';
    }
  }

  return '<fieldset' . drupal_attributes($element[attributes]) .'>' . ($element[title] ? '<legend>'. $element[title] .'</legend>' : '') . $element[children] . ($element[description] ? '<div class="description">'. $element[description] .'</div>' : '') . "</fieldset>\n";
}

/**
* Format the defaul output for form items.
*
* This function is called if the element type is not defined, or if there is no such element type.
* Only the children are output.
*
* @param $element
*   An associative array containing the properties of the element.
*   Properties used : children
* @return
*   A themed HTML string representing the form item group.
*/
function theme_default($element) {
  return $element[children];
}

/**
* Format a radio button.
*
* @param $element
*   An associative array containing the properties of the element.
*   Properties used : required, return_value, value, attributes, title, description
* @return
*   A themed HTML string representing the form item group.
*/
function theme_radio($element) {
  $output = '<input type="radio" class="'. _form_get_class('form-radio', $element[required], _form_get_error($element[name])) .'" name="edit['. $element[name] .']" value="'. $element[return_value] .'"'. ($element[value] ? ' checked="checked"' : '') . drupal_attributes($element[attributes]) .' />';
  if (!is_null($element[title])) {
    $output = '<label class="option">'. $output .' '. $element[title] .'</label>';
  }
  return theme('form_element', NULL, $output, $element[description], $element[name], $element[required], _form_get_error($element[name]));
}

/**
* Format a form item.
*
* @param $element
*   An associative array containing the properties of the element.
*   Properties used :  title, value, description, required, error
* @return
*   A themed HTML string representing the form item.
*/
function theme_item($element) {
  return theme('form_element', $element[title], $element[value], $element[description], $element[id], $element[required], $element[error]);
}


/**
* Format a checkbox.
*
* @param $element
*   An associative array containing the properties of the element.
*   Properties used :  title, value, return_value, description, required
* @return
*   A themed HTML string representing the checkbox.
*/
function theme_checkbox($element) {
  $checkbox = '<input type="checkbox" class="'. _form_get_class('form-checkbox', $element[required], _form_get_error($element[name])) .'" name="'. $element[name] .'" id="'. $element[id].'" value="'. $element[return_value] .'"'. ($element[value] ? ' checked="checked"' : '') . drupal_attributes($element[attributes]) .' />';
  if (!is_null($element[title])) {
    $checkbox = '<label class="option">'. $checkbox .' '. $element[title] .'</label>';
  }
  $hidden = array(type => 'hidden', 'name' => $element[name], value => 1, edit => 'form_zero');
  return form_render($hidden) . theme('form_element', NULL, $checkbox, $element[description], $element[name], $element[required], _form_get_error($element[name]));
}

function theme_submit($element) {
  return theme('button', $element);
}

function theme_button($element) {
  return '<input type="submit" class="form-'. $element[button_type] .'" name="'. $element[name] .'" value="'. check_plain($element[value]) .'" '. drupal_attributes($element[attributes]) ." />\n";
}

/**
* Format a hidden form field.
*
* @param $element
*   An associative array containing the properties of the element.
*   Properties used :  value
* @return
*   A themed HTML string representing the hidden form field.
*/
function theme_hidden($element) {
  return '<input type="hidden" name="'. $element[name] . '" value="'. check_plain($element[value]) ."\" />\n";
}

/**
* Format a textfield.
*
* @param $element
*   An associative array containing the properties of the element.
*   Properties used :  title, value, description, size, maxlength, required, attributes autocomplete_path
* @return
*   A themed HTML string representing the textfield.
*/
function theme_textfield($element) {
  $size = $element[size] ? ' size = "' . $element[size] . '"' : '';

  if ($element[autocomplete_path]) {
    drupal_add_js('misc/autocomplete.js');
    $class = ' form-autocomplete';
    $extra =  '<input class="autocomplete" type="hidden" id="'. $element[id] .'-autocomplete" value="'. check_url(url($element[autocomplete_path], NULL, NULL, TRUE)) .'" disabled="disabled" />';
  }

  $output = '<input type="text" maxlength="'. $element[maxlength] .'" class="'. _form_get_class("form-text $class", $element[required], _form_get_error($element[name])) .'" name="'. $element[name] .'" id="'. $element[id] .'" '. $size .' value="'. check_plain($element[value]) .'"'. drupal_attributes($element[attributes]) .' />';
  return  theme('form_element', $element[title], $output, $element[description], 'edit-'. $element[name], $element[required], _form_get_error($element[name])). $extra;
}

/**
* Format a form.
*
* @param $element
*   An associative array containing the properties of the element.
*   Properties used : action, method, attributes, children
* @return
*   A themed HTML string representing the form.
*/
function theme_form($element) {
  // Anonymous div to satisfy XHTML compliancy.
  return '<form action="'. check_url($element[action]) .'" method="'. $element[method] .'"'. drupal_attributes($element[attributes]) .">\n<div>". $element[children] ."\n</div></form>\n";
}


/**
* Format a textarea.
*
* @param $element
*   An associative array containing the properties of the element.
*   Properties used : title, value, description, rows, cols, required, attributes
* @return
*   A themed HTML string representing the form.
*/
function theme_textarea($element) {
  $cols = $element[cols] ? ' cols="'. $element[cols] .'"' : '';

  return theme('form_element', $element[title], '<textarea'. $cols .' rows="'. $element[rows] .'" name="'. $element[name] .'" id="' . $element[id] .'" class="'. _form_get_class('textarea', $element[required], _form_get_error($element[name])) .'"'. drupal_attributes($element[attributes]) .'>'. check_plain($element[value]) .'</textarea>', $element[description], 'edit-'. $element[name], $element[required], _form_get_error($element[name]));
}

/**
* Format a password field.
*
* @param $element
*   An associative array containing the properties of the element.
*   Properties used :  title, value, description, size, maxlength, required, attributes
* @return
*   A themed HTML string representing the form.
*/
function theme_password($element) {
  $size = $element[size] ? ' size="'. $element[size] .'"' : '';

  $output = '<input type="password" maxlength="'. $element[maxlength] .'" class="'. _form_get_class("form-text $class", $element[required], _form_get_error($element[name])) .'" name="'. $element[name] .'" id="'. $element[id] .'" '. $size .' value="'. check_plain($element[value]) .'"'. drupal_attributes($element[attributes]) .' />';

  return  theme('form_element', $element[title], $output, $element[description], 'edit-'. $element[name], $element[required], _form_get_error($element[name]));
}
?>