modules/spajax/spajax.module

<?php
// $Id: spajax.module,v 1.4 2006/03/19 13:31:59 jjeff Exp $

// spajax.module for Drupal
// Script.aculo.us/Prototype/Ajax Module by Jeff Robbins

/**
 * @abstract
 * This module implements the Prototype and Scriptaculous AJAX libraries
 * for use in Drupal
 * 
 * It adds form element types and themeing functions to display several
 * types of AJAX and DHTML elements on the page.
 * 
 * Prototype functions available:
 * http://wiki.script.aculo.us/scriptaculous/show/Prototype
 * 
 * Other documentation:
 * http://particletree.com/features/quick-guide-to-prototype/
 * http://www.sergiopereira.com/articles/prototype.js.html
 * 
 * (eventually) see help for more info
 * 
 * @todo
 * - add option to output JS in header (cleaner) or footer (more compatible)
 * - move Menu Magic css and js into that module's dir
 * 
 */

/**
 * Thoughts, ideas, todo:
 * 
 * - run sortable form element through theme('form_element') - can't get it to work...
 * - make a "slider" form element
 * - work on u.i. for settings page
 *    - only list active themes
 * - make default position for floating menus
 * - in-place editing of node content
 * 
 * floating menus
 * - make sure that floating menu is within page boundaries
 * - allow resizable width
 * - system for floating local tasks
 * - float other blocks?
 * - privileges for floating blocks?
 * 
 * 
 */


/******************* Drupal hooks ***********************/

/**
 * Implementation of hook_help()
 */
function spajax_help($section){
  switch($section){
    case 'admin/modules#name':
      return 'script.aculo.us/prototype/ajax';
    case 'admin/modules#description':
      return t('Adds ajax and dhtml functions using the script.aculo.us library');
  }
}

function spajax_menu($may_cache){
  $items = array();
  if($may_cache){
    // settings
    $items[] = array('path' => 'admin/settings/spajax', 'access' => user_access('administer site configuration'), 'title' => 's/p ajax', 'callback' => 'spajax_settings_page');
    $items[] = array('path' => 'admin/settings/spajax/settings', 'access' => user_access('administer site configuration'), 'title' => 'general', 'type' => MENU_DEFAULT_LOCAL_TASK);
    
    // ajax callbacks
    // access is TRUE on these so that there will be no Access Denied page returned
    // but these callback functions should be sure to check access if necessary
    $items[] = array('path' => 'spajax/set', 'access' => TRUE, 'title' => 'spajax set', 'callback' => 'spajax_set', 'type' => MENU_CALLBACK);
    
  }
  else{
    // check for messages at the beginning of each page call
    spajax_is_message();
  }
  return $items;
}

/**
 * Implementation of hook_elements
 * Custom form elements using Prototype/Scriptaculous
 *
 * @return unknown
 */
function spajax_elements(){
  // a Prototype version of autocomplete
  $type['spajax_autocomplete'] = array('#input' => TRUE, '#size' => 60, '#maxlength' => 128, '#autocomplete_path' => FALSE);
  
  $type['sortable'] = array(
    '#input' => TRUE,
    '#process' => array('spajax_form_sortable' => array()),
    '#items' => array(),
    '#outer_tag' => 'div',
    '#inner_tag' => 'div',
    '#options' => array(),
  );
  
  return $type;
}

/**
 * Implementation of hook_footer()
 * Add JS to page header after the rest of the page has been rendered
 * 
 * @todo
 *   Check that this works with all theme engines
 */
function spajax_footer(){
  //spajax_all_pages();
  
  // invoke 'spajax' hook in each module
  module_invoke_all('spajax');
  
  $spajax_output = spajax_output();
  if(!empty($spajax_output)) {
    spajax_create_function('spajax_init', $spajax_output);
  }
  
  // there's no "header" equivalent of hook_footer(), so....
  // (this may be getting called too late with some theme engines)
  $head_scripts = spajax_create_function();
  if (!empty($head_scripts)){
    $head = <<<EOT
<script type="text/javascript">
// <![CDATA[
Event.observe(window, 'load', spajax_init);
$head_scripts
// ]]>
</script>
EOT;
    drupal_set_html_head($head);
  }
  
  // and then the footer itself
  /*
  if (!empty($spajax_output)) {
    $output = <<<EOT
<script type="text/javascript">
// <![CDATA[
spajax_init();
// ]]>
</script>
EOT;

    return $output;
  }*/
}

/**
 * Implementation of hook_form_alter()
 * 
 * This should really be a part of core, but we're going to ensure that all form tags
 * are written to the page using <form id="form_id"... so that we can target them easily
 * using javascript
 *
 */

function spajax_form_alter($form_id, &$form_values){
  if (!isset($form_values['#attributes']['id'])){
    $form_values['#attributes']['id'] = $form_id;
  }
}

function spajax_settings_page() { 
  drupal_set_title(t('Scriptaculous/Prototype/AJAX Settings'));
  $form['fx'] = array('#type' => 'fieldset', '#title' => t('Effects'));
  $fx_options = variable_get('spajax_fx_options', array('' => 'none', 'Pulsate' => 'Pulsate', 'Shake' => 'Shake', 'Highlight' => 'Highlight'));
  $form['fx']['status_effect'] = array(
    '#type' => 'select', 
    '#title' => t('Status Message Effect'), 
    '#default_value' => variable_get('status_effect', 'Pulsate'), 
    '#options' => $fx_options,
    '#description' => t('Scriptaculous effect added to Drupal status messages and triggered when page loads'), 
  );
  $form['fx']['error_effect'] = array( 
    '#type' => 'select', 
    '#title' => t('Error Message Effect'), 
    '#default_value' => variable_get('error_effect', 'Pulsate'), 
    '#options' => $fx_options,
    '#description' => t('Effect added to Drupal error messages and triggered when page loads'), 
  );
  $form['#tree'] = TRUE;
  
  $form[] = array('#type' => 'submit', '#value' => t('Submit'));
  return drupal_get_form('spajax_settings', $form); 
}

function spajax_settings_submit($form_id, $form_values){
  //drupal_set_message('<pre>'. print_r($form_values, true) .'</pre>');
  variable_set('status_effect', $form_values['fx']['status_effect']);
  variable_set('error_effect', $form_values['fx']['error_effect']);
  drupal_set_message(t('Settings have been saved.'));
  // reload the page with the new variables
  drupal_goto('admin/settings/spajax');
}

/**************** Custom form elements *********************/

/**
 * Expansion function for 'sortable' type form element
 * 
 * extra arguments:
 * 
 * #items => array()
 *   required - Keyed array of items to be sorted.
 *   Keys will be returned in sorted order.
 *   Values can be anything, but they will get wrapped in <li> elements
 * 
 *  #options => array()
 *    options to modify the behaviour of the sorting
 *    see: http://wiki.script.aculo.us/scriptaculous/show/Sortable.create
 *  
 *  #outer_tag => 'div'
 *  #inner_tag => 'div'
 *    type of tag to use for sortables (could also be 'ul' and 'li'... or anything)
 *
 * @param array $element
 *   the array representing the sortable element
 */
function spajax_form_sortable($element){
  //var_dump($element);
  static $i = 1;
  $innertag = $element['#inner_tag'];
  $outertag = $element['#outer_tag'];
  //$outerid = $element['#attributes']['id'] ? $element['#attributes']['id'] : 'sortable'.$i++;
  $outerid = $element['#parents'][0];
  
  $sortables['#prefix'] = "<$outertag id='$outerid'>\n";
  $sortables['#suffix'] = "</$outertag>\n";
  
  // if there's a #value, eval it and resort
  if ($element['#value']){
    $keyorder = spajax_get_sort($element['#value']);
    $items = $element['#items'];
    foreach($keyorder as $key){
      $newitems[$key] = $items[$key];
    }
    $element['#items'] = $newitems;
    unset($element['#value']);
  }
  
  foreach($element['#items'] as $k => $v){
    $sortables[$k] = array('#type' => 'markup', '#value' => $v, '#prefix' => "<$innertag id='{$outerid}_{$k}' class='sortable'>", '#suffix' => "</$innertag>\n");
    $order[] = $k;
  }
  $value = $outerid.'[]='.implode('&'.$outerid.'[]=', $order);
  $element['#suffix'] .= '<input type="hidden" name="'. $element['#name'] .'" value="'. $value .'" id="'.$element['#id'].'" />';
  
  $element['#options']['tag'] = $innertag;
  
  if (!isset($element['#callback_path'])){
    // store in a hidden field
    $element['#options']['#onUpdate'] = "function(){\$('". $element['#id'] ."').value = Sortable.serialize('$outerid');}";
  }
  else {
    // immediately send to the server
    $element['#options']['#onUpdate'] = "function(){\$('". $element['#id'] ."').value = Sortable.serialize('$outerid');}";
  }
  
  spajax_sortable_element($outerid, $element['#options']);
  
  $element['#type'] = 'markup';
  $element[] = $sortables;
  
  // to do: get theme function working to add <label> and description
  // $element['#theme'] = 'sortable';
  
  return $element;
  
}


/**
 * Convert form output from spajax_form_sortable into an array
 * 
 * Prototype's sortable output is designed as a GET argument (e.g. ?sort[]=second&sort[]=thrid&sort[]=first)
 * 
 * This function converts the output of the hidden field into an array
 * 
 * note: maybe this function should be combined with spajax_unserialize();
 *
 * @param string $sort
 * @return array
 */

function spajax_get_sort($sort){
  parse_str($sort, $result);
  $return = array_shift($result);
  $return = is_array($return) ? $return : array();
  return $return;
}

/**
 * Decrypt data serialized by prototype's Form.serialize() javascript function
 * 
 * This function presumes that it is unserializing Drupal form elements
 * such as edit[foo]=bar&edit[foo2]=bar2
 * it will not work for foo=bar&foo2=bar2  -- currently commented out
 *
 * @param $string
 *  the serialized string
 */

function spajax_unserialize($string){
  $string = urldecode($string);
  parse_str($string, $result);
  //$return = array_shift($result); // un-nest the array
  //$return = is_array($return) ? $return : array();
  return $return;
}

/**
 * Stores javascript snippets to be output in a javascript block at end of page
 *
 * @param unknown_type $content
 */
function spajax_output($content = NULL){
  static $scripts = array();
  if (!is_null($content)){
    $scripts[] = $content;
  }
  else {
    return implode("\n", $scripts);
  }
}

/**
 * Adds functions into the head that can be called later
 * functions will appear in one <script> in the <head>
 * 
 * // would it just be easier to take the whole function?
 * // this may be overly complicated
 * 
 * @param string $function_name
 *   the name of the function
 * @param string $function
 *   the code of the function
 * @param array $arguments
 *   an array of argument variable names for the function
 * @return unknown
 */
function spajax_create_function($function_name = NULL, $function = NULL, $arguments = NULL){
  static $functions = array();
  if (!is_null($function_name)){
    $args = is_null($arguments) ? '' : implode(', ', $arguments);
    $functions[$function_name] = "function $function_name($args){\n".$function."\n}";
  }
  else {
    return implode("\n", $functions);
  }
}

/**
 * Put necessary CSS and JS into <HEAD>
 * 
 * This function is called whenever a Prototype-dependent function is called.
 * This way
 * 
 * 
 */
function spajax_head(){
  static $done = FALSE;
  if (!$done){
    $path = drupal_get_path('module', 'spajax').'/';
    theme_add_style($path .'spajax.css');
    if (file_exists($path .'scriptaculous/lib/prototype.js')) {
      drupal_add_js($path .'scriptaculous/lib/prototype.js');
      drupal_add_js($path .'scriptaculous/src/scriptaculous.js');
      drupal_add_js($path .'spajax.js');
    }
    else {
      drupal_set_message(t('The script.aculo.us library is in not installed correctly. Please download from <a href="http://script.aculo.us/downloads">http://script.aculo.us/downloads</a>, rename directory to "scriptaculous" and place in Drupal\'s modules/spajax/ directory.'), 'error');
    }
    $done = TRUE;
  }
}

/**
 * Implementation of hook_spajax
 * Adds effects to page if there is a message.
 * 
 * This hook takes no arguments and returns no value
 * Instead, implementations should use spajax_output() to add their output
 * to the JavaScript written to the page by the SPAjax module.
 *
 */
function spajax_spajax(){
  // only load things in if there are messages in the queue
  if (spajax_is_message()){
    $status_effect = variable_get('status_effect', 'Pulsate');
    if ($status_effect){
      $function = "msgs = document.getElementsByClassName('status');\n";
      $function .= "for (i=0; i<msgs.length; i++) {\n";
      $function .= "element = msgs[i];\n";
      $function .= spajax_visual_effect($status_effect).";\n";
      $function .= "}";
      spajax_create_function('status_effect', $function);
      spajax_output("status_effect();");
    }
    $error_effect = variable_get('error_effect', 'Pulsate');
    if ($error_effect){
      $function = "msgs = document.getElementsByClassName('error');\n";
      $function .= "for (i=0; i<msgs.length; i++) {\n";
      $function .= "element = msgs[i];\n";
      $function .= spajax_visual_effect($error_effect).";\n";
      $function .= "}";
      spajax_create_function('error_effect', $function);
      spajax_output("error_effect();");
    }
  }
}

/**
 * Create a sortable list from an array of elements (divs, form fields, whatever)
 * 
 * @param
 * $items is an array of elements - keys are ids for the elements
 * $title is a title for the list
 * $options is a keyed array of options for sortable.create options
 *   see: http://wiki.script.aculo.us/scriptaculous/show/Sortable.create
 * $ul_attributes are attributes for the ul
 * $li_attributes are attributes for the lis
 * $sortoptions is an array of options for the javascript behaviour
 * $description (not yet implemented)
 * 
 */
function theme_sortable_list($items, $title = '', $options = array(), $ul_attributes = array(), $li_attributes = array(), $description = ''){
  // we're going to need the CSS and the JS
  spajax_head();
  
  // id for non-keyed items without an $attributes['id'] item
  static $assignid = 'a';
  // id counter
  $idc = 1;
  
  // figure out the id for the ul 
  if (!isset($ul_attributes['id'])){
    $ul_attributes['id'] = $assignid;
  }
  if (strlen($title)){
    $output .= "<h2>$title</h2>\n";
  }
  $output .= '<ul'.drupal_attributes($ul_attributes).">\n";
  
  $li_attr = $li_attributes;
  unset($li_attributes['id']);
  if (!isset($li_attributes['class'])){
    $li_attributes['class'] = "sortable";
  }
  $li_attrstring = drupal_attributes($li_attributes);
  foreach($items as $key => $item){
    // figure out what the id is going to be
    if (!is_numeric($key)){
      $this_id = $key;
    }
    else {
      $this_id = $li_attributes['id'] ? $li_attributes['id'].$idc++ : $assignid.$idc++;
    }
    $output .= "<li id=\"$this_id\"$li_attrstring>";
    $output .= $item;
    $output .= "</li>\n";
  }
  $output .= "</ul>\n";
  
  spajax_sortable_element($ul_attributes['id'], $options);
  
  $assignid++;
  return $output;
}

/************* Prototype/Scriptaculous implementations **************/

/**
 * Makes the element with the DOM ID specified by element_id draggable.
 * This method requires the inclusion of the script.aculo.us JavaScript library.
 * Example:
 * spajax_draggable_element("my_image", array('revert' => true))
 * 
 * No return output. Instead, code is added for spajax_output() in the footer.
 *
 * @param string $element_id
 *   id of the element that will become draggable
 * @param array $options
 *   array of options to modify behaviour
 *   see: http://wiki.script.aculo.us/scriptaculous/show/Draggable
 */
function spajax_draggable_element($element_id, $options = NULL){
  spajax_head();
  $output = "new Draggable('$element_id', ".spajax_to_js($options).");\n";
  // add 'draggable' css class to the element
  if (isset($options['handle'])){
    // handle is a element id
    $output .= "\$('". $options['handle']. "').className += ' draggable';";
  }
  elseif (isset($options['#handle'])) {
    // handle is a variable or element reference
    $output .= $options['#handle']. ".className += ' draggable';";
  }
  else {
    // no handle
    $output .= "\$('$element_id').className += ' draggable';";
  }
  spajax_output($output);
}

/**
 * Makes the element with the DOM ID specified by element_id receive dropped
 * draggable elements (created by draggable_element). and make an AJAX call
 * By default, the action called gets the DOM ID of the element as parameter.
 * This method requires the inclusion of the script.aculo.us JavaScript library.
 * 
 * @example:
 * spajax_drop_receiving_element("my_cart", url => { :controller => "cart", :action => "add" })
 * [[[fix above]]]
 * 
 * You can change the behaviour with various options, see script.aculo.us
 * for more documentation.
 * 
 *  No return output. Instead, code is added for spajax_output() in the footer.
 *
 * @param string $element_id
 * @param array $options
 *   see: http://wiki.script.aculo.us/scriptaculous/show/Droppables.add
 */

function spajax_drop_receiving_element($element_id, $options = NULL){
  spajax_head();
  $output = "Droppables.add('$element_id', ".spajax_to_js($options).");";
  spajax_output($output);
}


/**
 * Make a slider control
 * 
 * http://wiki.script.aculo.us/scriptaculous/show/Slider
 *
 * @param string $handle_id
 *   id of the element that will be the handle for the slider
 * @param string $track_id
 *   id of the element that will be the track of the slider
 * @param array $options
 *   options to modify behaviour of the slider
 *   see: http://wiki.script.aculo.us/scriptaculous/show/Slider
 */

function spajax_slider($handle_id, $track_id, $options = NULL){
  spajax_head();
  $output = "new Control.Slider('$handle_id', '$track_id', ".spajax_to_js($options).");";
  spajax_output($output);
}

/**
 * Makes the element with the DOM ID specified by element_id sortable by
 * drag-and-drop and make an AJAX call whenever the sort order has changed.
 * By default, the action called gets the serialized sortable element as parameters.
 * This method requires the inclusion of the script.aculo.us JavaScript library.
 * 
 * @Example:
 *   spajax_sortable_element("my_list", array('action' => 'order'))
 * 
 * In the example, the action gets a "my_list" array parameter containing the values
 * of the ids of elements the sortable consists of, in the current order.
 * 
 * You can change the behaviour with various options, see script.aculo.us for more documentation.
 * 
 * No return output. Instead, code is added for spajax_output() in the footer.
 * 
 * @param string $element_id
 * @param array $options
 */

function spajax_sortable_element($element_id, $options = array()){
  spajax_head();
  $output = "Sortable.create('$element_id', ".spajax_to_js($options).");";
  if (isset($options['handle'])){
    // handle is a element id
    $output .= "\$(". $options['handle']. ").className += ' sortable'";
  }
  elseif (isset($options['#handle'])) {
    // handle is a variable or element reference
    $output .= $options['#handle']. ".className += ' sortable'";
  }
  else {
    // no handle
    $output .= "\$('$element_id').className += ' sortable'";
  }
  spajax_output($output);
}

//$name = sortable($title, array('value' => "some stuff", 'value2' => 'other stuff'));

/**
 * Returns a JavaScript snippet to be used on the AJAX callbacks for
 * starting visual effects.
 * This method requires the inclusion of the script.aculo.us JavaScript library.
 * 
 * @example:
 *  spajax_link_to_function('blind up', spajax_visual_effect('BlindUp', 'blinddiv'));
 * 
 * If no element_id is given, it assumes "element" which should be a local
 * variable in the generated JavaScript execution context. This can be used
 * for example with drop_receiving_element:
 *
 *  spajax_drop_receving_element (...), :loading => visual_effect('fade')
 * 
 * This would fade the element that was dropped on the drop receiving element.
 * 
 * You can change the behaviour with various options, see script.aculo.us
 * for more documentation.
 * 
 * http://wiki.script.aculo.us/scriptaculous/show/CoreEffects
 * http://wiki.script.aculo.us/scriptaculous/show/CombinationEffects
 * 
 * @todo 
 *   - option for using effects queue:
 *     http://www.railsdevelopment.com/2006/01/15/effectqueue/
 *
 * @param string $name
 *   name of the effect (see script.aculo.us
 * @param string $element_id
 *   id of element to effect
 * @param array $options
 *   options for the effect - see docs:
 *   
 * @return string
 *   the function
 */

function spajax_visual_effect($name, $element_id = FALSE, $options = NULL){
  spajax_head();
  $element_id = $element_id ? "'".$element_id."'" : 'element';
  $output = "new Effect.$name($element_id,".spajax_to_js($options).")";
  return $output;
}

/**
 * Return a function to build (nested) DOM element(s)
 *
 * @param string $tag_name
 *   tag name of the element to be built
 * @param keyed array or object $attributes
 *   attributes for the tag
 * @param array $children
 *   (non keyed) array of children for this element
 * @return string
 * 
 * Notes:
 * When specifying the class attribute for the node, use className to circumvent a Firefox bug.
 * This can not be used to create TR or TD elements
 * 
 * see also: http://wiki.script.aculo.us/scriptaculous/show/Builder
 * 
 */

function spajax_build($tag_name, $attributes, $children){
  // Builder.node( elementName, attributes, children )
  spajax_head();
  $output = "Builder.node('$tag_name',".spajax_to_js($attributes).", ".spajax_to_js($children).");";
  return $output;
}

/*
function spajax_append_to_element($element_id, $tag_name, $attributes, $children){
  spajax_head();
  $output = "new Effect.$name('$element_id',".spajax_to_js($options).");";
  return $output;
}
*/

/**
 * Insert HTML before, after, or inside an element
 *
 * @param string $target_element
 *   id of element to insert before/after/inside
 * @param string $html
 *   html or text to insert
 * @param string $location
 *   possible values:
 *     Before - insert before the element
 *     After - insert after the element
 *     Top - insert inside at the top
 *     Bottom - insert inside at the bottom
 */

function spajax_insert_html($target_element, $html, $location = 'after'){
  spajax_head();
  $html = addslashes($html);
  $html = str_replace("\n", '\n', $html);
  $output = "new Insertion.$location('$target_element', '$html');";
  return $output;
}


function spajax_observe($element, $name, $observer_func){
  return "Event.observe('$element', );";
}

/**
 * Enable an element for in-place editing
 *
 * @param string $element_id
 *   id of the element to be edited
 * @param string $path
 *   Drupal path for callback (example: "mymodule/callback")
 * @param array $options
 *   An array of options to change the behaviour - see docs:
 *   http://wiki.script.aculo.us/scriptaculous/show/Ajax.InPlaceEditor
 * 
 */

function spajax_in_place_editor($element_id, $path, $options = NULL){
  spajax_head();
  $url = url($path, NULL, NULL, TRUE); // absolute because JS may not read the base href
  $output = "new Ajax.InPlaceEditor('$element_id', '$url', ".spajax_to_js($options).");";
  spajax_output($output);
}

/**
 * Make a textfield autocomplete
 *
 * @param string $textfield_id
 *   id of the textfield
 * @param string $div_id
 *   id of the div that gets populated 
 * @param string $path
 *   Drupal menu path for the callback function to return autocomplete items
 * @param array $options
 *   options to modify behaviour of the autocompleter
 *   see: http://wiki.script.aculo.us/scriptaculous/show/Ajax.Autocompleter
 */

function spajax_autocompleter($textfield_id, $div_id, $path, $options = NULL){
  spajax_head();
  $url = url($path, NULL, NULL, TRUE); // absolute because JS may not read the base href
  $output = "new Ajax.Autocompleter('$textfield_id', '$div_id', '$url', ".spajax_to_js($options).");";
  spajax_output($output);
}


function spajax_ajax_request($path, $options = NULL){
  $url = url($path, NULL, NULL, TRUE);
  $opts = spajax_to_js($options);
  $output = "new Ajax.Request('$url', $opts)";
  return $output;  
}

/******************** Helper functions **************************/

/**
 * Returns a link thatÕll trigger a javascript function using the onclick
 * handler and return false after the fact.
 * 
 * @examples:
 * spajax_link_to_function("Greeting", "alert('Hello world!')")
 * spajax_link_to_function(theme('image', 'delete.png'), "if confirm('Really?'){ do_delete(); }")
 *
 * @param html $linkhtml
 *   the link (text, image, etc) itself
 * @param string $function
 *   the javascript function to be run when the link is clicked
 * @param string $fallback
 *  the href of the link. non-javascript will follow this link.
 * @param array $attributes
 *   an array of html attributes
 * 
 * @return html string representing the link
 */

function spajax_link_to_function($linkhtml, $function, $fallback = '#', $attributes = array()){
  spajax_head();
  $fallback = ($fallback == '#') ? $_GET['q'].'#' : $fallback;
  $attributes = array_merge($attributes, array('onclick' => $function .'; return false;'));
  return l($linkhtml, $fallback, $attributes, NULL, NULL, FALSE, TRUE);
}

/**
 * This callback receives an ajax call with POST information
 * it looks through the $_POST['vars'] array and saves each into
 * the user's session for retrieval using the spajax_get() function
 *
 */

function spajax_set(){
  if ($_POST['vars']){
    if(is_array($_POST['vars'])){
      foreach($_POST['vars'] as $block_id => $pos)
      $_SESSION['proto_vars'][$block_id] = $pos;
    }
  }
}

function spajax_get($type, $uid = NULL){
  return $_SESSION['proto_vars'][$type];
}

/**
 * This function tests to see if there is a drupal message
 * and stores it for later
 * 
 * workaround for checking drupal_set_message() in the footer
 * because by that point it has been cleared out
 *
 * @return unknown
 */

function spajax_is_message(){
  static $bool;
  if (!isset($bool)){
    $bool = !is_null(drupal_set_message());
  }
  return $bool;
}

/******************** Core rewrites *************************/

/**
 * Modification of drupal_to_js()
 * adds support for anonymous arrays & function (non-quoted) strings
 * 
 * prefix key with # to prevent quoting of value
 * 
 * @example
 * spajax_to_js(
 *   array('containment' => array('element_1', 'element_2'), '#onUpdate' => 'function(){alert("hi");}'));
 * returns:
 *   {containment: ['element_1', 'element_2'], onUpdate: function(){alert("hi");}}
 * 
 * [[[^^^check that^^^]]]
 *
 * @param mixed $var
 *   any type of variable
 * 
 * @param string $key
 *   used internally
 * 
 * @return string
 *   a javascript representation of the variable
 */
function spajax_to_js($var, $key = NULL) {
  switch (gettype($var)) {
    case 'boolean':
    case 'integer':
    case 'double':
      return $var;
    case 'resource':
    case 'string':
      // if the key for this variable starts with a #, don't quote it
      if ($key{0} == '#') {
        $output = $var;
      }
      else {
        $output = str_replace(array("\r", "\n"), array('\r', '\n'), addslashes($var));
        $output = '"'. $output .'"';
      }
      return $output;
    case 'array':
      //check to see if there are non-numeric keys
      $keys = false;
      foreach(array_keys($var) as $key){
        if(!is_numeric($key)){
          $keys = true;
          break;
        }
      }
      if (!$keys) {
        foreach($var as $v) {
          $output[] = spajax_to_js($v);
        }
        return '[ '.implode(', ', $output) .' ]';
      }
      // if it's an array with keys, continue to object treatment
    case 'object':
      $output = array();
      foreach ($var as $k => $v) {
        if ($k{0} == '#'){
          $ok = substr($k, 1);
        }
        else {
          $ok = $k;
        }
        $output[] = $ok .': '. spajax_to_js($v, $k);
      }
      return '{ '. implode(', ', $output) .' }';
    default:
      return 'null';
  }
}

?>