Skip navigation
Help

ajax.inc

  1. drupal
    1. 7 drupal/includes/ajax.inc

Functions for use with Drupal's Ajax framework.

Functions & methods

NameDescription
ajax_base_page_themeTheme callback for Ajax requests.
ajax_command_afterCreates a Drupal Ajax 'insert/after' command.
ajax_command_alertCreates a Drupal Ajax 'alert' command.
ajax_command_appendCreates a Drupal Ajax 'insert/append' command.
ajax_command_beforeCreates a Drupal Ajax 'insert/before' command.
ajax_command_changedCreates a Drupal Ajax 'changed' command.
ajax_command_cssCreates a Drupal Ajax 'css' command.
ajax_command_dataCreates a Drupal Ajax 'data' command.
ajax_command_htmlCreates a Drupal Ajax 'insert/html' command.
ajax_command_insertCreates a Drupal Ajax 'insert' command using the method in #ajax['method'].
ajax_command_invokeCreates a Drupal Ajax 'invoke' command.
ajax_command_prependCreates a Drupal Ajax 'insert/prepend' command.
ajax_command_removeCreates a Drupal Ajax 'remove' command.
ajax_command_replaceCreates a Drupal Ajax 'insert/replaceWith' command.
ajax_command_restripeCreates a Drupal Ajax 'restripe' command.
ajax_command_settingsCreates a Drupal Ajax 'settings' command.
ajax_deliverPackage and send the result of a page callback to the browser as an Ajax response.
ajax_footerPerform end-of-Ajax-request tasks.
ajax_form_callbackMenu callback; handles Ajax requests for the #ajax Form API property.
ajax_get_formGet a form submitted via #ajax during an Ajax callback.
ajax_prepare_responseConverts the return value of a page callback into an Ajax commands array.
ajax_pre_render_elementAdd Ajax information about an element to the page to communicate with JavaScript.
ajax_process_formForm element process callback to handle #ajax.
ajax_renderRender a commands array into JSON.

File

drupal/includes/ajax.inc
View source
  1. <?php
  2. /**
  3. * @file
  4. * Functions for use with Drupal's Ajax framework.
  5. */
  6. /**
  7. * @defgroup ajax Ajax framework
  8. * @{
  9. * Functions for Drupal's Ajax framework.
  10. *
  11. * Drupal's Ajax framework is used to dynamically update parts of a page's HTML
  12. * based on data from the server. Upon a specified event, such as a button
  13. * click, a callback function is triggered which performs server-side logic and
  14. * may return updated markup, which is then replaced on-the-fly with no page
  15. * refresh necessary.
  16. *
  17. * This framework creates a PHP macro language that allows the server to
  18. * instruct JavaScript to perform actions on the client browser. When using
  19. * forms, it can be used with the #ajax property.
  20. * The #ajax property can be used to bind events to the Ajax framework. By
  21. * default, #ajax uses 'system/ajax' as its path for submission and thus calls
  22. * ajax_form_callback() and a defined #ajax['callback'] function.
  23. * However, you may optionally specify a different path to request or a
  24. * different callback function to invoke, which can return updated HTML or can
  25. * also return a richer set of @link ajax_commands Ajax framework commands @endlink.
  26. *
  27. * Standard form handling is as follows:
  28. * - A form element has a #ajax property that includes #ajax['callback'] and
  29. * omits #ajax['path']. See below about using #ajax['path'] to implement
  30. * advanced use-cases that require something other than standard form
  31. * handling.
  32. * - On the specified element, Ajax processing is triggered by a change to
  33. * that element.
  34. * - The browser submits an HTTP POST request to the 'system/ajax' Drupal
  35. * path.
  36. * - The menu page callback for 'system/ajax', ajax_form_callback(), calls
  37. * drupal_process_form() to process the form submission and rebuild the
  38. * form if necessary. The form is processed in much the same way as if it
  39. * were submitted without Ajax, with the same #process functions and
  40. * validation and submission handlers called in either case, making it easy
  41. * to create Ajax-enabled forms that degrade gracefully when JavaScript is
  42. * disabled.
  43. * - After form processing is complete, ajax_form_callback() calls the
  44. * function named by #ajax['callback'], which returns the form element that
  45. * has been updated and needs to be returned to the browser, or
  46. * alternatively, an array of custom Ajax commands.
  47. * - The page delivery callback for 'system/ajax', ajax_deliver(), renders the
  48. * element returned by #ajax['callback'], and returns the JSON string
  49. * created by ajax_render() to the browser.
  50. * - The browser unserializes the returned JSON string into an array of
  51. * command objects and executes each command, resulting in the old page
  52. * content within and including the HTML element specified by
  53. * #ajax['wrapper'] being replaced by the new content returned by
  54. * #ajax['callback'], using a JavaScript animation effect specified by
  55. * #ajax['effect'].
  56. *
  57. * A simple example of basic Ajax use from the
  58. * @link http://drupal.org/project/examples Examples module @endlink follows:
  59. * @code
  60. * function main_page() {
  61. * return drupal_get_form('ajax_example_simplest');
  62. * }
  63. *
  64. * function ajax_example_simplest($form, &$form_state) {
  65. * $form = array();
  66. * $form['changethis'] = array(
  67. * '#type' => 'select',
  68. * '#options' => array(
  69. * 'one' => 'one',
  70. * 'two' => 'two',
  71. * 'three' => 'three',
  72. * ),
  73. * '#ajax' => array(
  74. * 'callback' => 'ajax_example_simplest_callback',
  75. * 'wrapper' => 'replace_textfield_div',
  76. * ),
  77. * );
  78. * // This entire form element will be replaced with an updated value.
  79. * $form['replace_textfield'] = array(
  80. * '#type' => 'textfield',
  81. * '#title' => t("The default value will be changed"),
  82. * '#description' => t("Say something about why you chose") . "'" .
  83. * (!empty($form_state['values']['changethis'])
  84. * ? $form_state['values']['changethis'] : t("Not changed yet")) . "'",
  85. * '#prefix' => '<div id="replace_textfield_div">',
  86. * '#suffix' => '</div>',
  87. * );
  88. * return $form;
  89. * }
  90. *
  91. * function ajax_example_simplest_callback($form, $form_state) {
  92. * // The form has already been submitted and updated. We can return the replaced
  93. * // item as it is.
  94. * return $form['replace_textfield'];
  95. * }
  96. * @endcode
  97. *
  98. * In the above example, the 'changethis' element is Ajax-enabled. The default
  99. * #ajax['event'] is 'change', so when the 'changethis' element changes,
  100. * an Ajax call is made. The form is submitted and reprocessed, and then the
  101. * callback is called. In this case, the form has been automatically
  102. * built changing $form['replace_textfield']['#description'], so the callback
  103. * just returns that part of the form.
  104. *
  105. * To implement Ajax handling in a form, add '#ajax' to the form
  106. * definition of a field. That field will trigger an Ajax event when it is
  107. * clicked (or changed, depending on the kind of field). #ajax supports
  108. * the following parameters (either 'path' or 'callback' is required at least):
  109. * - #ajax['callback']: The callback to invoke to handle the server side of the
  110. * Ajax event, which will receive a $form and $form_state as arguments, and
  111. * returns a renderable array (most often a form or form fragment), an HTML
  112. * string, or an array of Ajax commands. If returning a renderable array or
  113. * a string, the value will replace the original element named in
  114. * #ajax['wrapper'], and
  115. * theme_status_messages()
  116. * will be prepended to that
  117. * element. (If the status messages are not wanted, return an array
  118. * of Ajax commands instead.)
  119. * #ajax['wrapper']. If an array of Ajax commands is returned, it will be
  120. * executed by the calling code.
  121. * - #ajax['path']: The menu path to use for the request. This is often omitted
  122. * and the default is used. This path should map
  123. * to a menu page callback that returns data using ajax_render(). Defaults to
  124. * 'system/ajax', which invokes ajax_form_callback(), eventually calling
  125. * the function named in #ajax['callback']. If you use a custom
  126. * path, you must set up the menu entry and handle the entire callback in your
  127. * own code.
  128. * - #ajax['wrapper']: The CSS ID of the area to be replaced by the content
  129. * returned by the #ajax['callback'] function. The content returned from
  130. * the callback will replace the entire element named by #ajax['wrapper'].
  131. * The wrapper is usually created using #prefix and #suffix properties in the
  132. * form. Note that this is the wrapper ID, not a CSS selector. So to replace
  133. * the element referred to by the CSS selector #some-selector on the page,
  134. * use #ajax['wrapper'] = 'some-selector', not '#some-selector'.
  135. * - #ajax['effect']: The jQuery effect to use when placing the new HTML.
  136. * Defaults to no effect. Valid options are 'none', 'slide', or 'fade'.
  137. * - #ajax['speed']: The effect speed to use. Defaults to 'slow'. May be
  138. * 'slow', 'fast' or a number in milliseconds which represents the length
  139. * of time the effect should run.
  140. * - #ajax['event']: The JavaScript event to respond to. This is normally
  141. * selected automatically for the type of form widget being used, and
  142. * is only needed if you need to override the default behavior.
  143. * - #ajax['prevent']: A JavaScript event to prevent when 'event' is triggered.
  144. * Defaults to 'click' for #ajax on #type 'submit', 'button', and
  145. * 'image_button'. Multiple events may be specified separated by spaces.
  146. * For example, when binding #ajax behaviors to form buttons, pressing the
  147. * ENTER key within a textfield triggers the 'click' event of the form's first
  148. * submit button. Triggering Ajax in this situation leads to problems, like
  149. * breaking autocomplete textfields. Because of that, Ajax behaviors are bound
  150. * to the 'mousedown' event on form buttons by default. However, binding to
  151. * 'mousedown' rather than 'click' means that it is possible to trigger a
  152. * click by pressing the mouse, holding the mouse button down until the Ajax
  153. * request is complete and the button is re-enabled, and then releasing the
  154. * mouse button. For this case, 'prevent' can be set to 'click', so an
  155. * additional event handler is bound to prevent such a click from triggering a
  156. * non-Ajax form submission. This also prevents a textfield's ENTER press
  157. * triggering a button's non-Ajax form submission behavior.
  158. * - #ajax['method']: The jQuery method to use to place the new HTML.
  159. * Defaults to 'replaceWith'. May be: 'replaceWith', 'append', 'prepend',
  160. * 'before', 'after', or 'html'. See the
  161. * @link http://api.jquery.com/category/manipulation/ jQuery manipulators documentation @endlink
  162. * for more information on these methods.
  163. * - #ajax['progress']: Choose either a throbber or progress bar that is
  164. * displayed while awaiting a response from the callback, and add an optional
  165. * message. Possible keys: 'type', 'message', 'url', 'interval'.
  166. * More information is available in the
  167. * @link http://api.drupal.org/api/drupal/developer--topics--forms_api_reference.html/7 Form API Reference @endlink
  168. *
  169. * In addition to using Form API for doing in-form modification, Ajax may be
  170. * enabled by adding classes to buttons and links. By adding the 'use-ajax'
  171. * class to a link, the link will be loaded via an Ajax call. When using this
  172. * method, the href of the link can contain '/nojs/' as part of the path. When
  173. * the Ajax framework makes the request, it will convert this to '/ajax/'.
  174. * The server is then able to easily tell if this request was made through an
  175. * actual Ajax request or in a degraded state, and respond appropriately.
  176. *
  177. * Similarly, submit buttons can be given the class 'use-ajax-submit'. The
  178. * form will then be submitted via Ajax to the path specified in the #action.
  179. * Like the ajax-submit class above, this path will have '/nojs/' replaced with
  180. * '/ajax/' so that the submit handler can tell if the form was submitted
  181. * in a degraded state or not.
  182. *
  183. * When responding to Ajax requests, the server should do what it needs to do
  184. * for that request, then create a commands array. This commands array will
  185. * be converted to a JSON object and returned to the client, which will then
  186. * iterate over the array and process it like a macro language.
  187. *
  188. * Each command item is an associative array which will be converted to a command
  189. * object on the JavaScript side. $command_item['command'] is the type of
  190. * command, e.g. 'alert' or 'replace', and will correspond to a method in the
  191. * Drupal.ajax[command] space. The command array may contain any other data
  192. * that the command needs to process, e.g. 'method', 'selector', 'settings', etc.
  193. *
  194. * Commands are usually created with a couple of helper functions, so they
  195. * look like this:
  196. * @code
  197. * $commands = array();
  198. * // Replace the content of '#object-1' on the page with 'some html here'.
  199. * $commands[] = ajax_command_replace('#object-1', 'some html here');
  200. * // Add a visual "changed" marker to the '#object-1' element.
  201. * $commands[] = ajax_command_changed('#object-1');
  202. * // Menu 'page callback' and #ajax['callback'] functions are supposed to
  203. * // return render arrays. If returning an Ajax commands array, it must be
  204. * // encapsulated in a render array structure.
  205. * return array('#type' => 'ajax', '#commands' => $commands);
  206. * @endcode
  207. *
  208. * When returning an Ajax command array, it is often useful to have
  209. * status messages rendered along with other tasks in the command array.
  210. * In that case the the Ajax commands array may be constructed like this:
  211. * @code
  212. * $commands = array();
  213. * $commands[] = ajax_command_replace(NULL, $output);
  214. * $commands[] = ajax_command_prepend(NULL, theme('status_messages'));
  215. * return array('#type' => 'ajax', '#commands' => $commands);
  216. * @endcode
  217. *
  218. * See @link ajax_commands Ajax framework commands @endlink
  219. */
  220. /**
  221. * Render a commands array into JSON.
  222. *
  223. * @param $commands
  224. * A list of macro commands generated by the use of ajax_command_*()
  225. * functions.
  226. */
  227. function ajax_render($commands = array()) {
  228. // Ajax responses aren't rendered with html.tpl.php, so we have to call
  229. // drupal_get_css() and drupal_get_js() here, in order to have new files added
  230. // during this request to be loaded by the page. We only want to send back
  231. // files that the page hasn't already loaded, so we implement simple diffing
  232. // logic using array_diff_key().
  233. foreach (array('css', 'js') as $type) {
  234. // It is highly suspicious if $_POST['ajax_page_state'][$type] is empty,
  235. // since the base page ought to have at least one JS file and one CSS file
  236. // loaded. It probably indicates an error, and rather than making the page
  237. // reload all of the files, instead we return no new files.
  238. if (empty($_POST['ajax_page_state'][$type])) {
  239. $items[$type] = array();
  240. }
  241. else {
  242. $function = 'drupal_add_' . $type;
  243. $items[$type] = $function();
  244. drupal_alter($type, $items[$type]);
  245. // @todo Inline CSS and JS items are indexed numerically. These can't be
  246. // reliably diffed with array_diff_key(), since the number can change
  247. // due to factors unrelated to the inline content, so for now, we strip
  248. // the inline items from Ajax responses, and can add support for them
  249. // when drupal_add_css() and drupal_add_js() are changed to using md5()
  250. // or some other hash of the inline content.
  251. foreach ($items[$type] as $key => $item) {
  252. if (is_numeric($key)) {
  253. unset($items[$type][$key]);
  254. }
  255. }
  256. // Ensure that the page doesn't reload what it already has.
  257. $items[$type] = array_diff_key($items[$type], $_POST['ajax_page_state'][$type]);
  258. }
  259. }
  260. // Settings are handled separately, later in this function, so that changes to
  261. // the ajaxPageState setting that occur during drupal_get_css() and
  262. // drupal_get_js() get included, and because the jQuery.extend() code produced
  263. // by drupal_get_js() for adding settings isn't appropriate during an Ajax
  264. // response, because it does not pass TRUE for the "deep" parameter, and
  265. // therefore, can clobber existing settings on the page.
  266. if (isset($items['js']['settings'])) {
  267. unset($items['js']['settings']);
  268. }
  269. // Render the HTML to load these files, and add Ajax commands to insert this
  270. // HTML in the page. We pass TRUE as the $skip_alter argument to prevent the
  271. // data from being altered again, as we already altered it above.
  272. $styles = drupal_get_css($items['css'], TRUE);
  273. $scripts_footer = drupal_get_js('footer', $items['js'], TRUE);
  274. $scripts_header = drupal_get_js('header', $items['js'], TRUE);
  275. $extra_commands = array();
  276. if (!empty($styles)) {
  277. $extra_commands[] = ajax_command_prepend('head', $styles);
  278. }
  279. if (!empty($scripts_header)) {
  280. $extra_commands[] = ajax_command_prepend('head', $scripts_header);
  281. }
  282. if (!empty($scripts_footer)) {
  283. $extra_commands[] = ajax_command_append('body', $scripts_footer);
  284. }
  285. if (!empty($extra_commands)) {
  286. $commands = array_merge($extra_commands, $commands);
  287. }
  288. $scripts = drupal_add_js();
  289. if (!empty($scripts['settings'])) {
  290. $settings = $scripts['settings'];
  291. // Automatically extract any settings added via drupal_add_js() and make
  292. // them the first command.
  293. array_unshift($commands, ajax_command_settings(call_user_func_array('array_merge_recursive', $settings['data']), TRUE));
  294. }
  295. // Allow modules to alter any Ajax response.
  296. drupal_alter('ajax_render', $commands);
  297. return drupal_json_encode($commands);
  298. }
  299. /**
  300. * Get a form submitted via #ajax during an Ajax callback.
  301. *
  302. * This will load a form from the form cache used during Ajax operations. It
  303. * pulls the form info from $_POST.
  304. *
  305. * @return
  306. * An array containing the $form and $form_state. Use the list() function
  307. * to break these apart:
  308. * @code
  309. * list($form, $form_state, $form_id, $form_build_id) = ajax_get_form();
  310. * @endcode
  311. */
  312. function ajax_get_form() {
  313. $form_state = form_state_defaults();
  314. $form_build_id = $_POST['form_build_id'];
  315. // Get the form from the cache.
  316. $form = form_get_cache($form_build_id, $form_state);
  317. if (!$form) {
  318. // If $form cannot be loaded from the cache, the form_build_id in $_POST
  319. // must be invalid, which means that someone performed a POST request onto
  320. // system/ajax without actually viewing the concerned form in the browser.
  321. // This is likely a hacking attempt as it never happens under normal
  322. // circumstances, so we just do nothing.
  323. watchdog('ajax', 'Invalid form POST data.', array(), WATCHDOG_WARNING);
  324. drupal_exit();
  325. }
  326. // Since some of the submit handlers are run, redirects need to be disabled.
  327. $form_state['no_redirect'] = TRUE;
  328. // When a form is rebuilt after Ajax processing, its #build_id and #action
  329. // should not change.
  330. // @see drupal_rebuild_form()
  331. $form_state['rebuild_info']['copy']['#build_id'] = TRUE;
  332. $form_state['rebuild_info']['copy']['#action'] = TRUE;
  333. // The form needs to be processed; prepare for that by setting a few internal
  334. // variables.
  335. $form_state['input'] = $_POST;
  336. $form_id = $form['#form_id'];
  337. return array($form, $form_state, $form_id, $form_build_id);
  338. }
  339. /**
  340. * Menu callback; handles Ajax requests for the #ajax Form API property.
  341. *
  342. * This rebuilds the form from cache and invokes the defined #ajax['callback']
  343. * to return an Ajax command structure for JavaScript. In case no 'callback' has
  344. * been defined, nothing will happen.
  345. *
  346. * The Form API #ajax property can be set both for buttons and other input
  347. * elements.
  348. *
  349. * This function is also the canonical example of how to implement
  350. * #ajax['path']. If processing is required that cannot be accomplished with
  351. * a callback, re-implement this function and set #ajax['path'] to the
  352. * enhanced function.
  353. */
  354. function ajax_form_callback() {
  355. list($form, $form_state) = ajax_get_form();
  356. drupal_process_form($form['#form_id'], $form, $form_state);
  357. // We need to return the part of the form (or some other content) that needs
  358. // to be re-rendered so the browser can update the page with changed content.
  359. // Since this is the generic menu callback used by many Ajax elements, it is
  360. // up to the #ajax['callback'] function of the element (may or may not be a
  361. // button) that triggered the Ajax request to determine what needs to be
  362. // rendered.
  363. if (!empty($form_state['triggering_element'])) {
  364. $callback = $form_state['triggering_element']['#ajax']['callback'];
  365. }
  366. if (!empty($callback) && function_exists($callback)) {
  367. return $callback($form, $form_state);
  368. }
  369. }
  370. /**
  371. * Theme callback for Ajax requests.
  372. *
  373. * Many different pages can invoke an Ajax request to system/ajax or another
  374. * generic Ajax path. It is almost always desired for an Ajax response to be
  375. * rendered using the same theme as the base page, because most themes are built
  376. * with the assumption that they control the entire page, so if the CSS for two
  377. * themes are both loaded for a given page, they may conflict with each other.
  378. * For example, Bartik is Drupal's default theme, and Seven is Drupal's default
  379. * administration theme. Depending on whether the "Use the administration theme
  380. * when editing or creating content" checkbox is checked, the node edit form may
  381. * be displayed in either theme, but the Ajax response to the Field module's
  382. * "Add another item" button should be rendered using the same theme as the rest
  383. * of the page. Therefore, system_menu() sets the 'theme callback' for
  384. * 'system/ajax' to this function, and it is recommended that modules
  385. * implementing other generic Ajax paths do the same.
  386. */
  387. function ajax_base_page_theme() {
  388. if (!empty($_POST['ajax_page_state']['theme']) && !empty($_POST['ajax_page_state']['theme_token'])) {
  389. $theme = $_POST['ajax_page_state']['theme'];
  390. $token = $_POST['ajax_page_state']['theme_token'];
  391. // Prevent a request forgery from giving a person access to a theme they
  392. // shouldn't be otherwise allowed to see. However, since everyone is allowed
  393. // to see the default theme, token validation isn't required for that, and
  394. // bypassing it allows most use-cases to work even when accessed from the
  395. // page cache.
  396. if ($theme === variable_get('theme_default', 'bartik') || drupal_valid_token($token, $theme)) {
  397. return $theme;
  398. }
  399. }
  400. }
  401. /**
  402. * Package and send the result of a page callback to the browser as an Ajax response.
  403. *
  404. * This function is the equivalent of drupal_deliver_html_page(), but for Ajax
  405. * requests. Like that function, it:
  406. * - Adds needed HTTP headers.
  407. * - Prints rendered output.
  408. * - Performs end-of-request tasks.
  409. *
  410. * @param $page_callback_result
  411. * The result of a page callback. Can be one of:
  412. * - NULL: to indicate no content.
  413. * - An integer menu status constant: to indicate an error condition.
  414. * - A string of HTML content.
  415. * - A renderable array of content.
  416. *
  417. * @see drupal_deliver_html_page()
  418. */
  419. function ajax_deliver($page_callback_result) {
  420. // Browsers do not allow JavaScript to read the contents of a user's local
  421. // files. To work around that, the jQuery Form plugin submits forms containing
  422. // a file input element to an IFRAME, instead of using XHR. Browsers do not
  423. // normally expect JSON strings as content within an IFRAME, so the response
  424. // must be customized accordingly.
  425. // @see http://malsup.com/jquery/form/#file-upload
  426. // @see Drupal.ajax.prototype.beforeSend()
  427. $iframe_upload = !empty($_POST['ajax_iframe_upload']);
  428. // Emit a Content-Type HTTP header if none has been added by the page callback
  429. // or by a wrapping delivery callback.
  430. if (is_null(drupal_get_http_header('Content-Type'))) {
  431. if (!$iframe_upload) {
  432. // Standard JSON can be returned to a browser's XHR object, and to
  433. // non-browser user agents.
  434. // @see http://www.ietf.org/rfc/rfc4627.txt?number=4627
  435. drupal_add_http_header('Content-Type', 'application/json; charset=utf-8');
  436. }
  437. else {
  438. // Browser IFRAMEs expect HTML. With most other content types, Internet
  439. // Explorer presents the user with a download prompt.
  440. drupal_add_http_header('Content-Type', 'text/html; charset=utf-8');
  441. }
  442. }
  443. // Print the response.
  444. $commands = ajax_prepare_response($page_callback_result);
  445. $json = ajax_render($commands);
  446. if (!$iframe_upload) {
  447. // Standard JSON can be returned to a browser's XHR object, and to
  448. // non-browser user agents.
  449. print $json;
  450. }
  451. else {
  452. // Browser IFRAMEs expect HTML. Browser extensions, such as Linkification
  453. // and Skype's Browser Highlighter, convert URLs, phone numbers, etc. into
  454. // links. This corrupts the JSON response. Protect the integrity of the
  455. // JSON data by making it the value of a textarea.
  456. // @see http://malsup.com/jquery/form/#file-upload
  457. // @see http://drupal.org/node/1009382
  458. print '<textarea>' . $json . '</textarea>';
  459. }
  460. // Perform end-of-request tasks.
  461. ajax_footer();
  462. }
  463. /**
  464. * Converts the return value of a page callback into an Ajax commands array.
  465. *
  466. * @param $page_callback_result
  467. * The result of a page callback. Can be one of:
  468. * - NULL: to indicate no content.
  469. * - An integer menu status constant: to indicate an error condition.
  470. * - A string of HTML content.
  471. * - A renderable array of content.
  472. *
  473. * @return
  474. * An Ajax commands array that can be passed to ajax_render().
  475. */
  476. function ajax_prepare_response($page_callback_result) {
  477. $commands = array();
  478. if (!isset($page_callback_result)) {
  479. // Simply delivering an empty commands array is sufficient. This results
  480. // in the Ajax request being completed, but nothing being done to the page.
  481. }
  482. elseif (is_int($page_callback_result)) {
  483. switch ($page_callback_result) {
  484. case MENU_NOT_FOUND:
  485. $commands[] = ajax_command_alert(t('The requested page could not be found.'));
  486. break;
  487. case MENU_ACCESS_DENIED:
  488. $commands[] = ajax_command_alert(t('You are not authorized to access this page.'));
  489. break;
  490. case MENU_SITE_OFFLINE:
  491. $commands[] = ajax_command_alert(filter_xss_admin(variable_get('maintenance_mode_message',
  492. t('@site is currently under maintenance. We should be back shortly. Thank you for your patience.', array('@site' => variable_get('site_name', 'Drupal'))))));
  493. break;
  494. }
  495. }
  496. elseif (is_array($page_callback_result) && isset($page_callback_result['#type']) && ($page_callback_result['#type'] == 'ajax')) {
  497. // Complex Ajax callbacks can return a result that contains an error message
  498. // or a specific set of commands to send to the browser.
  499. $page_callback_result += element_info('ajax');
  500. $error = $page_callback_result['#error'];
  501. if (isset($error) && $error !== FALSE) {
  502. if ((empty($error) || $error === TRUE)) {
  503. $error = t('An error occurred while handling the request: The server received invalid input.');
  504. }
  505. $commands[] = ajax_command_alert($error);
  506. }
  507. else {
  508. $commands = $page_callback_result['#commands'];
  509. }
  510. }
  511. else {
  512. // Like normal page callbacks, simple Ajax callbacks can return HTML
  513. // content, as a string or render array. This HTML is inserted in some
  514. // relationship to #ajax['wrapper'], as determined by which jQuery DOM
  515. // manipulation method is used. The method used is specified by
  516. // #ajax['method']. The default method is 'replaceWith', which completely
  517. // replaces the old wrapper element and its content with the new HTML.
  518. $html = is_string($page_callback_result) ? $page_callback_result : drupal_render($page_callback_result);
  519. $commands[] = ajax_command_insert(NULL, $html);
  520. // Add the status messages inside the new content's wrapper element, so that
  521. // on subsequent Ajax requests, it is treated as old content.
  522. $commands[] = ajax_command_prepend(NULL, theme('status_messages'));
  523. }
  524. return $commands;
  525. }
  526. /**
  527. * Perform end-of-Ajax-request tasks.
  528. *
  529. * This function is the equivalent of drupal_page_footer(), but for Ajax
  530. * requests.
  531. *
  532. * @see drupal_page_footer()
  533. */
  534. function ajax_footer() {
  535. // Even for Ajax requests, invoke hook_exit() implementations. There may be
  536. // modules that need very fast Ajax responses, and therefore, run Ajax
  537. // requests with an early bootstrap.
  538. if (drupal_get_bootstrap_phase() == DRUPAL_BOOTSTRAP_FULL && (!defined('MAINTENANCE_MODE') || MAINTENANCE_MODE != 'update')) {
  539. module_invoke_all('exit');
  540. }
  541. // Commit the user session. See above comment about the possibility of this
  542. // function running without session.inc loaded.
  543. if (function_exists('drupal_session_commit')) {
  544. drupal_session_commit();
  545. }
  546. }
  547. /**
  548. * Form element process callback to handle #ajax.
  549. *
  550. * @param $element
  551. * An associative array containing the properties of the element.
  552. *
  553. * @return
  554. * The processed element.
  555. *
  556. * @see ajax_pre_render_element()
  557. */
  558. function ajax_process_form($element, &$form_state) {
  559. $element = ajax_pre_render_element($element);
  560. if (!empty($element['#ajax_processed'])) {
  561. $form_state['cache'] = TRUE;
  562. }
  563. return $element;
  564. }
  565. /**
  566. * Add Ajax information about an element to the page to communicate with JavaScript.
  567. *
  568. * If #ajax['path'] is set on an element, this additional JavaScript is added
  569. * to the page header to attach the Ajax behaviors. See ajax.js for more
  570. * information.
  571. *
  572. * @param $element
  573. * An associative array containing the properties of the element.
  574. * Properties used:
  575. * - #ajax['event']
  576. * - #ajax['prevent']
  577. * - #ajax['path']
  578. * - #ajax['options']
  579. * - #ajax['wrapper']
  580. * - #ajax['parameters']
  581. * - #ajax['effect']
  582. *
  583. * @return
  584. * The processed element with the necessary JavaScript attached to it.
  585. */
  586. function ajax_pre_render_element($element) {
  587. // Skip already processed elements.
  588. if (isset($element['#ajax_processed'])) {
  589. return $element;
  590. }
  591. // Initialize #ajax_processed, so we do not process this element again.
  592. $element['#ajax_processed'] = FALSE;
  593. // Nothing to do if there is neither a callback nor a path.
  594. if (!(isset($element['#ajax']['callback']) || isset($element['#ajax']['path']))) {
  595. return $element;
  596. }
  597. // Add a reasonable default event handler if none was specified.
  598. if (isset($element['#ajax']) && !isset($element['#ajax']['event'])) {
  599. switch ($element['#type']) {
  600. case 'submit':
  601. case 'button':
  602. case 'image_button':
  603. // Pressing the ENTER key within a textfield triggers the click event of
  604. // the form's first submit button. Triggering Ajax in this situation
  605. // leads to problems, like breaking autocomplete textfields, so we bind
  606. // to mousedown instead of click.
  607. // @see http://drupal.org/node/216059
  608. $element['#ajax']['event'] = 'mousedown';
  609. // Retain keyboard accessibility by setting 'keypress'. This causes
  610. // ajax.js to trigger 'event' when SPACE or ENTER are pressed while the
  611. // button has focus.
  612. $element['#ajax']['keypress'] = TRUE;
  613. // Binding to mousedown rather than click means that it is possible to
  614. // trigger a click by pressing the mouse, holding the mouse button down
  615. // until the Ajax request is complete and the button is re-enabled, and
  616. // then releasing the mouse button. Set 'prevent' so that ajax.js binds
  617. // an additional handler to prevent such a click from triggering a
  618. // non-Ajax form submission. This also prevents a textfield's ENTER
  619. // press triggering this button's non-Ajax form submission behavior.
  620. if (!isset($element['#ajax']['prevent'])) {
  621. $element['#ajax']['prevent'] = 'click';
  622. }
  623. break;
  624. case 'password':
  625. case 'textfield':
  626. case 'textarea':
  627. $element['#ajax']['event'] = 'blur';
  628. break;
  629. case 'radio':
  630. case 'checkbox':
  631. case 'select':
  632. $element['#ajax']['event'] = 'change';
  633. break;
  634. case 'link':
  635. $element['#ajax']['event'] = 'click';
  636. break;
  637. default:
  638. return $element;
  639. }
  640. }
  641. // Attach JavaScript settings to the element.
  642. if (isset($element['#ajax']['event'])) {
  643. $element['#attached']['library'][] = array('system', 'jquery.form');
  644. $element['#attached']['library'][] = array('system', 'drupal.ajax');
  645. $settings = $element['#ajax'];
  646. // Assign default settings.
  647. $settings += array(
  648. 'path' => 'system/ajax',
  649. 'options' => array(),
  650. );
  651. // @todo Legacy support. Remove in Drupal 8.
  652. if (isset($settings['method']) && $settings['method'] == 'replace') {
  653. $settings['method'] = 'replaceWith';
  654. }
  655. // Change path to URL.
  656. $settings['url'] = url($settings['path'], $settings['options']);
  657. unset($settings['path'], $settings['options']);
  658. // Add special data to $settings['submit'] so that when this element
  659. // triggers an Ajax submission, Drupal's form processing can determine which
  660. // element triggered it.
  661. // @see _form_element_triggered_scripted_submission()
  662. if (isset($settings['trigger_as'])) {
  663. // An element can add a 'trigger_as' key within #ajax to make the element
  664. // submit as though another one (for example, a non-button can use this
  665. // to submit the form as though a button were clicked). When using this,
  666. // the 'name' key is always required to identify the element to trigger
  667. // as. The 'value' key is optional, and only needed when multiple elements
  668. // share the same name, which is commonly the case for buttons.
  669. $settings['submit']['_triggering_element_name'] = $settings['trigger_as']['name'];
  670. if (isset($settings['trigger_as']['value'])) {
  671. $settings['submit']['_triggering_element_value'] = $settings['trigger_as']['value'];
  672. }
  673. unset($settings['trigger_as']);
  674. }
  675. elseif (isset($element['#name'])) {
  676. // Most of the time, elements can submit as themselves, in which case the
  677. // 'trigger_as' key isn't needed, and the element's name is used.
  678. $settings['submit']['_triggering_element_name'] = $element['#name'];
  679. // If the element is a (non-image) button, its name may not identify it
  680. // uniquely, in which case a match on value is also needed.
  681. // @see _form_button_was_clicked()
  682. if (isset($element['#button_type']) && empty($element['#has_garbage_value'])) {
  683. $settings['submit']['_triggering_element_value'] = $element['#value'];
  684. }
  685. }
  686. // Convert a simple #ajax['progress'] string into an array.
  687. if (isset($settings['progress']) && is_string($settings['progress'])) {
  688. $settings['progress'] = array('type' => $settings['progress']);
  689. }
  690. // Change progress path to a full URL.
  691. if (isset($settings['progress']['path'])) {
  692. $settings['progress']['url'] = url($settings['progress']['path']);
  693. unset($settings['progress']['path']);
  694. }
  695. $element['#attached']['js'][] = array(
  696. 'type' => 'setting',
  697. 'data' => array('ajax' => array($element['#id'] => $settings)),
  698. );
  699. // Indicate that Ajax processing was successful.
  700. $element['#ajax_processed'] = TRUE;
  701. }
  702. return $element;
  703. }
  704. /**
  705. * @} End of "defgroup ajax".
  706. */
  707. /**
  708. * @defgroup ajax_commands Ajax framework commands
  709. * @{
  710. * Functions to create various Ajax commands.
  711. *
  712. * These functions can be used to create arrays for use with the
  713. * ajax_render() function.
  714. */
  715. /**
  716. * Creates a Drupal Ajax 'alert' command.
  717. *
  718. * The 'alert' command instructs the client to display a JavaScript alert
  719. * dialog box.
  720. *
  721. * This command is implemented by Drupal.ajax.prototype.commands.alert()
  722. * defined in misc/ajax.js.
  723. *
  724. * @param $text
  725. * The message string to display to the user.
  726. *
  727. * @return
  728. * An array suitable for use with the ajax_render() function.
  729. */
  730. function ajax_command_alert($text) {
  731. return array(
  732. 'command' => 'alert',
  733. 'text' => $text,
  734. );
  735. }
  736. /**
  737. * Creates a Drupal Ajax 'insert' command using the method in #ajax['method'].
  738. *
  739. * This command instructs the client to insert the given HTML using whichever
  740. * jQuery DOM manipulation method has been specified in the #ajax['method']
  741. * variable of the element that triggered the request.
  742. *
  743. * This command is implemented by Drupal.ajax.prototype.commands.insert()
  744. * defined in misc/ajax.js.
  745. *
  746. * @param $selector
  747. * A jQuery selector string. If the command is a response to a request from
  748. * an #ajax form element then this value can be NULL.
  749. * @param $html
  750. * The data to use with the jQuery method.
  751. * @param $settings
  752. * An optional array of settings that will be used for this command only.
  753. *
  754. * @return
  755. * An array suitable for use with the ajax_render() function.
  756. */
  757. function ajax_command_insert($selector, $html, $settings = NULL) {
  758. return array(
  759. 'command' => 'insert',
  760. 'method' => NULL,
  761. 'selector' => $selector,
  762. 'data' => $html,
  763. 'settings' => $settings,
  764. );
  765. }
  766. /**
  767. * Creates a Drupal Ajax 'insert/replaceWith' command.
  768. *
  769. * The 'insert/replaceWith' command instructs the client to use jQuery's
  770. * replaceWith() method to replace each element matched matched by the given
  771. * selector with the given HTML.
  772. *
  773. * This command is implemented by Drupal.ajax.prototype.commands.insert()
  774. * defined in misc/ajax.js.
  775. *
  776. * @param $selector
  777. * A jQuery selector string. If the command is a response to a request from
  778. * an #ajax form element then this value can be NULL.
  779. * @param $html
  780. * The data to use with the jQuery replaceWith() method.
  781. * @param $settings
  782. * An optional array of settings that will be used for this command only.
  783. *
  784. * @return
  785. * An array suitable for use with the ajax_render() function.
  786. *
  787. * See @link http://docs.jquery.com/Manipulation/replaceWith#content jQuery replaceWith command @endlink
  788. */
  789. function ajax_command_replace($selector, $html, $settings = NULL) {
  790. return array(
  791. 'command' => 'insert',
  792. 'method' => 'replaceWith',
  793. 'selector' => $selector,
  794. 'data' => $html,
  795. 'settings' => $settings,
  796. );
  797. }
  798. /**
  799. * Creates a Drupal Ajax 'insert/html' command.
  800. *
  801. * The 'insert/html' command instructs the client to use jQuery's html()
  802. * method to set the HTML content of each element matched by the given
  803. * selector while leaving the outer tags intact.
  804. *
  805. * This command is implemented by Drupal.ajax.prototype.commands.insert()
  806. * defined in misc/ajax.js.
  807. *
  808. * @param $selector
  809. * A jQuery selector string. If the command is a response to a request from
  810. * an #ajax form element then this value can be NULL.
  811. * @param $html
  812. * The data to use with the jQuery html() method.
  813. * @param $settings
  814. * An optional array of settings that will be used for this command only.
  815. *
  816. * @return
  817. * An array suitable for use with the ajax_render() function.
  818. *
  819. * @see http://docs.jquery.com/Attributes/html#val
  820. */
  821. function ajax_command_html($selector, $html, $settings = NULL) {
  822. return array(
  823. 'command' => 'insert',
  824. 'method' => 'html',
  825. 'selector' => $selector,
  826. 'data' => $html,
  827. 'settings' => $settings,
  828. );
  829. }
  830. /**
  831. * Creates a Drupal Ajax 'insert/prepend' command.
  832. *
  833. * The 'insert/prepend' command instructs the client to use jQuery's prepend()
  834. * method to prepend the given HTML content to the inside each element matched
  835. * by the given selector.
  836. *
  837. * This command is implemented by Drupal.ajax.prototype.commands.insert()
  838. * defined in misc/ajax.js.
  839. *
  840. * @param $selector
  841. * A jQuery selector string. If the command is a response to a request from
  842. * an #ajax form element then this value can be NULL.
  843. * @param $html
  844. * The data to use with the jQuery prepend() method.
  845. * @param $settings
  846. * An optional array of settings that will be used for this command only.
  847. *
  848. * @return
  849. * An array suitable for use with the ajax_render() function.
  850. *
  851. * @see http://docs.jquery.com/Manipulation/prepend#content
  852. */
  853. function ajax_command_prepend($selector, $html, $settings = NULL) {
  854. return array(
  855. 'command' => 'insert',
  856. 'method' => 'prepend',
  857. 'selector' => $selector,
  858. 'data' => $html,
  859. 'settings' => $settings,
  860. );
  861. }
  862. /**
  863. * Creates a Drupal Ajax 'insert/append' command.
  864. *
  865. * The 'insert/append' command instructs the client to use jQuery's append()
  866. * method to append the given HTML content to the inside of each element matched
  867. * by the given selector.
  868. *
  869. * This command is implemented by Drupal.ajax.prototype.commands.insert()
  870. * defined in misc/ajax.js.
  871. *
  872. * @param $selector
  873. * A jQuery selector string. If the command is a response to a request from
  874. * an #ajax form element then this value can be NULL.
  875. * @param $html
  876. * The data to use with the jQuery append() method.
  877. * @param $settings
  878. * An optional array of settings that will be used for this command only.
  879. *
  880. * @return
  881. * An array suitable for use with the ajax_render() function.
  882. *
  883. * @see http://docs.jquery.com/Manipulation/append#content
  884. */
  885. function ajax_command_append($selector, $html, $settings = NULL) {
  886. return array(
  887. 'command' => 'insert',
  888. 'method' => 'append',
  889. 'selector' => $selector,
  890. 'data' => $html,
  891. 'settings' => $settings,
  892. );
  893. }
  894. /**
  895. * Creates a Drupal Ajax 'insert/after' command.
  896. *
  897. * The 'insert/after' command instructs the client to use jQuery's after()
  898. * method to insert the given HTML content after each element matched by
  899. * the given selector.
  900. *
  901. * This command is implemented by Drupal.ajax.prototype.commands.insert()
  902. * defined in misc/ajax.js.
  903. *
  904. * @param $selector
  905. * A jQuery selector string. If the command is a response to a request from
  906. * an #ajax form element then this value can be NULL.
  907. * @param $html
  908. * The data to use with the jQuery after() method.
  909. * @param $settings
  910. * An optional array of settings that will be used for this command only.
  911. *
  912. * @return
  913. * An array suitable for use with the ajax_render() function.
  914. *
  915. * @see http://docs.jquery.com/Manipulation/after#content
  916. */
  917. function ajax_command_after($selector, $html, $settings = NULL) {
  918. return array(
  919. 'command' => 'insert',
  920. 'method' => 'after',
  921. 'selector' => $selector,
  922. 'data' => $html,
  923. 'settings' => $settings,
  924. );
  925. }
  926. /**
  927. * Creates a Drupal Ajax 'insert/before' command.
  928. *
  929. * The 'insert/before' command instructs the client to use jQuery's before()
  930. * method to insert the given HTML content before each of elements matched by
  931. * the given selector.
  932. *
  933. * This command is implemented by Drupal.ajax.prototype.commands.insert()
  934. * defined in misc/ajax.js.
  935. *
  936. * @param $selector
  937. * A jQuery selector string. If the command is a response to a request from
  938. * an #ajax form element then this value can be NULL.
  939. * @param $html
  940. * The data to use with the jQuery before() method.
  941. * @param $settings
  942. * An optional array of settings that will be used for this command only.
  943. *
  944. * @return
  945. * An array suitable for use with the ajax_render() function.
  946. *
  947. * @see http://docs.jquery.com/Manipulation/before#content
  948. */
  949. function ajax_command_before($selector, $html, $settings = NULL) {
  950. return array(
  951. 'command' => 'insert',
  952. 'method' => 'before',
  953. 'selector' => $selector,
  954. 'data' => $html,
  955. 'settings' => $settings,
  956. );
  957. }
  958. /**
  959. * Creates a Drupal Ajax 'remove' command.
  960. *
  961. * The 'remove' command instructs the client to use jQuery's remove() method
  962. * to remove each of elements matched by the given selector, and everything
  963. * within them.
  964. *
  965. * This command is implemented by Drupal.ajax.prototype.commands.remove()
  966. * defined in misc/ajax.js.
  967. *
  968. * @param $selector
  969. * A jQuery selector string. If the command is a response to a request from
  970. * an #ajax form element then this value can be NULL.
  971. *
  972. * @return
  973. * An array suitable for use with the ajax_render() function.
  974. *
  975. * @see http://docs.jquery.com/Manipulation/remove#expr
  976. */
  977. function ajax_command_remove($selector) {
  978. return array(
  979. 'command' => 'remove',
  980. 'selector' => $selector,
  981. );
  982. }
  983. /**
  984. * Creates a Drupal Ajax 'changed' command.
  985. *
  986. * This command instructs the client to mark each of the elements matched by the
  987. * given selector as 'ajax-changed'.
  988. *
  989. * This command is implemented by Drupal.ajax.prototype.commands.changed()
  990. * defined in misc/ajax.js.
  991. *
  992. * @param $selector
  993. * A jQuery selector string. If the command is a response to a request from
  994. * an #ajax form element then this value can be NULL.
  995. * @param $asterisk
  996. * An optional CSS selector which must be inside $selector. If specified,
  997. * an asterisk will be appended to the HTML inside the $asterisk selector.
  998. *
  999. * @return
  1000. * An array suitable for use with the ajax_render() function.
  1001. */
  1002. function ajax_command_changed($selector, $asterisk = '') {
  1003. return array(
  1004. 'command' => 'changed',
  1005. 'selector' => $selector,
  1006. 'asterisk' => $asterisk,
  1007. );
  1008. }
  1009. /**
  1010. * Creates a Drupal Ajax 'css' command.
  1011. *
  1012. * The 'css' command will instruct the client to use the jQuery css() method
  1013. * to apply the CSS arguments to elements matched by the given selector.
  1014. *
  1015. * This command is implemented by Drupal.ajax.prototype.commands.css()
  1016. * defined in misc/ajax.js.
  1017. *
  1018. * @param $selector
  1019. * A jQuery selector string. If the command is a response to a request from
  1020. * an #ajax form element then this value can be NULL.
  1021. * @param $argument
  1022. * An array of key/value pairs to set in the CSS for the selector.
  1023. *
  1024. * @return
  1025. * An array suitable for use with the ajax_render() function.
  1026. *
  1027. * @see http://docs.jquery.com/CSS/css#properties
  1028. */
  1029. function ajax_command_css($selector, $argument) {
  1030. return array(
  1031. 'command' => 'css',
  1032. 'selector' => $selector,
  1033. 'argument' => $argument,
  1034. );
  1035. }
  1036. /**
  1037. * Creates a Drupal Ajax 'settings' command.
  1038. *
  1039. * The 'settings' command instructs the client either to use the given array as
  1040. * the settings for ajax-loaded content or to extend Drupal.settings with the
  1041. * given array, depending on the value of the $merge parameter.
  1042. *
  1043. * This command is implemented by Drupal.ajax.prototype.commands.settings()
  1044. * defined in misc/ajax.js.
  1045. *
  1046. * @param $argument
  1047. * An array of key/value pairs to add to the settings. This will be utilized
  1048. * for all commands after this if they do not include their own settings
  1049. * array.
  1050. * @param $merge
  1051. * Whether or not the passed settings in $argument should be merged into the
  1052. * global Drupal.settings on the page. By default (FALSE), the settings that
  1053. * are passed to Drupal.attachBehaviors will not include the global
  1054. * Drupal.settings.
  1055. *
  1056. * @return
  1057. * An array suitable for use with the ajax_render() function.
  1058. */
  1059. function ajax_command_settings($argument, $merge = FALSE) {
  1060. return array(
  1061. 'command' => 'settings',
  1062. 'settings' => $argument,
  1063. 'merge' => $merge,
  1064. );
  1065. }
  1066. /**
  1067. * Creates a Drupal Ajax 'data' command.
  1068. *
  1069. * The 'data' command instructs the client to attach the name=value pair of
  1070. * data to the selector via jQuery's data cache.
  1071. *
  1072. * This command is implemented by Drupal.ajax.prototype.commands.data()
  1073. * defined in misc/ajax.js.
  1074. *
  1075. * @param $selector
  1076. * A jQuery selector string. If the command is a response to a request from
  1077. * an #ajax form element then this value can be NULL.
  1078. * @param $name
  1079. * The name or key (in the key value pair) of the data attached to this
  1080. * selector.
  1081. * @param $value
  1082. * The value of the data. Not just limited to strings can be any format.
  1083. *
  1084. * @return
  1085. * An array suitable for use with the ajax_render() function.
  1086. *
  1087. * @see http://docs.jquery.com/Core/data#namevalue
  1088. */
  1089. function ajax_command_data($selector, $name, $value) {
  1090. return array(
  1091. 'command' => 'data',
  1092. 'selector' => $selector,
  1093. 'name' => $name,
  1094. 'value' => $value,
  1095. );
  1096. }
  1097. /**
  1098. * Creates a Drupal Ajax 'invoke' command.
  1099. *
  1100. * The 'invoke' command will instruct the client to invoke the given jQuery
  1101. * method with the supplied arguments on the elements matched by the given
  1102. * selector. Intended for simple jQuery commands, such as attr(), addClass(),
  1103. * removeClass(), toggleClass(), etc.
  1104. *
  1105. * This command is implemented by Drupal.ajax.prototype.commands.invoke()
  1106. * defined in misc/ajax.js.
  1107. *
  1108. * @param $selector
  1109. * A jQuery selector string. If the command is a response to a request from
  1110. * an #ajax form element then this value can be NULL.
  1111. * @param $method
  1112. * The jQuery method to invoke.
  1113. * @param $arguments
  1114. * (optional) A list of arguments to the jQuery $method, if any.
  1115. *
  1116. * @return
  1117. * An array suitable for use with the ajax_render() function.
  1118. */
  1119. function ajax_command_invoke($selector, $method, array $arguments = array()) {
  1120. return array(
  1121. 'command' => 'invoke',
  1122. 'selector' => $selector,
  1123. 'method' => $method,
  1124. 'arguments' => $arguments,
  1125. );
  1126. }
  1127. /**
  1128. * Creates a Drupal Ajax 'restripe' command.
  1129. *
  1130. * The 'restripe' command instructs the client to restripe a table. This is
  1131. * usually used after a table has been modified by a replace or append command.
  1132. *
  1133. * This command is implemented by Drupal.ajax.prototype.commands.restripe()
  1134. * defined in misc/ajax.js.
  1135. *
  1136. * @param $selector
  1137. * A jQuery selector string.
  1138. *
  1139. * @return
  1140. * An array suitable for use with the ajax_render() function.
  1141. */
  1142. function ajax_command_restripe($selector) {
  1143. return array(
  1144. 'command' => 'restripe',
  1145. 'selector' => $selector,
  1146. );
  1147. }