<?php
/**
 * @defgroup form Form generation
 * @{
 * Functions to enable output of HTML forms and form elements.
 *
 * Drupal uses these functions to achieve consistency in its form presentation,
 * while at the same time simplifying code and reducing the amount of HTML that
 * must be explicitly generated by modules.
 */
 
/**
 * 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: printed
 * 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: built
 * Internal: For use within the form api. Should not be set by the developer.
 * Description: Used by _form_builder to ascertain wether or not a form element has been built yet
 */
define('built', '_built');

/**
 * Keyword: processed
 * Internal: For use within the form api. Should not be set by the developer.
 * Description: Used by _form_builder to ascertain wether or not a form element has been processed (ie: expanded to multiple elements)
 */
define('processed', '_processed');


/**
 * Keyword: variable
 * Internal: For use within the form api. Should not be set by the developer.
 * Description: used by form builder to populate a global form_variables array. 
 */
define('variable', '_variable');

/**
 * 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: return_value.
 * Used: For select , radio and checkbox elements.
 * Description: The value the form element will return. 
 */
define('return_value', '_return_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');
define('validation_arguments', '_validation_arguments');

/**
 * 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');

/**
 * Keyword: prefix
 * Used: markup element.
 * Description: Text to include before the value and children properties.
 */
define('prefix', '_prefix');

/**
 * Keyword: suffix
 * Used: markup element.
 * Description: Text to include after the value and children properties.
 */
define('suffix', '_suffix');

/**
 * Keyword: error 
 * Used: weight form element.
 * Description: Number of weights to have selectable.
 */
define('delta', '_delta');

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

/**
 * Keyword : process
 * Used : By any element, used to modify a form element.
 */
define('process', '_process');

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

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

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

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

/**
 * Check if the key is a property.
 */
function element_property($key) {
 return (substr($key, 0, 1) == '_');
}

/**
 * Check if the key is a child.
 */
function element_child($key) {
  return (substr($key, 0, 1) != '_');
}

/**
 * Processes a form array, and produces the HTML output of a form.
 * If there is input in the $_POST['edit'] variable, this function
 * will attempt to validate it, using <code>drupal_validate_form</code>, 
 * and then execute the form using <code>drupal_execute_form</code>.
 *
 * @param $form_id
 *   A unique string identifying the form. Allows each form to be themed.
 * @param $form
 *   An associative array containing the structure of the form.
 * @param $callback
 *   An optional callback that will be used in addition to the form_id.
 *  
 */
function drupal_get_form($form_id, &$form, $callback = NULL) {
  global $form_values;
  $form_values = array();

  if (!$form[built]) {
    $form = _form_builder($form);
  }

  // If the form validates, it will execute.
  drupal_execute_form($form_id, $form, $callback);

  // Set the form to markup, to allow children to be populated from a theme function.
  $form[type] = 'markup'; 
  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;
  }

 
  // Set up the form element.  
  $form[type] = 'form';
  $form[printed] = FALSE;
  $form[attributes]['class'] .= ' form-api';
  $form = array_merge(_element_info('form'), $form);

  return form_render($form);
}

function drupal_validate_form($form_id, &$form, $callback = NULL) {
  _form_validate($form);

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

function drupal_execute_form($form_id, $form, $callback = NULL) {
  if (!empty($_POST['edit'])) {
    drupal_validate_form($form_id, $form, $callback);
    if (!form_get_errors()) {
      if (function_exists($form_id . '_execute')) {
        call_user_func($form_id . '_execute', $form_id, $form);
      }
      elseif (function_exists($callback . '_execute')) {
        call_user_func($callback . '_execute', $form_id, $form);
      }
    }
  }
}

function _form_validate(&$form) {

  // Recurse through all children.
  foreach ($elements as $key => $element) {
    if (element_child($key)) {
      _form_validate($element);
    }
  }

  /* 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 $key => $valid) {
            $args = is_array($elements[validation_arguments][$key]) ? $elements[validation_arguments][$key] : array();
            if (function_exists('valid_' . $valid))  {
              call_user_func_array('valid_' . $valid, array_merge(array($elements), $args));
            } 
          } 
        }
        else {
          $args = is_array($elements[validation_arguments]) ? $elements[validation_arguments] : array();
          if (function_exists('valid_' . $elements[valid]))  {
            call_user_func_array('valid_' . $elements[valid], array_merge(array($elements), $args));
          } 
        }

      }
    }
    $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, $parents = array(), $multiple = FALSE) {
  global $form_values;
  
  $form[parents] = ($form[parents]) ? $form[parents] : $parents;

  /* Use element defaults */
  if (!empty($form[type])) { 
    $form = array_merge(_element_info($form[type]), $form);
  }

  if ($form[input]) {
    $form[name] = ($form[name]) ? $form[name] : 'edit[' . implode('][', $form[parents]) . ']';
    $form[id] =  ($form[id]) ? $form[id] : 'edit-' . implode('-', $form[parents]);

    
    $edit = $_POST['edit'];
    $ref =& $form_values;
    foreach ($form[parents] as $parent) {
      $edit = $edit[$parent];
      $ref =& $ref[$parent];
    }
          
    $form[value] = ($form[value]) ? $form[value] : ($edit ? $edit : $form[default_value]);
    $ref = $form[value];
  }

  // Allow for elements to expand to multiple elements. Radios, checkboxes and files for instance.
  if (function_exists($form[process]) && !$form[processed]) {
    $form = call_user_func($form[process], $form);
    $form[processed] = TRUE;
  }

  // Recurse through all child elements.
  $count  = 0;
  foreach ($form as $key => $element) {
    if (element_child($key)) {
      # Assign a decimal placeholder weight, to preserve original array order
      $element[weight] = $element[weight] ? $element[weight] : $count/10;
      $form[$key] = _form_builder($element, array_merge($form[parents], array($key)));
      $count++;
    }
  }
  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 (!element_property($key)) {
        $content .= form_render($element);
      }
    }
    if ($content) {
      $elements[children] = $content;
    }
  }

  /* Call the form element renderer */
  if (!$elements[printed]) { 
    $content = theme(($elements[type]) ? $elements[type]: 'markup', $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 => array(),
    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 $element_type => $info) {
        $cache[$element_type] = array_merge($basic_defaults, $info);
      }
    }
  }

  return $cache[$type];
}

/**
 * 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="'. $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 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" ';
  $output .= 'class="'. _form_get_class('form-radio', $element[required], _form_get_error($element[name])) .'" ';
  $output .= 'name="' . $element[name] .'" ';
  $output .= 'value="'. $element[return_value] .'" ';
  $output .= ($element[value] == $element[return_value]) ? ' checked="checked" ' : ' ';
  $output .= 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 set of radio buttons.
 *
 * @param $element
 *   An associative array containing the properties of the element.
 *   Properties used : title, value, options, description, required and attributes.
 * @return
 *   A themed HTML string representing the radio button set.
 */
function theme_radios($element) {
  if ($element[title] || $element[description]) {
    return theme('form_element', $element[title], $element[children], $element[description], 'edit-'. $element[name], $element[required], _form_get_error($element[name]));
  }
  else {
    return $element[children];
  }
}

define('spawned', '_spawned');
/**
 * Roll out a single checkbox element to a list of checkboxes, using the options array as index.
 */
function expand_radios($element) {
  if (count($element[options]) > 0) {
    foreach ($element[options] as $key => $choice) {
      $element[$key] = array(type => 'radio', title => $choice, return_value => $key, default_value => $element[default_value], attributes => $element[attributes], parents => $element[parents], spawned => TRUE);
    }
  }

  return $element;
}


/**
 * 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 ';
  $checkbox .= 'type="checkbox" ';
  $checkbox .= 'class="'. _form_get_class('form-checkbox', $element[required], _form_get_error($element[name])) . '" ';
  $checkbox .= 'name="'. $element[name] .'" ';
  $checkbox .= 'id="'. $element[id].'" ' ;
  $checkbox .= 'value="'. $element[return_value] .'" ';
  $checkbox .= ($element[value] == $element[return_value]) ? ' checked="checked" ' : ' ';
  $checkbox .= drupal_attributes($element[attributes]) . ' />';

  if (!is_null($element[title])) {
    $checkbox = '<label class="option">'. $checkbox .' '. $element[title] .'</label>';
  }

  return theme('form_element', NULL, $checkbox, $element[description], $element[name], $element[required], _form_get_error($element[name]));
}

/**
 * Format a set of checkboxes.
 *
 * @param $element
 *   An associative array containing the properties of the element.
 * @return
 *   A themed HTML string representing the checkbox set.
 */
function theme_checkboxes($element) {
  if ($element[title] || $element[description]) {
    return theme('form_element', $element[title], $element[children], $element[description], 'edit-'. $element[name], $element[required], _form_get_error($element[name]));
  }
  else {
    return $element[children];
  }
}

function expand_checkboxes($element) {
  if (count($element[options]) > 0) {
    if (!isset($element[default_value]) || $element[default_value] == 0) {
      $element[default_value] = array();
    }
    foreach ($element[options] as $key => $choice) {
      $element[$key] = array(type => 'checkbox', processed => TRUE, title => $choice, return_value => $key, default_value => (in_array($key, $element[default_value]) ? $key : ''), attributes => $element[attributes]);
    }
  }
  return $element;
}


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, edit
 * @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.
  $action = $element[action] ? 'action="' . check_url($element[action]) . '" ' : ''; 
  return '<form '. $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 textarea.
 */
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 HTML markup for use in forms.
 *
 * This is used in more advanced forms, such as theme selection and filter format.
 *
 * @param $element
 *   An associative array containing the properties of the element.
 *   Properties used : prefix, value, children and suffix.
 * @return
 *   A themed HTML string representing the HTML markup.
 */

function theme_markup($element) {
  return $element[prefix] . $element[value] . $element[children] . $element[suffix];
}


/**
* 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 . drupal_attributes($element[attributes]) .' />';

  return  theme('form_element', $element[title], $output, $element[description], $element[id], $element[required], _form_get_error($element[name]));
}

/**
 * Format a weight selection menu.
 *
 * @param $element
 *   An associative array containing the properties of the element.
 *   Properties used :  title, delta, description
 * @return
 *   A themed HTML string representing the form.
 */
function theme_weight($element) {
  for ($n = (-1 * $element[delta]); $n <= $element[delta]; $n++) {
    $weights[$n] = $n;
  }
  $element[options] = $weights;
  $element[type] = 'select';

  return form_render($element);
}

/**
 * File an error against the form element with the specified name.
 */
function form_set_error($name, $message) {
  $GLOBALS['form'][$name] = $message;
  drupal_set_message($message, 'error');
}

/**
 * Return an associative array of all errors.
 */
function form_get_errors() {
  if (array_key_exists('form', $GLOBALS)) {
    return $GLOBALS['form'];
  }
}

/**
 * Return the error message filed against the form with the specified name.
 */
function _form_get_error($name) {
  if (array_key_exists('form', $GLOBALS)) {
    return $GLOBALS['form'][$name];
  }
}

function _form_get_class($name, $required, $error) {
  return $name. ($required ? ' required' : '') . ($error ? ' error' : '');
}

/**
 * Remove invalid characters from an HTML ID attribute string
 *
 * @param $id
 *   The ID to clean
 * @return
 *   The cleaned ID
 */
function form_clean_id($id = NULL) {
  $id = str_replace('][', '-', $id);
  return $id;
}

/**
 * @} End of "defgroup form".
 */

function _print_rp($value) {
  print "<pre>";
  print_r($value);
  print "</pre>";
}
?>