form.inc 150 KB
Newer Older
1
<?php
2 3
// $Id$

4
/**
5 6 7 8 9 10
 * @defgroup forms Form builder functions
 * @{
 * Functions that build an abstract representation of a HTML form.
 *
 * All modules should declare their form builder functions to be in this
 * group and each builder function should reference its validate and submit
11
 * functions using \@see. Conversely, validate and submit functions should
12
 * reference the form builder function using \@see. For examples, of this see
13
 * system_modules_uninstall() or user_pass(), the latter of which has the
14 15 16 17 18 19 20 21 22 23 24
 * following in its doxygen documentation:
 *
 * \@ingroup forms
 * \@see user_pass_validate().
 * \@see user_pass_submit().
 *
 * @} End of "defgroup forms".
 */

/**
 * @defgroup form_api Form generation
25
 * @{
26
 * Functions to enable the processing and display of HTML forms.
27
 *
28 29 30 31
 * Drupal uses these functions to achieve consistency in its form processing and
 * presentation, while simplifying code and reducing the amount of HTML that
 * must be explicitly generated by modules.
 *
32 33 34 35
 * The primary function used with forms is drupal_get_form(), which is
 * used for forms presented interactively to a user. Forms can also be built and
 * submitted programmatically without any user input using the
 * drupal_form_submit() function.
36
 *
37 38 39 40 41
 * drupal_get_form() handles retrieving, processing, and displaying a rendered
 * HTML form for modules automatically.
 *
 * Here is an example of how to use drupal_get_form() and a form builder
 * function:
42
 * @code
43 44 45 46 47 48 49
 * $form = drupal_get_form('my_module_example_form');
 * ...
 * function my_module_example_form($form, &$form_state) {
 *   $form['submit'] = array(
 *     '#type' => 'submit',
 *     '#value' => t('Submit'),
 *   );
50
 *   return $form;
51 52 53 54 55 56 57
 * }
 * function my_module_example_form_validate($form, &$form_state) {
 *   // Validation logic.
 * }
 * function my_module_example_form_submit($form, &$form_state) {
 *   // Submission logic.
 * }
58
 * @endcode
59
 *
60 61 62 63 64 65 66 67 68 69
 * Or with any number of additional arguments:
 * @code
 * $extra = "extra";
 * $form = drupal_get_form('my_module_example_form', $extra);
 * ...
 * function my_module_example_form($form, &$form_state, $extra) {
 *   $form['submit'] = array(
 *     '#type' => 'submit',
 *     '#value' => $extra,
 *   );
70
 *   return $form;
71 72
 * }
 * @endcode
73
 *
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
 * The $form argument to form-related functions is a structured array containing
 * the elements and properties of the form. For information on the array
 * components and format, and more detailed explanations of the Form API
 * workflow, see the
 * @link http://api.drupal.org/api/drupal/developer--topics--forms_api_reference.html Form API reference @endlink
 * and the
 * @link http://drupal.org/node/37775 Form API section of the handbook. @endlink
 * In addition, there is a set of Form API tutorials in
 * @link form_example_tutorial.inc the Form Example Tutorial @endlink which
 * provide basics all the way up through multistep forms.
 *
 * In the form builder, validation, submission, and other form functions,
 * $form_state is the primary influence on the processing of the form and is
 * passed by reference to most functions, so they use it to communicate with
 * the form system and each other.
 *
 * The $form_state keys are:
 * - 'values': An associative array of values submitted to the form. The
 *   validation functions and submit functions use this array for nearly all
 *   their decision making. (Note that
 *   @link http://api.drupal.org/api/drupal/developer--topics--forms_api_reference.html/7#tree #tree @endlink
 *   determines whether the values are a flat array or an array whose structure
 *   parallels the $form array.)
 * - 'rebuild': If the submit function sets $form_state['rebuild'] to TRUE,
 *   submission is not completed and instead the form is rebuilt using any
 *   information that the submit function has made available to the form builder
 *   function via $form_state. This is commonly used for wizard-style
 *   multi-step forms, add-more buttons, and the like. For further information
 *   see drupal_build_form().
 * - 'redirect': a URL that will be used to redirect the form on submission.
 *   See drupal_redirect_form() for complete information.
 * - 'storage': $form_state['storage'] is not a special key, and no specific
 *   support is provided for it in the Form API, but by tradition it was
 *   the location where application-specific data was stored for communication
 *   between the submit, validation, and form builder functions, especially
109 110 111 112 113 114 115 116 117 118 119 120 121 122
 *   in a multi-step-style form. Form implementations may use any key(s) within
 *   $form_state (other than the keys listed here and other reserved ones used
 *   by Form API internals) for this kind of storage. The recommended way to
 *   ensure that the chosen key doesn't conflict with ones used by the Form API
 *   or other modules is to use the module name as the key name or a prefix for
 *   the key name. For example, the Node module uses $form_state['node'] in node
 *   editing forms to store information about the node being edited, and this
 *   information stays available across successive clicks of the "Preview"
 *   button as well as when the "Save" button is finally clicked.
 * - 'temporary': Since values for all non-reserved keys in $form_state persist
 *   throughout a multistep form sequence, the Form API provides the 'temporary'
 *   key for modules to use for communicating information across form-related
 *   functions during a single page request only. There is no use-case for this
 *   functionality in core.
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
 * - 'triggering_element': (read-only) The form element that triggered
 *   submission. This is the same as the deprecated
 *   $form_state['clicked_button']. It is the element that caused submission,
 *   which may or may not be a button (in the case of AJAX forms.) This is
 *   often used to distinguish between various buttons in a submit handler,
 *   and is also used in AJAX handlers.
 * - 'cache': The typical form workflow involves two page requests. During the
 *   first page request, a form is built and returned for the user to fill in.
 *   Then the user fills the form in and submits it, triggering a second page
 *   request in which the form must be built and processed. By default, $form
 *   and $form_state are built from scratch during each of these page requests.
 *   In some special use-cases, it is necessary or desired to persist the $form
 *   and $form_state variables from the initial page request to the one that
 *   processes the submission. A form builder function can set 'cache' to TRUE
 *   to do this. One example where this is needed is to handle AJAX submissions,
 *   so ajax_process_form() sets this for all forms that include an element with
 *   a #ajax property. (In AJAX, the handler has no way to build the form
 *   itself, so must rely on the cached version created on each page load, so
 *   it's a classic example of this use case.) Note that the persistence of
 *   $form and $form_state across successive submissions of a multi-step form
 *   happens automatically regardless of the value for 'cache'.
 * - 'input': The array of values as they were submitted by the user. These are
 *   raw and unvalidated, so should not be used without a thorough understanding
 *   of security implications. In almost all cases, code should use the data in
 *   the 'values' array exclusively. The most common use of this key is for
 *   multi-step forms that need to clear some of the user input when setting
 *   'rebuild'.
150 151 152
 */

/**
153
 * Wrapper for drupal_build_form() for use when $form_state is not needed.
154 155
 *
 * @param $form_id
156 157 158 159 160 161
 *   The unique string identifying the desired form. If a function with that
 *   name exists, it is called to build the form array. Modules that need to
 *   generate the same form (or very similar forms) using different $form_ids
 *   can implement hook_forms(), which maps different $form_id values to the
 *   proper form constructor function. Examples may be found in node_forms(),
 *   search_forms(), and user_forms().
162
 * @param ...
163
 *   Any additional arguments are passed on to the functions called by
164 165 166
 *   drupal_get_form(), including the unique form constructor function. For
 *   example, the node_edit form requires that a node object is passed in here
 *   when it is called.
167
 *
168
 * @return
169
 *   The form array.
170 171
 *
 * @see drupal_build_form()
172 173
 */
function drupal_get_form($form_id) {
174
  $form_state = array();
175 176

  $args = func_get_args();
177 178
  // Remove $form_id from the arguments.
  array_shift($args);
179
  $form_state['build_info']['args'] = $args;
180 181 182 183 184

  return drupal_build_form($form_id, $form_state);
}

/**
185
 * Build and process a form based on a form id.
186 187 188
 *
 * The form may also be retrieved from the cache if the form was built in a
 * previous page-load. The form is then passed on for processing, validation
189
 * and submission if there is proper input.
190 191 192 193 194 195 196 197 198 199
 *
 * @param $form_id
 *   The unique string identifying the desired form. If a function with that
 *   name exists, it is called to build the form array. Modules that need to
 *   generate the same form (or very similar forms) using different $form_ids
 *   can implement hook_forms(), which maps different $form_id values to the
 *   proper form constructor function. Examples may be found in node_forms(),
 *   search_forms(), and user_forms().
 * @param &$form_state
 *   An array which stores information about the form. This is passed as a
200
 *   reference so that the caller can use it to examine what in the form changed
201 202 203
 *   when the form submission process is complete. Furthermore, it may be used
 *   to store information related to the processed data in the form, which will
 *   persist across page requests when the 'cache' or 'rebuild' flag is set.
204 205
 *   The following parameters may be set in $form_state to affect how the form
 *   is rendered:
206 207 208 209 210 211 212
 *   - build_info: A keyed array of build information that is necessary to
 *     rebuild the form from cache when the original context may no longer be
 *     available:
 *     - args: An array of arguments to pass to the form builder.
 *     - file: An optional include file that contains the form and is
 *       automatically loaded by form_get_cache(). Defaults to the current menu
 *       router item's 'file' definition, if existent.
213 214 215 216 217 218 219 220 221 222 223
 *   - rebuild: Normally, after the entire form processing is completed and
 *     submit handlers ran, a form is considered to be done and
 *     drupal_redirect_form() will redirect the user to a new page using a GET
 *     request (so a browser refresh does not re-submit the form). However, if
 *     'rebuild' has been set to TRUE, then a new copy of the form is
 *     immediately built and sent to the browser; instead of a redirect. This is
 *     used for multi-step forms, such as wizards and confirmation forms. Also,
 *     if a form validation handler has set 'rebuild' to TRUE and a validation
 *     error occurred, then the form is rebuilt prior to being returned,
 *     enabling form elements to be altered, as appropriate to the particular
 *     validation error.
224 225 226 227 228 229 230 231
 *   - input: An array of input that corresponds to $_POST or $_GET, depending
 *     on the 'method' chosen (see below).
 *   - method: The HTTP form method to use for finding the input for this form.
 *     May be 'post' or 'get'. Defaults to 'post'. Note that 'get' method
 *     forms do not use form ids so are always considered to be submitted, which
 *     can have unexpected effects. The 'get' method should only be used on
 *     forms that do not change data, as that is exclusively the domain of post.
 *   - no_redirect: If set to TRUE the form will NOT perform a drupal_goto(),
232 233 234 235 236
 *     even if 'redirect' is set.
 *   - cache: If set to TRUE the original, unprocessed form structure will be
 *     cached, which allows to rebuild the entire form from cache.
 *   - no_cache: If set to TRUE the form will NOT be cached, even if 'cache' is
 *     set.
237 238 239 240 241 242 243 244 245
 *   - always_process: If TRUE and the method is GET, a form_id is not
 *     necessary. This should only be used on RESTful GET forms that do NOT
 *     write data, as this could lead to security issues. It is useful so that
 *     searches do not need to have a form_id in their query arguments to
 *     trigger the search.
 *   - must_validate: Ordinarily, a form is only validated once but there are
 *     times when a form is resubmitted internally and should be validated
 *     again. Setting this to TRUE will force that to happen. This is most
 *     likely to occur during AHAH or AJAX operations.
246 247 248 249
 *   - temporary: An array holding temporary data accessible during the current
 *     page request only. It may be used to temporary save any data that doesn't
 *     need to or shouldn't be cached during the whole form workflow, e.g. data
 *     that needs to be accessed during the current form build process only.
250 251 252 253
 *   - wrapper_callback: Modules that wish to pre-populate certain forms with
 *     common elements, such as back/next/save buttons in multi-step form
 *     wizards, may define a form builder function name that returns a form
 *     structure, which is passed on to the actual form builder function.
254 255 256 257
 *     Such implementations may either define the 'wrapper_callback' via
 *     hook_forms() or have to invoke drupal_build_form() (instead of
 *     drupal_get_form()) on their own in a custom menu callback to prepare
 *     $form_state accordingly.
258 259 260
 *   Further $form_state properties controlling the redirection behavior after
 *   form submission may be found in drupal_redirect_form().
 *
261 262
 * @return
 *   The rendered form or NULL, depending upon the $form_state flags that were set.
263 264
 *
 * @see drupal_redirect_form()
265 266 267 268 269 270 271 272 273
 */
function drupal_build_form($form_id, &$form_state) {
  // Ensure some defaults; if already set they will not be overridden.
  $form_state += form_state_defaults();

  if (!isset($form_state['input'])) {
    $form_state['input'] = $form_state['method'] == 'get' ? $_GET : $_POST;
  }

274 275 276 277 278 279
  if (isset($_SESSION['batch_form_state'])) {
    // We've been redirected here after a batch processing : the form has
    // already been processed, so we grab the post-process $form_state value
    // and move on to form display. See _batch_finished() function.
    $form_state = $_SESSION['batch_form_state'];
    unset($_SESSION['batch_form_state']);
280 281
  }
  else {
282
    // If the incoming input contains a form_build_id, we'll check the
283 284 285 286
    // cache for a copy of the form in question. If it's there, we don't
    // have to rebuild the form to proceed. In addition, if there is stored
    // form_state data from a previous step, we'll retrieve it so it can
    // be passed on to the form processing code.
287
    if (isset($form_state['input']['form_id']) && $form_state['input']['form_id'] == $form_id && !empty($form_state['input']['form_build_id'])) {
288 289
      $form_build_id = $form_state['input']['form_build_id'];
      $form = form_get_cache($form_build_id, $form_state);
290 291
    }

292 293 294 295
    // If the previous bit of code didn't result in a populated $form
    // object, we're hitting the form for the first time and we need
    // to build it from scratch.
    if (!isset($form)) {
296 297
      // Record the filepath of the include file containing the original form,
      // so the form builder callbacks can be loaded when the form is being
298
      // rebuilt from cache on a different path (such as 'system/ajax'). See
299
      // form_get_cache().
300
      // $menu_get_item() is not available at installation time.
301
      if (!isset($form_state['build_info']['file']) && !defined('MAINTENANCE_MODE')) {
302
        $item = menu_get_item();
303 304
        if (!empty($item['include_file'])) {
          $form_state['build_info']['file'] = $item['include_file'];
305 306 307
        }
      }

308
      $form = drupal_retrieve_form($form_id, $form_state);
309
      $form_build_id = 'form-' . drupal_hash_base64(uniqid(mt_rand(), TRUE) . mt_rand());
310 311
      $form['#build_id'] = $form_build_id;

312 313 314 315 316
      // Fix the form method, if it is 'get' in $form_state, but not in $form.
      if ($form_state['method'] == 'get' && !isset($form['#method'])) {
        $form['#method'] = 'get';
      }

317
      drupal_prepare_form($form_id, $form, $form_state);
318 319
      // Store a copy of the unprocessed form to cache in case
      // $form_state['cache'] is set.
320
      $original_form = $form;
321
    }
322

323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
    // Now that we know we have a form, we'll process it (validating,
    // submitting, and handling the results returned by its submission
    // handlers. Submit handlers accumulate data in the form_state by
    // altering the $form_state variable, which is passed into them by
    // reference.
    drupal_process_form($form_id, $form, $form_state);
  }

  // Most simple, single-step forms will be finished by this point --
  // drupal_process_form() usually redirects to another page (or to
  // a 'fresh' copy of the form) once processing is complete. If one
  // of the form's handlers has set $form_state['redirect'] to FALSE,
  // the form will simply be re-rendered with the values still in its
  // fields.
  //
338
  // If $form_state['rebuild'] has been set and input has been processed, we
339 340 341
  // know that we're in a multi-part process of some sort and the form's
  // workflow is not complete. We need to construct a fresh copy of the form,
  // passing in the latest $form_state in addition to any other variables passed
342
  // into drupal_get_form().
343
  if ($form_state['rebuild'] && $form_state['process_input'] && !form_get_errors()) {
344
    $form = drupal_rebuild_form($form_id, $form_state);
345
  }
346 347 348 349 350 351 352 353 354 355 356 357 358 359
  // After processing the form, the form builder or a #process callback may
  // have set $form_state['cache'] to indicate that the original form and the
  // $form_state shall be cached. But the form may only be cached if the
  // special 'no_cache' property is not set to TRUE and we are not rebuilding.
  elseif (isset($form_build_id) && $form_state['cache'] && empty($form_state['no_cache'])) {
    // Cache the original, unprocessed form upon initial build of the form.
    if (isset($original_form)) {
      form_set_cache($form_build_id, $original_form, $form_state);
    }
    // After processing a cached form, only update the cached form state.
    else {
      form_set_cache($form_build_id, NULL, $form_state);
    }
  }
360

361 362
  // Don't override #theme if someone already set it.
  if (!isset($form['#theme'])) {
363
    drupal_theme_initialize();
364 365 366 367 368
    $registry = theme_get_registry();
    if (isset($registry[$form_id])) {
      $form['#theme'] = $form_id;
    }
  }
369

370
  return $form;
371
}
372

373 374 375 376 377
/**
 * Retrieve default values for the $form_state array.
 */
function form_state_defaults() {
  return array(
378 379
    'rebuild' => FALSE,
    'redirect' => NULL,
380 381
    'build_info' => array('args' => array()),
    'temporary' => array(),
382 383
    'submitted' => FALSE,
    'programmed' => FALSE,
384 385
    'cache'=> FALSE,
    'method' => 'post',
386
    'groups' => array(),
387
    'buttons' => array(),
388 389 390
  );
}

391
/**
392
 * Retrieves a form, caches it and processes it again.
393
 *
394 395
 * If your AJAX callback simulates the pressing of a button, then your AJAX
 * callback will need to do the same as what drupal_get_form() would do when the
396
 * button is pressed: get the form from the cache, run drupal_process_form over
397
 * it and then if it needs rebuild, run drupal_rebuild_form() over it. Then send
398
 * back a part of the returned form.
399 400 401
 * $form_state['triggering_element']['#array_parents'] will help you to find
 * which part.
 * @see ajax_form_callback() for an example.
402 403 404 405 406 407 408 409 410
 *
 * @param $form_id
 *   The unique string identifying the desired form. If a function
 *   with that name exists, it is called to build the form array.
 *   Modules that need to generate the same form (or very similar forms)
 *   using different $form_ids can implement hook_forms(), which maps
 *   different $form_id values to the proper form constructor function. Examples
 *   may be found in node_forms(), search_forms(), and user_forms().
 * @param $form_state
411
 *   A keyed array containing the current state of the form.
412 413 414 415 416 417
 * @param $old_form
 *   (optional) A previously built $form. Used to retain the #build_id and
 *   #action properties in AJAX callbacks and similar partial form rebuilds.
 *   Should not be passed for regular rebuilds, for which the entire $form
 *   should be rebuilt freshly.
 *
418 419 420
 * @return
 *   The newly built form.
 */
421
function drupal_rebuild_form($form_id, &$form_state, $old_form = NULL) {
422 423 424 425 426 427 428
  // AJAX and other contexts may call drupal_rebuild_form() even when
  // $form_state['rebuild'] isn't set, but _form_builder_handle_input_element()
  // needs to distinguish a rebuild from an initial build in order to process
  // user input correctly. Form constructors and form processing functions may
  // also need to handle a rebuild differently than an initial build.
  $form_state['rebuild'] = TRUE;

429
  $form = drupal_retrieve_form($form_id, $form_state);
430

431 432 433 434 435 436
  // If only parts of the form will be returned to the browser (e.g. AJAX or
  // RIA clients), re-use the old #build_id to not require client-side code to
  // manually update the hidden 'build_id' input element.
  // Otherwise, a new #build_id is generated, to not clobber the previous
  // build's data in the form cache; also allowing the user to go back to an
  // earlier build, make changes, and re-submit.
437
  $form['#build_id'] = isset($old_form['#build_id']) ? $old_form['#build_id'] : 'form-' . drupal_hash_base64(uniqid(mt_rand(), TRUE) . mt_rand());
438 439 440 441 442 443

  // #action defaults to request_uri(), but in case of AJAX and other partial
  // rebuilds, the form is submitted to an alternate URL, and the original
  // #action needs to be retained.
  if (isset($old_form['#action'])) {
    $form['#action'] = $old_form['#action'];
444
  }
445

446 447
  drupal_prepare_form($form_id, $form, $form_state);

448
  if (empty($form_state['no_cache'])) {
449 450
    // We cache the form structure and the form state so it can be retrieved
    // later for validation.
451
    form_set_cache($form['#build_id'], $form, $form_state);
452
  }
453

454 455
  // Clear out all group associations as these might be different when
  // re-rendering the form.
456 457
  $form_state['groups'] = array();

458 459 460
  // Do not call drupal_process_form(), since it would prevent the rebuilt form
  // to submit.
  $form = form_builder($form_id, $form, $form_state);
461 462 463
  return $form;
}

464 465 466 467
/**
 * Fetch a form from cache.
 */
function form_get_cache($form_build_id, &$form_state) {
468
  if ($cached = cache_get('form_' . $form_build_id, 'cache_form')) {
469
    $form = $cached->data;
470

471 472
    global $user;
    if ((isset($form['#cache_token']) && drupal_valid_token($form['#cache_token'])) || (!isset($form['#cache_token']) && !$user->uid)) {
473 474
      if ($cached = cache_get('form_state_' . $form_build_id, 'cache_form')) {
        // Re-populate $form_state for subsequent rebuilds.
475
        $form_state = $cached->data + $form_state;
476 477

        // If the original form is contained in an include file, load the file.
478
        // See drupal_build_form().
479 480 481
        if (!empty($form_state['build_info']['file']) && file_exists($form_state['build_info']['file'])) {
          require_once DRUPAL_ROOT . '/' . $form_state['build_info']['file'];
        }
482 483
      }
      return $form;
484 485 486 487 488
    }
  }
}

/**
489
 * Store a form in the cache.
490 491
 */
function form_set_cache($form_build_id, $form, $form_state) {
492 493
  // 6 hours cache life time for forms should be plenty.
  $expire = 21600;
494 495 496 497 498 499 500

  // Cache form structure.
  if (isset($form)) {
    if ($GLOBALS['user']->uid) {
      $form['#cache_token'] = drupal_get_token();
    }
    cache_set('form_' . $form_build_id, $form, 'cache_form', REQUEST_TIME + $expire);
501
  }
502 503

  // Cache form state.
504
  if ($data = array_diff_key($form_state, array_flip(form_state_keys_no_cache()))) {
505
    cache_set('form_state_' . $form_build_id, $data, 'cache_form', REQUEST_TIME + $expire);
506 507 508
  }
}

509 510 511 512 513 514 515 516 517 518 519 520 521 522
/**
 * Returns an array of $form_state keys that shouldn't be cached.
 */
function form_state_keys_no_cache() {
  return array(
    // Public properties defined by form constructors and form handlers.
    'always_process',
    'must_validate',
    'rebuild',
    'redirect',
    'no_redirect',
    'temporary',
    // Internal properties defined by form processing.
    'buttons',
523
    'triggering_element',
524 525 526 527 528 529 530 531 532 533 534 535
    'clicked_button',
    'complete form',
    'groups',
    'input',
    'method',
    'submit_handlers',
    'submitted',
    'validate_handlers',
    'values',
  );
}

536
/**
537 538 539 540 541 542 543 544
 * Retrieves, populates, and processes a form.
 *
 * This function allows you to supply values for form elements and submit a
 * form for processing. Compare to drupal_get_form(), which also builds and
 * processes a form, but does not allow you to supply values.
 *
 * There is no return value, but you can check to see if there are errors
 * by calling form_get_errors().
545 546 547 548 549 550
 *
 * @param $form_id
 *   The unique string identifying the desired form. If a function
 *   with that name exists, it is called to build the form array.
 *   Modules that need to generate the same form (or very similar forms)
 *   using different $form_ids can implement hook_forms(), which maps
551
 *   different $form_id values to the proper form constructor function. Examples
552
 *   may be found in node_forms(), search_forms(), and user_forms().
553
 * @param $form_state
554 555 556 557 558 559 560
 *   A keyed array containing the current state of the form. Most important is
 *   the $form_state['values'] collection, a tree of data used to simulate the
 *   incoming $_POST information from a user's form submission. If a key is not
 *   filled in $form_state['values'], then the default value of the respective
 *   element is used. To submit an unchecked checkbox or other control that
 *   browsers submit by not having a $_POST entry, include the key, but set the
 *   value to NULL.
561
 * @param ...
562
 *   Any additional arguments are passed on to the functions called by
563
 *   drupal_form_submit(), including the unique form constructor function.
564
 *   For example, the node_edit form requires that a node object be passed
565 566 567 568 569 570 571 572 573 574 575 576 577 578
 *   in here when it is called. Arguments that need to be passed by reference
 *   should not be included here, but rather placed directly in the $form_state
 *   build info array so that the reference can be preserved. For example, a
 *   form builder function with the following signature:
 *   @code
 *   function mymodule_form($form, &$form_state, &$object) {
 *   }
 *   @endcode
 *   would be called via drupal_form_submit() as follows:
 *   @code
 *   $form_state['values'] = $my_form_values;
 *   $form_state['build_info']['args'] = array(&$object);
 *   drupal_form_submit('mymodule_form', $form_state);
 *   @endcode
579
 * For example:
580
 * @code
581
 * // register a new user
582 583 584
 * $form_state = array();
 * $form_state['values']['name'] = 'robo-user';
 * $form_state['values']['mail'] = 'robouser@example.com';
585 586
 * $form_state['values']['pass']['pass1'] = 'password';
 * $form_state['values']['pass']['pass2'] = 'password';
587
 * $form_state['values']['op'] = t('Create new account');
588
 * drupal_form_submit('user_register_form', $form_state);
589
 * @endcode
590
 */
591
function drupal_form_submit($form_id, &$form_state) {
592
  if (!isset($form_state['build_info']['args'])) {
593 594 595
    $args = func_get_args();
    array_shift($args);
    array_shift($args);
596
    $form_state['build_info']['args'] = $args;
597
  }
598 599
  // Merge in default values.
  $form_state += form_state_defaults();
Dries's avatar
Dries committed
600

601 602 603
  $form = drupal_retrieve_form($form_id, $form_state);
  $form_state['input'] = $form_state['values'];
  $form_state['programmed'] = TRUE;
604 605
  // Programmed forms are always submitted.
  $form_state['submitted'] = TRUE;
606

607 608 609 610
  // Reset form validation.
  $form_state['must_validate'] = TRUE;
  form_clear_error();

611 612
  drupal_prepare_form($form_id, $form, $form_state);
  drupal_process_form($form_id, $form, $form_state);
613 614
}

615 616 617 618 619 620 621 622
/**
 * Retrieves the structured array that defines a given form.
 *
 * @param $form_id
 *   The unique string identifying the desired form. If a function
 *   with that name exists, it is called to build the form array.
 *   Modules that need to generate the same form (or very similar forms)
 *   using different $form_ids can implement hook_forms(), which maps
623
 *   different $form_id values to the proper form constructor function.
624
 * @param $form_state
625 626 627
 *   A keyed array containing the current state of the form, including the
 *   additional arguments to drupal_get_form() or drupal_form_submit() in the
 *   'args' component of the array.
628
 */
629
function drupal_retrieve_form($form_id, &$form_state) {
630
  $forms = &drupal_static(__FUNCTION__);
631

632
  // We save two copies of the incoming arguments: one for modules to use
633
  // when mapping form ids to constructor functions, and another to pass to
634
  // the constructor function itself.
635
  $args = $form_state['build_info']['args'];
636 637 638

  // We first check to see if there's a function named after the $form_id.
  // If there is, we simply pass the arguments on to it to get the form.
639
  if (!function_exists($form_id)) {
640
    // In cases where many form_ids need to share a central constructor function,
641
    // such as the node editing form, modules can implement hook_forms(). It
642
    // maps one or more form_ids to the correct constructor functions.
643 644 645 646 647 648 649 650 651
    //
    // We cache the results of that hook to save time, but that only works
    // for modules that know all their form_ids in advance. (A module that
    // adds a small 'rate this comment' form to each comment in a list
    // would need a unique form_id for each one, for example.)
    //
    // So, we call the hook if $forms isn't yet populated, OR if it doesn't
    // yet have an entry for the requested form_id.
    if (!isset($forms) || !isset($forms[$form_id])) {
652
      $forms = module_invoke_all('forms', $form_id, $args);
653 654 655 656 657 658 659 660
    }
    $form_definition = $forms[$form_id];
    if (isset($form_definition['callback arguments'])) {
      $args = array_merge($form_definition['callback arguments'], $args);
    }
    if (isset($form_definition['callback'])) {
      $callback = $form_definition['callback'];
    }
661 662 663 664 665
    // In case $form_state['wrapper_callback'] is not defined already, we also
    // allow hook_forms() to define one.
    if (!isset($form_state['wrapper_callback']) && isset($form_definition['wrapper_callback'])) {
      $form_state['wrapper_callback'] = $form_definition['wrapper_callback'];
    }
666
  }
667

668 669 670 671 672 673
  $form = array();
  // We need to pass $form_state by reference in order for forms to modify it,
  // since call_user_func_array() requires that referenced variables are passed
  // explicitly.
  $args = array_merge(array($form, &$form_state), $args);

674 675 676 677 678
  // When the passed $form_state (not using drupal_get_form()) defines a
  // 'wrapper_callback', then it requests to invoke a separate (wrapping) form
  // builder function to pre-populate the $form array with form elements, which
  // the actual form builder function ($callback) expects. This allows for
  // pre-populating a form with common elements for certain forms, such as
679
  // back/next/save buttons in multi-step form wizards. See drupal_build_form().
680
  if (isset($form_state['wrapper_callback']) && function_exists($form_state['wrapper_callback'])) {
681 682 683
    $form = call_user_func_array($form_state['wrapper_callback'], $args);
    // Put the prepopulated $form into $args.
    $args[0] = $form;
684
  }
685

686 687
  // If $callback was returned by a hook_forms() implementation, call it.
  // Otherwise, call the function named after the form id.
688
  $form = call_user_func_array(isset($callback) ? $callback : $form_id, $args);
689
  $form['#form_id'] = $form_id;
690

691
  return $form;
692 693 694
}

/**
695 696
 * Processes a form submission.
 *
697 698 699 700 701
 * This function is the heart of form API. The form gets built, validated and in
 * appropriate cases, submitted.
 *
 * @param $form_id
 *   The unique string identifying the current form.
702 703
 * @param $form
 *   An associative array containing the structure of the form.
704 705
 * @param $form_state
 *   A keyed array containing the current state of the form. This
Dries's avatar
Dries committed
706
 *   includes the current persistent storage data for the form, and
707 708 709
 *   any data passed along by earlier steps when displaying a
 *   multi-step form. Additional information, like the sanitized $_POST
 *   data, is also accumulated here.
710
 */
711 712 713
function drupal_process_form($form_id, &$form, &$form_state) {
  $form_state['values'] = array();

714 715 716 717 718 719 720 721 722 723 724 725 726
  // With $_GET, these forms are always submitted if requested.
  if ($form_state['method'] == 'get' && !empty($form_state['always_process'])) {
    if (!isset($form_state['input']['form_build_id'])) {
      $form_state['input']['form_build_id'] = $form['#build_id'];
    }
    if (!isset($form_state['input']['form_id'])) {
      $form_state['input']['form_id'] = $form_id;
    }
    if (!isset($form_state['input']['form_token']) && isset($form['#token'])) {
      $form_state['input']['form_token'] = drupal_get_token($form['#token']);
    }
  }

727
  // Build the form.
728
  $form = form_builder($form_id, $form, $form_state);
729 730 731

  // Only process the input if we have a correct form submission.
  if ($form_state['process_input']) {
732 733
    drupal_validate_form($form_id, $form, $form_state);

734
    // drupal_html_id() maintains a cache of element IDs it has seen,
735
    // so it can prevent duplicates. We want to be sure we reset that
736
    // cache when a form is processed, so scenarios that result in
737 738
    // the form being built behind the scenes and again for the
    // browser don't increment all the element IDs needlessly.
739
    drupal_static_reset('drupal_html_id');
740

741 742
    if ($form_state['submitted'] && !form_get_errors() && !$form_state['rebuild']) {
      // Execute form submit handlers.
743 744 745 746 747
      form_execute_handlers('submit', $form, $form_state);

      // We'll clear out the cached copies of the form and its stored data
      // here, as we've finished with them. The in-memory copies are still
      // here, though.
748
      if (!variable_get('cache', 0) && !empty($form_state['values']['form_build_id'])) {
749
        cache_clear_all('form_' . $form_state['values']['form_build_id'], 'cache_form');
750
        cache_clear_all('form_state_' . $form_state['values']['form_build_id'], 'cache_form');
751 752 753
      }

      // If batches were set in the submit handlers, we process them now,
754 755
      // possibly ending execution. We make sure we do not react to the batch
      // that is already being processed (if a batch operation performs a
756
      // drupal_form_submit).
757
      if ($batch =& batch_get() && !isset($batch['current_set'])) {
758 759 760 761 762 763 764
        // Store $form_state information in the batch definition.
        // We need the full $form_state when either:
        // - Some submit handlers were saved to be called during batch
        //   processing. See form_execute_handlers().
        // - The form is multistep.
        // In other cases, we only need the information expected by
        // drupal_redirect_form().
765
        if ($batch['has_form_submits'] || !empty($form_state['rebuild'])) {
766 767 768 769 770 771
          $batch['form_state'] = $form_state;
        }
        else {
          $batch['form_state'] = array_intersect_key($form_state, array_flip(array('programmed', 'rebuild', 'storage', 'no_redirect', 'redirect')));
        }

772
        $batch['progressive'] = !$form_state['programmed'];
773
        batch_process();
774

775 776 777 778
        // Execution continues only for programmatic forms.
        // For 'regular' forms, we get redirected to the batch processing
        // page. Form redirection will be handled in _batch_finished(),
        // after the batch is processed.
779
      }
780

781 782 783
      // Set a flag to indicate the the form has been processed and executed.
      $form_state['executed'] = TRUE;

784 785
      // Redirect the form based on values in $form_state.
      drupal_redirect_form($form_state);
786 787 788 789 790 791 792 793 794 795 796 797 798 799
    }
  }
}

/**
 * Prepares a structured form array by adding required elements,
 * executing any hook_form_alter functions, and optionally inserting
 * a validation token to prevent tampering.
 *
 * @param $form_id
 *   A unique string identifying the form for validation, submission,
 *   theming, and hook_form_alter functions.
 * @param $form
 *   An associative array containing the structure of the form.
800 801 802
 * @param $form_state
 *   A keyed array containing the current state of the form. Passed
 *   in here so that hook_form_alter() calls can use it, as well.
803
 */
804
function drupal_prepare_form($form_id, &$form, &$form_state) {
805 806
  global $user;

807
  $form['#type'] = 'form';
808
  $form_state['programmed'] = isset($form_state['programmed']) ? $form_state['programmed'] : FALSE;
809

810 811 812 813 814 815 816 817 818
  if (isset($form['#build_id'])) {
    $form['form_build_id'] = array(
      '#type' => 'hidden',
      '#value' => $form['#build_id'],
      '#id' => $form['#build_id'],
      '#name' => 'form_build_id',
    );
  }

819 820 821 822
  // Add a token, based on either #token or form_id, to any form displayed to
  // authenticated users. This ensures that any submitted form was actually
  // requested previously by the user and protects against cross site request
  // forgeries.
823 824 825 826 827 828 829 830
  // This does not apply to programmatically submitted forms. Furthermore, since
  // tokens are session-bound and forms displayed to anonymous users are very
  // likely cached, we cannot assign a token for them.
  // During installation, there is no $user yet.
  if (!empty($user->uid) && !$form_state['programmed']) {
    // Form constructors may explicitly set #token to FALSE when cross site
    // request forgery is irrelevant to the form, such as search forms.
    if (isset($form['#token']) && $form['#token'] === FALSE) {
831
      unset($form['#token']);
832
    }
833
    // Otherwise, generate a public token based on the form id.
834
    else {
835 836 837 838 839 840
      $form['#token'] = $form_id;
      $form['form_token'] = array(
        '#id' => drupal_html_id('edit-' . $form_id . '-form-token'),
        '#type' => 'token',
        '#default_value' => drupal_get_token($form['#token']),
      );
841
    }
842
  }
843

844
  if (isset($form_id)) {
845 846 847
    $form['form_id'] = array(
      '#type' => 'hidden',
      '#value' => $form_id,
848
      '#id' => drupal_html_id("edit-$form_id"),
849
    );
850
  }
851
  if (!isset($form['#id'])) {
852
    $form['#id'] = drupal_html_id($form_id);
853
  }
Steven Wittens's avatar
Steven Wittens committed
854

855
  $form += element_info('form');
856
  $form += array('#tree' => FALSE, '#parents' => array());
857

Dries's avatar
Dries committed
858
  if (!isset($form['#validate'])) {
859
    if (function_exists($form_id . '_validate')) {
860
      $form['#validate'] = array($form_id . '_validate');
Dries's avatar
Dries committed
861 862 863
    }
  }

864
  if (!isset($form['#submit'])) {
865
    if (function_exists($form_id . '_submit')) {
866
      // We set submit here so that it can be altered.
867
      $form['#submit'] = array($form_id . '_submit');
Dries's avatar
Dries committed
868 869 870
    }
  }

871 872
  // Invoke hook_form_alter() and hook_form_FORM_ID_alter() implementations.
  drupal_alter(array('form', 'form_' . $form_id), $form, $form_state, $form_id);
873 874
}

875 876

/**
877
 * Validates user-submitted form data from the $form_state using
878 879 880 881 882 883
 * the validate functions defined in a structured form array.
 *
 * @param $form_id
 *   A unique string identifying the form for validation, submission,
 *   theming, and hook_form_alter functions.
 * @param $form
884 885 886 887 888 889 890
 *   An associative array containing the structure of the form, which is passed
 *   by reference. Form validation handlers are able to alter the form structure
 *   (like #process and #after_build callbacks during form building) in case of
 *   a validation error. If a validation handler alters the form structure, it
 *   is responsible for validating the values of changed form elements in
 *   $form_state['values'] to prevent form submit handlers from receiving
 *   unvalidated values.
891 892 893 894 895 896
 * @param $form_state
 *   A keyed array containing the current state of the form. The current
 *   user-submitted data is stored in $form_state['values'], though
 *   form validation functions are passed an explicit copy of the
 *   values for the sake of simplicity. Validation handlers can also
 *   $form_state to pass information on to submit handlers. For example:
897
 *     $form_state['data_for_submission'] = $data;
898 899 900
 *   This technique is useful when validation requires file parsing,
 *   web service requests, or other expensive requests that should
 *   not be repeated in the submission step.
901
 */
902
function drupal_validate_form($form_id, &$form, &$form_state) {
903
  $validated_forms = &drupal_static(__FUNCTION__, array());
904

905
  if (isset($validated_forms[$form_id]) && empty($form_state['must_validate'])) {
906 907
    return;
  }
908

909
  // If the session token was set by drupal_prepare_form(), ensure that it
910
  // matches the current user's session.
911
  if (isset($form['#token'])) {
912
    if (!drupal_valid_token($form_state['values']['form_token'], $form['#token'])) {
913
      // Setting this error will cause the form to fail validation.
914
      form_set_error('form_token', t('Validation error, please try again. If this error persists, please contact the site administrator.'));
915 916 917
    }
  }

918
  _form_validate($form, $form_state, $form_id);
919
  $validated_forms[$form_id] = TRUE;
920 921
}

922
/**
923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948
 * Redirects the user to a URL after a form has been processed.
 *
 * After a form was executed, the data in $form_state controls whether the form
 * is redirected. By default, we redirect to a new destination page. The path of
 * the destination page can be set in $form_state['redirect']. If that is not
 * set, the user is redirected to the current page to display a fresh,
 * unpopulated copy of the form.
 *
 * There are several triggers that may prevent a redirection though:
 * - If $form_state['redirect'] is FALSE, a form builder function or form
 *   validation/submit handler does not want a user to be redirected, which
 *   means that drupal_goto() is not invoked. For most forms, the redirection
 *   logic will be the same regardless of whether $form_state['redirect'] is
 *   undefined or FALSE. However, in case it was not defined and the current
 *   request contains a 'destination' query string, drupal_goto() will redirect
 *   to that given destination instead. Only setting $form_state['redirect'] to
 *   FALSE will prevent any redirection.
 * - If $form_state['no_redirect'] is TRUE, then the callback that originally
 *   built the form explicitly disallows any redirection, regardless of the
 *   redirection value in $form_state['redirect']. For example, ajax_get_form()
 *   defines $form_state['no_redirect'] when building a form in an AJAX
 *   callback to prevent any redirection. $form_state['no_redirect'] should NOT
 *   be altered by form builder functions or form validation/submit handlers.
 * - If $form_state['programmed'] is TRUE, the form submission was usually
 *   invoked via drupal_form_submit(), so any redirection would break the script
 *   that invoked drupal_form_submit().
949
 * - If $form_state['rebuild'] is TRUE, the form needs to be rebuilt without
950
 *   redirection.
951
 *
952 953 954 955 956
 * @param $form_state
 *   A keyed array containing the current state of the form.
 *
 * @see drupal_process_form()
 * @see drupal_build_form()
957
 */
958 959 960 961
function drupal_redirect_form($form_state) {
  // Skip redirection for form submissions invoked via drupal_form_submit().
  if (!empty($form_state['programmed'])) {
    return;
962
  }
963 964
  // Skip redirection if rebuild is activated.
  if (!empty($form_state['rebuild'])) {
965 966 967 968 969
    return;
  }
  // Skip redirection if it was explicitly disallowed.
  if (!empty($form_state['no_redirect'])) {
    return;
970
  }
971 972 973 974 975
  // Only invoke drupal_goto() if redirect value was not set to FALSE.
  if (!isset($form_state['redirect']) || $form_state['redirect'] !== FALSE) {
    if (isset($form_state['redirect'])) {
      if (is_array($form_state['redirect'])) {
        call_user_func_array('drupal_goto', $form_state['redirect']);
976 977
      }
      else {
978 979 980 981
        // This function can be called from the installer, which guarantees
        // that $redirect will always be a string, so catch that case here
        // and use the appropriate redirect function.
        $function = drupal_installation_attempted() ? 'install_goto' : 'drupal_goto';
982
        $function($form_state['redirect']);
983 984 985 986
      }
    }
    drupal_goto($_GET['q']);
  }
987 988
}

989 990 991 992 993 994 995
/**
 * Performs validation on form elements. First ensures required fields are
 * completed, #maxlength is not exceeded, and selected options were in the
 * list of options given to the user. Then calls user-defined validators.
 *
 * @param $elements
 *   An associative array containing the structure of the form.
996 997 998 999 1000 1001
 * @param $form_state
 *   A keyed array containing the current state of the form. The current
 *   user-submitted data is stored in $form_state['values'], though
 *   form validation functions are passed an explicit copy of the
 *   values for the sake of simplicity. Validation handlers can also
 *   $form_state to pass information on to submit handlers. For example:
1002
 *     $form_state['data_for_submission'] = $data;
1003 1004 1005
 *   This technique is useful when validation requires file parsing,
 *   web service requests, or other expensive requests that should
 *   not be repeated in the submission step.
1006 1007 1008 1009
 * @param $form_id
 *   A unique string identifying the form for validation, submission,
 *   theming, and hook_form_alter functions.
 */
1010
function _form_validate(&$elements, &$form_state, $form_id = NULL) {
1011 1012
  // Also used in the installer, pre-database setup.
  $t = get_t();
1013

1014 1015 1016
  // Recurse through all children.
  foreach (element_children($elements) as $key) {
    if (isset($elements[$key]) && $elements[$key]) {
1017
      _form_validate($elements[$key], $form_state);
1018 1019
    }
  }
1020

1021
  // Validate the current input.
drumm's avatar
drumm committed
1022
  if (!isset($elements['#validated']) || !$elements['#validated']) {
1023
    // The following errors are always shown.
1024
    if (isset($elements['#needs_validation'])) {
1025 1026
      // Verify that the value is not longer than #maxlength.
      if (isset($elements['#maxlength']) && drupal_strlen($elements['#value']) > $elements['#maxlength']) {
1027
        form_error($elements, $t('!name cannot be longer than %max characters but is currently %length characters long.', array('!name' => empty($elements['#title']) ? $elements['#parents'][0] : $elements['#title'], '%max' => $elements['#maxlength'], '%length' => drupal_strlen($elements['#value']))));
1028 1029
      }

1030
      if (isset($elements['#options']) && isset($elements['#value'])) {
1031 1032 1033 1034 1035 1036 1037
        if ($elements['#type'] == 'select') {
          $options = form_options_flatten($elements['#options']);
        }
        else {
          $options = $elements['#options'];
        }
        if (is_array($elements['#value'])) {
1038
          $value = $elements['#type'] == 'checkboxes' ? array_keys($elements['#value']) : $elements['#value'];
1039 1040
          foreach ($value as $v) {
            if (!isset($options[$v])) {
1041
              form_error($elements, $t('An illegal choice has been detected. Please contact the site administrator.'));
1042
              watchdog('form', 'Illegal choice %choice in !name element.', array('%choice' => $v, '!name' => empty($elements['#title']) ? $elements['#parents'][0] : $elements['#title']), WATCHDOG_ERROR);
1043
            }
1044 1045
          }
        }
1046
        elseif (!isset($options[$elements['#value']])) {
1047
          form_error($elements, $t('An illegal choice has been detected. Please contact the site administrator.'));
1048
          watchdog('form', 'Illegal choice %choice in %name element.', array('%choice' => $elements['#value'], '%name' => empty($elements['#title']) ? $elements['#parents'][0] : $elements['#title']), WATCHDOG_ERROR);
1049
        }
1050 1051 1052
      }
    }

1053 1054 1055 1056