Subversion-Projekte lars-tiefland.cakephp

<?php

/* SVN FILE: $Id: ajax.php 7945 2008-12-19 02:16:01Z gwoo $ */

/**

 * Helper for AJAX operations.

 *

 * Helps doing AJAX using the Prototype library.

 *

 * PHP versions 4 and 5

 *

 * CakePHP(tm) :  Rapid Development Framework (http://www.cakephp.org)

 * Copyright 2005-2008, Cake Software Foundation, Inc. (http://www.cakefoundation.org)

 *

 * Licensed under The MIT License

 * Redistributions of files must retain the above copyright notice.

 *

 * @filesource

 * @copyright     Copyright 2005-2008, Cake Software Foundation, Inc. (http://www.cakefoundation.org)

 * @link          http://www.cakefoundation.org/projects/info/cakephp CakePHP(tm) Project

 * @package       cake

 * @subpackage    cake.cake.libs.view.helpers

 * @since         CakePHP(tm) v 0.10.0.1076

 * @version       $Revision: 7945 $

 * @modifiedby    $LastChangedBy: gwoo $

 * @lastmodified  $Date: 2008-12-18 18:16:01 -0800 (Thu, 18 Dec 2008) $

 * @license       http://www.opensource.org/licenses/mit-license.php The MIT License

 */

/**

 * AjaxHelper helper library.

 *

 * Helps doing AJAX using the Prototype library.

 *

 * @package       cake

 * @subpackage    cake.cake.libs.view.helpers

 */

class AjaxHelper extends AppHelper {

/**

 * Included helpers.

 *

 * @var array

 */

	var $helpers = array('Html', 'Javascript', 'Form');

/**

 * HtmlHelper instance

 *

 * @var object

 * @access public

 */

	var $Html = null;

/**

 * JavaScriptHelper instance

 *

 * @var object

 * @access public

 */

	var $Javascript = null;

/**

 * Names of Javascript callback functions.

 *

 * @var array

 */

	var $callbacks = array(

		'complete', 'create', 'exception', 'failure', 'interactive', 'loading',

		'loaded', 'success', 'uninitialized'

	);

/**

 * Names of AJAX options.

 *

 * @var array

 */

	var $ajaxOptions = array(

		'after', 'asynchronous', 'before', 'confirm', 'condition', 'contentType', 'encoding',

		'evalScripts', 'failure', 'fallback', 'form', 'indicator', 'insertion', 'interactive',

		'loaded', 'loading', 'method', 'onCreate', 'onComplete', 'onException', 'onFailure',

		'onInteractive', 'onLoaded', 'onLoading', 'onSuccess', 'onUninitialized', 'parameters',

		'position', 'postBody', 'requestHeaders', 'success', 'type', 'update', 'with'

	);

/**

 * Options for draggable.

 *

 * @var array

 */

	var $dragOptions = array(

		'handle', 'revert', 'snap', 'zindex', 'constraint', 'change', 'ghosting',

		'starteffect', 'reverteffect', 'endeffect'

	);

/**

 * Options for droppable.

 *

 * @var array

 */

	var $dropOptions = array(

		'accept', 'containment', 'greedy', 'hoverclass', 'onHover', 'onDrop', 'overlap'

	);

/**

 * Options for sortable.

 *

 * @var array

 */

	var $sortOptions = array(

		'constraint', 'containment', 'dropOnEmpty', 'ghosting', 'handle', 'hoverclass', 'onUpdate',

		'onChange', 'only', 'overlap', 'scroll', 'scrollSensitivity', 'scrollSpeed', 'tag', 'tree',

		'treeTag', 'update'

	);

/**

 * Options for slider.

 *

 * @var array

 */

	var $sliderOptions = array(

		'alignX', 'alignY', 'axis', 'disabled', 'handleDisabled', 'handleImage', 'increment',

		'maximum', 'minimum', 'onChange', 'onSlide', 'range', 'sliderValue', 'values'

	);

/**

 * Options for in-place editor.

 *

 * @var array

 */

	var $editorOptions = array(

		'okText', 'cancelText', 'savingText', 'formId', 'externalControl', 'rows', 'cols', 'size',

		'highlightcolor', 'highlightendcolor', 'savingClassName', 'formClassName', 'loadTextURL',

		'loadingText', 'callback', 'ajaxOptions', 'clickToEditText', 'collection', 'okControl',

		'cancelControl', 'submitOnBlur'

	);

/**

 * Options for auto-complete editor.

 *

 * @var array

 */

	var $autoCompleteOptions = array(

		'afterUpdateElement', 'callback', 'frequency', 'indicator', 'minChars', 'onShow', 'onHide',

		'parameters', 'paramName', 'tokens', 'updateElement'

	);

/**

 * Output buffer for Ajax update content

 *

 * @var array

 */

	var $__ajaxBuffer = array();

/**

 * Returns link to remote action

 *

 * Returns a link to a remote action defined by <i>options[url]</i>

 * (using the url() format) that's called in the background using

 * XMLHttpRequest. The result of that request can then be inserted into a

 * DOM object whose id can be specified with <i>options[update]</i>.

 *

 * Examples:

 * <code>

 *  link("Delete this post",

 * array("update" => "posts", "url" => "delete/{$postid->id}"));

 *  link(imageTag("refresh"),

 *		array("update" => "emails", "url" => "list_emails" ));

 * </code>

 *

 * By default, these remote requests are processed asynchronous during

 * which various callbacks can be triggered (for progress indicators and

 * the likes).

 *

 * Example:

 * <code>

 *	link (word,

 *		array("url" => "undo", "n" => word_counter),

 *		array("complete" => "undoRequestCompleted(request)"));

 * </code>

 *

 * The callbacks that may be specified are:

 *

 * - <i>loading</i>::		Called when the remote document is being

 *							loaded with data by the browser.

 * - <i>loaded</i>::		Called when the browser has finished loading

 *							the remote document.

 * - <i>interactive</i>::	Called when the user can interact with the

 *							remote document, even though it has not

 *							finished loading.

 * - <i>complete</i>:: Called when the XMLHttpRequest is complete.

 *

 * If you for some reason or another need synchronous processing (that'll

 * block the browser while the request is happening), you can specify

 * <i>options[type] = synchronous</i>.

 *

 * You can customize further browser side call logic by passing

 * in Javascript code snippets via some optional parameters. In

 * their order of use these are:

 *

 * - <i>confirm</i>:: Adds confirmation dialog.

 * -<i>condition</i>::	Perform remote request conditionally

 *                      by this expression. Use this to

 *                      describe browser-side conditions when

 *                      request should not be initiated.

 * - <i>before</i>::		Called before request is initiated.

 * - <i>after</i>::		Called immediately after request was

 *						initiated and before <i>loading</i>.

 *

 * @param string $title Title of link

 * @param string $href Href string "/products/view/12"

 * @param array $options		Options for JavaScript function

 * @param string $confirm		Confirmation message. Calls up a JavaScript confirm() message.

 * @param boolean $escapeTitle  Escaping the title string to HTML entities

 *

 * @return string				HTML code for link to remote action

 */

	function link($title, $href = null, $options = array(), $confirm = null, $escapeTitle = true) {

		if (!isset($href)) {

			$href = $title;

		}

		if (!isset($options['url'])) {

			$options['url'] = $href;

		}

		if (isset($confirm)) {

			$options['confirm'] = $confirm;

			unset($confirm);

		}

		$htmlOptions = $this->__getHtmlOptions($options, array('url'));

		if (empty($options['fallback']) || !isset($options['fallback'])) {

			$options['fallback'] = $href;

		}

		$htmlDefaults = array('id' => 'link' . intval(mt_rand()), 'onclick' => '');

		$htmlOptions = array_merge($htmlDefaults, $htmlOptions);

		$htmlOptions['onclick'] .= ' event.returnValue = false; return false;';

		$return = $this->Html->link($title, $href, $htmlOptions, null, $escapeTitle);

		$callback = $this->remoteFunction($options);

		$script = $this->Javascript->event("'{$htmlOptions['id']}'", "click", $callback);

		if (is_string($script)) {

			$return .= $script;

		}

		return $return;

	}

/**

 * Creates JavaScript function for remote AJAX call

 *

 * This function creates the javascript needed to make a remote call

 * it is primarily used as a helper for AjaxHelper::link.

 *

 * @param array $options options for javascript

 * @return string html code for link to remote action

 * @see AjaxHelper::link() for docs on options parameter.

 */

	function remoteFunction($options) {

		if (isset($options['update'])) {

			if (!is_array($options['update'])) {

				$func = "new Ajax.Updater('{$options['update']}',";

			} else {

				$func = "new Ajax.Updater(document.createElement('div'),";

			}

			if (!isset($options['requestHeaders'])) {

				$options['requestHeaders'] = array();

			}

			if (is_array($options['update'])) {

				$options['update'] = join(' ', $options['update']);

			}

			$options['requestHeaders']['X-Update'] = $options['update'];

		} else {

			$func = "new Ajax.Request(";

		}

		$func .= "'" . $this->url(isset($options['url']) ? $options['url'] : "") . "'";

		$func .= ", " . $this->__optionsForAjax($options) . ")";

		if (isset($options['before'])) {

			$func = "{$options['before']}; $func";

		}

		if (isset($options['after'])) {

			$func = "$func; {$options['after']};";

		}

		if (isset($options['condition'])) {

			$func = "if ({$options['condition']}) { $func; }";

		}

		if (isset($options['confirm'])) {

			$func = "if (confirm('" . $this->Javascript->escapeString($options['confirm'])

				. "')) { $func; } else { event.returnValue = false; return false; }";

		}

		return $func;

	}

/**

 * Periodically call remote url via AJAX.

 *

 * Periodically calls the specified url (<i>options[url]</i>) every <i>options[frequency]</i>

 * seconds (default is 10).  Usually used to update a specified div (<i>options[update]</i>) with

 * the results of the remote call.  The options for specifying the target with url and defining

 * callbacks is the same as AjaxHelper::link().

 *

 * @param array $options Callback options

 * @return string Javascript code

 * @see AjaxHelper::link()

 */

	function remoteTimer($options = null) {

		$frequency = (isset($options['frequency'])) ? $options['frequency'] : 10;

		$callback = $this->remoteFunction($options);

		$code = "new PeriodicalExecuter(function() {{$callback}}, $frequency)";

		return $this->Javascript->codeBlock($code);

	}

/**

 * Returns form tag that will submit using Ajax.

 *

 * Returns a form tag that will submit using XMLHttpRequest in the background instead of the regular

 * reloading POST arrangement. Even though it's using Javascript to serialize the form elements,

 * the form submission will work just like a regular submission as viewed by the receiving side

 * (all elements available in params).  The options for defining callbacks is the same

 * as AjaxHelper::link().

 *

 * @param mixed $params Either a string identifying the form target, or an array of method

 *                      parameters, including:

 *                          - 'params' => Acts as the form target

 *                          - 'type' => 'post' or 'get'

 *                          - 'options' => An array containing all HTML and script options used to

 *                             generate the form tag and Ajax request.

 * @param array $type How form data is posted: 'get' or 'post'

 * @param array $options Callback/HTML options

 * @return string JavaScript/HTML code

 * @see AjaxHelper::link()

 */

	function form($params = null, $type = 'post', $options = array()) {

		$model = false;

		if (is_array($params)) {

			extract($params, EXTR_OVERWRITE);

		}

		if (empty($options['url'])) {

			$options['url'] = array('action' => $params);

		}

		$htmlDefaults = array(

			'id' => 'form' . intval(mt_rand()),

			'onsubmit'	=> "event.returnValue = false; return false;",

			'type' => $type

		);

		$htmlOptions = $this->__getHtmlOptions($options, array('model', 'with'));

		$htmlOptions = array_merge($htmlDefaults, $htmlOptions);

		$defaults = array('model' => $model, 'with' => "Form.serialize('{$htmlOptions['id']}')");

		$options = array_merge($defaults, $options);

		$callback = $this->remoteFunction($options);

		$form = $this->Form->create($options['model'], $htmlOptions);

		$script = $this->Javascript->event("'" . $htmlOptions['id']. "'", 'submit', $callback);

		return $form . $script;

	}

/**

 * Returns a button input tag that will submit using Ajax

 *

 * Returns a button input tag that will submit form using XMLHttpRequest in the background instead

 * of regular reloading POST arrangement. <i>options</i> argument is the same as

 * in AjaxHelper::form().

 *

 * @param string $title Input button title

 * @param array $options Callback options

 * @return string Ajaxed input button

 * @see AjaxHelper::form()

 */

	function submit($title = 'Submit', $options = array()) {

		$htmlOptions = $this->__getHtmlOptions($options);

		$htmlOptions['value'] = $title;

		if (!isset($options['with'])) {

			$options['with'] = 'Form.serialize(Event.element(event).form)';

		}

		if (!isset($htmlOptions['id'])) {

			$htmlOptions['id'] = 'submit' . intval(mt_rand());

		}

		$htmlOptions['onclick'] = "event.returnValue = false; return false;";

		$callback = $this->remoteFunction($options);

		$form = $this->Form->submit($title, $htmlOptions);

		$script = $this->Javascript->event('"' . $htmlOptions['id'] . '"', 'click', $callback);

		return $form . $script;

	}

/**

 * Observe field and call ajax on change.

 *

 * Observes the field with the DOM ID specified by <i>field</i> and makes

 * an Ajax when its contents have changed.

 *

 * Required +options+ are:

 * - <i>frequency</i>:: The frequency (in seconds) at which changes to

 *						this field will be detected.

 * - <i>url</i>::		@see url() -style options for the action to call

 *						when the field has changed.

 *

 * Additional options are:

 * - <i>update</i>::	Specifies the DOM ID of the element whose

 *						innerHTML should be updated with the

 *						XMLHttpRequest response text.

 * - <i>with</i>:: A Javascript expression specifying the

 *						parameters for the XMLHttpRequest. This defaults

 *						to Form.Element.serialize('$field'), which can be

 *						accessed from params['form']['field_id'].

 *

 * Additionally, you may specify any of the options documented in

 * @see linkToRemote().

 *

 * @param string $field DOM ID of field to observe

 * @param array $options ajax options

 * @return string ajax script

 */

	function observeField($field, $options = array()) {

		if (!isset($options['with'])) {

			$options['with'] = 'Form.Element.serialize(\'' . $field . '\')';

		}

		$observer = 'Observer';

		if (!isset($options['frequency']) || intval($options['frequency']) == 0) {

			$observer = 'EventObserver';

		}

		return $this->Javascript->codeBlock(

			$this->_buildObserver('Form.Element.' . $observer, $field, $options)

		);

	}

/**

 * Observe entire form and call ajax on change.

 *

 * Like @see observeField(), but operates on an entire form identified by the

 * DOM ID <b>form</b>. <b>options</b> are the same as <b>observeField</b>, except

 * the default value of the <i>with</i> option evaluates to the

 * serialized (request string) value of the form.

 *

 * @param string $form DOM ID of form to observe

 * @param array $options ajax options

 * @return string ajax script

 */

	function observeForm($form, $options = array()) {

		if (!isset($options['with'])) {

			$options['with'] = 'Form.serialize(\'' . $form . '\')';

		}

		$observer = 'Observer';

		if (!isset($options['frequency']) || intval($options['frequency']) == 0) {

			$observer = 'EventObserver';

		}

		return $this->Javascript->codeBlock(

			$this->_buildObserver('Form.' . $observer, $form, $options)

		);

	}

/**

 * Create a text field with Autocomplete.

 *

 * Creates an autocomplete field with the given ID and options.

 *

 * options['with'] defaults to "Form.Element.serialize('$field')",

 * but can be any valid javascript expression defining the additional fields.

 *

 * @param string $field DOM ID of field to observe

 * @param string $url URL for the autocomplete action

 * @param array $options Ajax options

 * @return string Ajax script

 */

	function autoComplete($field, $url = "", $options = array()) {

		$var = '';

		if (isset($options['var'])) {

			$var = 'var ' . $options['var'] . ' = ';

			unset($options['var']);

		}

		if (!isset($options['id'])) {

			$options['id'] = Inflector::camelize(str_replace(".", "_", $field));

		}

		$divOptions = array(

			'id' => $options['id'] . "_autoComplete",

			'class' => isset($options['class']) ? $options['class'] : 'auto_complete'

		);

		if (isset($options['div_id'])) {

			$divOptions['id'] = $options['div_id'];

			unset($options['div_id']);

		}

		$htmlOptions = $this->__getHtmlOptions($options);

		$htmlOptions['autocomplete'] = "off";

		foreach ($this->autoCompleteOptions as $opt) {

			unset($htmlOptions[$opt]);

		}

		if (isset($options['tokens'])) {

			if (is_array($options['tokens'])) {

				$options['tokens'] = $this->Javascript->object($options['tokens']);

			} else {

				$options['tokens'] = '"' . $options['tokens'] . '"';

			}

		}

		$options = $this->_optionsToString($options, array('paramName', 'indicator'));

		$options = $this->_buildOptions($options, $this->autoCompleteOptions);

		$text = $this->Form->text($field, $htmlOptions);

		$div = $this->Html->div(null, '', $divOptions);

		$script = "{$var}new Ajax.Autocompleter('{$htmlOptions['id']}', '{$divOptions['id']}', '";

		$script .= $this->Html->url($url) . "', {$options});";

		return  "{$text}\n{$div}\n" . $this->Javascript->codeBlock($script);

	}

/**

 * Creates an Ajax-updateable DIV element

 *

 * @param string $id options for javascript

 * @return string HTML code

 */

	function div($id, $options = array()) {

		if (env('HTTP_X_UPDATE') != null) {

			$this->Javascript->enabled = false;

			$divs = explode(' ', env('HTTP_X_UPDATE'));

			if (in_array($id, $divs)) {

				@ob_end_clean();

				ob_start();

				return '';

			}

		}

		$attr = $this->_parseAttributes(array_merge($options, array('id' => $id)));

		return $this->output(sprintf($this->Html->tags['blockstart'], $attr));

	}

/**

 * Closes an Ajax-updateable DIV element

 *

 * @param string $id The DOM ID of the element

 * @return string HTML code

 */

	function divEnd($id) {

		if (env('HTTP_X_UPDATE') != null) {

			$divs = explode(' ', env('HTTP_X_UPDATE'));

			if (in_array($id, $divs)) {

				$this->__ajaxBuffer[$id] = ob_get_contents();

				ob_end_clean();

				ob_start();

				return '';

			}

		}

		return $this->output($this->Html->tags['blockend']);

	}

/**

 * Detects Ajax requests

 *

 * @return boolean True if the current request is a Prototype Ajax update call

 */

	function isAjax() {

		return (isset($this->params['isAjax']) && $this->params['isAjax'] === true);

	}

/**

 * Creates a draggable element.  For a reference on the options for this function,

 * check out http://github.com/madrobby/scriptaculous/wikis/draggable

 *

 * @param unknown_type $id

 * @param array $options

 * @return unknown

 */

	function drag($id, $options = array()) {

		$var = '';

		if (isset($options['var'])) {

			$var = 'var ' . $options['var'] . ' = ';

			unset($options['var']);

		}

		$options = $this->_buildOptions(

			$this->_optionsToString($options, array('handle', 'constraint')), $this->dragOptions

		);

		return $this->Javascript->codeBlock("{$var}new Draggable('$id', " .$options . ");");

	}

/**

 * For a reference on the options for this function, check out

 * http://github.com/madrobby/scriptaculous/wikis/droppables

 *

 * @param unknown_type $id

 * @param array $options

 * @return string

 */

	function drop($id, $options = array()) {

		$optionsString = array('overlap', 'hoverclass');

		if (!isset($options['accept']) || !is_array($options['accept'])) {

			$optionsString[] = 'accept';

		} else if (isset($options['accept'])) {

			$options['accept'] = $this->Javascript->object($options['accept']);

		}

		$options = $this->_buildOptions(

			$this->_optionsToString($options, $optionsString), $this->dropOptions

		);

		return $this->Javascript->codeBlock("Droppables.add('{$id}', {$options});");

	}

/**

 * Make an element with the given $id droppable, and trigger an Ajax call when a draggable is

 * dropped on it.

 *

 * For a reference on the options for this function, check out

 * http://wiki.script.aculo.us/scriptaculous/show/Droppables.add

 *

 * @param string $id

 * @param array $options

 * @param array $ajaxOptions

 * @return string JavaScript block to create a droppable element

 */

	function dropRemote($id, $options = array(), $ajaxOptions = array()) {

		$callback = $this->remoteFunction($ajaxOptions);

		$options['onDrop'] = "function(element, droppable, event) {{$callback}}";

		$optionsString = array('overlap', 'hoverclass');

		if (!isset($options['accept']) || !is_array($options['accept'])) {

			$optionsString[] = 'accept';

		} else if (isset($options['accept'])) {

			$options['accept'] = $this->Javascript->object($options['accept']);

		}

		$options = $this->_buildOptions(

			$this->_optionsToString($options, $optionsString),

			$this->dropOptions

		);

		return $this->Javascript->codeBlock("Droppables.add('{$id}', {$options});");

	}

/**

 * Makes a slider control.

 *

 * @param string $id DOM ID of slider handle

 * @param string $trackId DOM ID of slider track

 * @param array $options Array of options to control the slider

 * @link          http://github.com/madrobby/scriptaculous/wikis/slider

 */

	function slider($id, $trackId, $options = array()) {

		if (isset($options['var'])) {

			$var = 'var ' . $options['var'] . ' = ';

			unset($options['var']);

		} else {

			$var = 'var ' . $id . ' = ';

		}

		$options = $this->_optionsToString($options, array(

			'axis', 'handleImage', 'handleDisabled'

		));

		$callbacks = array('change', 'slide');

		foreach ($callbacks as $callback) {

			if (isset($options[$callback])) {

				$call = $options[$callback];

				$options['on' . ucfirst($callback)] = "function(value) {{$call}}";

				unset($options[$callback]);

			}

		}

		if (isset($options['values']) && is_array($options['values'])) {

			$options['values'] = $this->Javascript->object($options['values']);

		}

		$options = $this->_buildOptions($options, $this->sliderOptions);

		$script = "{$var}new Control.Slider('$id', '$trackId', $options);";

		return $this->Javascript->codeBlock($script);

	}

/**

 * Makes an Ajax In Place editor control.

 *

 * @param string $id DOM ID of input element

 * @param string $url Postback URL of saved data

 * @param array $options Array of options to control the editor, including ajaxOptions (see link).

 * @link          http://github.com/madrobby/scriptaculous/wikis/ajax-inplaceeditor

 */

	function editor($id, $url, $options = array()) {

		$url = $this->url($url);

		$options['ajaxOptions'] = $this->__optionsForAjax($options);

		foreach ($this->ajaxOptions as $opt) {

			if (isset($options[$opt])) {

				unset($options[$opt]);

			}

		}

		if (isset($options['callback'])) {

			$options['callback'] = 'function(form, value) {' . $options['callback'] . '}';

		}

		$type = 'InPlaceEditor';

		if (isset($options['collection']) && is_array($options['collection'])) {

			$options['collection'] = $this->Javascript->object($options['collection']);

			$type = 'InPlaceCollectionEditor';

		}

		$var = '';

		if (isset($options['var'])) {

			$var = 'var ' . $options['var'] . ' = ';

			unset($options['var']);

		}

		$options = $this->_optionsToString($options, array(

			'okText', 'cancelText', 'savingText', 'formId', 'externalControl', 'highlightcolor',

			'highlightendcolor', 'savingClassName', 'formClassName', 'loadTextURL', 'loadingText',

			'clickToEditText', 'okControl', 'cancelControl'

		));

		$options = $this->_buildOptions($options, $this->editorOptions);

		$script = "{$var}new Ajax.{$type}('{$id}', '{$url}', {$options});";

		return $this->Javascript->codeBlock($script);

	}

/**

 * Makes a list or group of floated objects sortable.

 *

 * @param string $id DOM ID of parent

 * @param array $options Array of options to control sort.

 * @link          http://github.com/madrobby/scriptaculous/wikis/sortable

 */

	function sortable($id, $options = array()) {

		if (!empty($options['url'])) {

			if (empty($options['with'])) {

				$options['with'] = "Sortable.serialize('$id')";

			}

			$options['onUpdate'] = 'function(sortable) {' . $this->remoteFunction($options) . '}';

		}

		$block = true;

		if (isset($options['block'])) {

			$block = $options['block'];

			unset($options['block']);

		}

		$strings = array(

			'tag', 'constraint', 'only', 'handle', 'hoverclass', 'tree',

			'treeTag', 'update', 'overlap'

		);

		$scrollIsObject = (

			isset($options['scroll']) &&

			$options['scroll'] != 'window' &&

			strpos($options['scroll'], '$(') !== 0

		);

		if ($scrollIsObject) {

			$strings[] = 'scroll';

		}

		$options = $this->_optionsToString($options, $strings);

		$options = array_merge($options, $this->_buildCallbacks($options));

		$options = $this->_buildOptions($options, $this->sortOptions);

		$result = "Sortable.create('$id', $options);";

		if (!$block) {

			return $result;

		}

		return $this->Javascript->codeBlock($result);

	}

/**

 * Private helper function for Javascript.

 *

 * @param array $options Set of options

 * @access private

 */

	function __optionsForAjax($options) {

		if (isset($options['indicator'])) {

			if (isset($options['loading'])) {

				$loading = $options['loading'];

				if (!empty($loading) && substr(trim($loading), -1, 1) != ';') {

					$options['loading'] .= '; ';

				}

				$options['loading'] .= "Element.show('{$options['indicator']}');";

			} else {

				$options['loading'] = "Element.show('{$options['indicator']}');";

			}

			if (isset($options['complete'])) {

				$complete = $options['complete'];

				if (!empty($complete) && substr(trim($complete), -1, 1) != ';') {

					$options['complete'] .= '; ';

				}

				$options['complete'] .= "Element.hide('{$options['indicator']}');";

			} else {

				$options['complete'] = "Element.hide('{$options['indicator']}');";

			}

			unset($options['indicator']);

		}

		$jsOptions = array_merge(

			array('asynchronous' => 'true', 'evalScripts'  => 'true'),

			$this->_buildCallbacks($options)

		);

		$options = $this->_optionsToString($options, array(

			'contentType', 'encoding', 'fallback', 'method', 'postBody', 'update', 'url'

		));

		$jsOptions = array_merge($jsOptions, array_intersect_key($options, array_flip(array(

			'contentType', 'encoding', 'method', 'postBody'

		))));

		foreach ($options as $key => $value) {

			switch ($key) {

				case 'type':

					$jsOptions['asynchronous'] = ($value == 'synchronous') ? 'false' : 'true';

				break;

				case 'evalScripts':

					$jsOptions['evalScripts'] = ($value) ? 'true' : 'false';

				break;

				case 'position':

					$pos = Inflector::camelize($options['position']);

					$jsOptions['insertion'] = "Insertion.{$pos}";

				break;

				case 'with':

					$jsOptions['parameters'] = $options['with'];

				break;

				case 'form':

					$jsOptions['parameters'] = 'Form.serialize(this)';

				break;

				case 'requestHeaders':

					$keys = array();

					foreach ($value as $key => $val) {

						$keys[] = "'" . $key . "'";

						$keys[] = "'" . $val . "'";

					}

					$jsOptions['requestHeaders'] = '[' . join(', ', $keys) . ']';

				break;

			}

		}

		return $this->_buildOptions($jsOptions, $this->ajaxOptions);

	}

/**

 * Private Method to return a string of html options

 * option data as a JavaScript options hash.

 *

 * @param array $options	Options in the shape of keys and values

 * @param array $extra	Array of legal keys in this options context

 * @return array Array of html options

 * @access private

 */

	function __getHtmlOptions($options, $extra = array()) {

		foreach (array_merge($this->ajaxOptions, $this->callbacks, $extra) as $key) {

			if (isset($options[$key])) {

				unset($options[$key]);

			}

		}

		return $options;

	}

/**

 * Returns a string of JavaScript with the given option data as a JavaScript options hash.

 *

 * @param array $options	Options in the shape of keys and values

 * @param array $acceptable	Array of legal keys in this options context

 * @return string	String of Javascript array definition

 */

	function _buildOptions($options, $acceptable) {

		if (is_array($options)) {

			$out = array();

			foreach ($options as $k => $v) {

				if (in_array($k, $acceptable)) {

					if ($v === true) {

						$v = 'true';

					} elseif ($v === false) {

						$v = 'false';

					}

					$out[] = "$k:$v";

				} elseif ($k === 'with' && in_array('parameters', $acceptable)) {

					$out[] = "parameters:${v}";

				}

			}

			$out = join(', ', $out);

			$out = '{' . $out . '}';

			return $out;

		} else {

			return false;

		}

	}

/**

 * Return JavaScript text for an observer...

 *

 * @param string $klass Name of JavaScript class

 * @param string $name

 * @param array $options	Ajax options

 * @return string Formatted JavaScript

 */

	function _buildObserver($klass, $name, $options = null) {

		if (!isset($options['with']) && isset($options['update'])) {

			$options['with'] = 'value';

		}

		$callback = $this->remoteFunction($options);

		$hasFrequency = !(!isset($options['frequency']) || intval($options['frequency']) == 0);

    	$frequency = $hasFrequency ? $options['frequency'] . ', ' : '';

		return "new $klass('$name', {$frequency}function(element, value) {{$callback}})";

	}

/**

 * Return Javascript text for callbacks.

 *

 * @param array $options Option array where a callback is specified

 * @return array Options with their callbacks properly set

 * @access protected

 */

	function _buildCallbacks($options) {

		$callbacks = array();

		foreach ($this->callbacks as $callback) {

			if (isset($options[$callback])) {

				$name = 'on' . ucfirst($callback);

				$code = $options[$callback];

				switch ($name) {

					case 'onComplete':

						$callbacks[$name] = "function(request, json) {" . $code . "}";

						break;

					case 'onCreate':

						$callbacks[$name] = "function(request, xhr) {" . $code . "}";

						break;

					case 'onException':

						$callbacks[$name] = "function(request, exception) {" . $code . "}";

						break;

					default:

						$callbacks[$name] = "function(request) {" . $code . "}";

						break;

				}

				if (isset($options['bind'])) {

					$bind = $options['bind'];

					$hasBinding = (

						(is_array($bind) && in_array($callback, $bind)) ||

						(is_string($bind) && strpos($bind, $callback) !== false)

					);

					if ($hasBinding) {

						$callbacks[$name] .= ".bind(this)";

					}

				}

			}

		}

		return $callbacks;

	}

/**

 * Returns a string of JavaScript with a string representation of given options array.

 *

 * @param array $options	Ajax options array

 * @param array $stringOpts	Options as strings in an array

 * @access private

 * @return array

 */

	function _optionsToString($options, $stringOpts = array()) {

		foreach ($stringOpts as $option) {

			$hasOption = (

				isset($options[$option]) && !empty($options[$option]) &&

				is_string($options[$option]) && $options[$option][0] != "'"

			);

			if ($hasOption) {

				if ($options[$option] === true || $options[$option] === 'true') {

					$options[$option] = 'true';

				} elseif ($options[$option] === false || $options[$option] === 'false') {

					$options[$option] = 'false';

				} else {

					$options[$option] = "'{$options[$option]}'";

				}

			}

		}

		return $options;

	}

/**

 * Executed after a view has rendered, used to include bufferred code

 * blocks.

 *

 * @access public

 */

	function afterRender() {

		if (env('HTTP_X_UPDATE') != null && !empty($this->__ajaxBuffer)) {

			@ob_end_clean();

			$data = array();

			$divs = explode(' ', env('HTTP_X_UPDATE'));

			$keys = array_keys($this->__ajaxBuffer);

			if (count($divs) == 1 && in_array($divs[0], $keys)) {

				e($this->__ajaxBuffer[$divs[0]]);

			} else {

				foreach ($this->__ajaxBuffer as $key => $val) {

					if (in_array($key, $divs)) {

						$data[] = $key . ':"' . rawurlencode($val) . '"';

					}

				}

				$out  = 'var __ajaxUpdater__ = {' . join(", \n", $data) . '};' . "\n";

				$out .= 'for (n in __ajaxUpdater__) { if (typeof __ajaxUpdater__[n] == "string"';

				$out .= ' && $(n)) Element.update($(n), unescape(decodeURIComponent(';

				$out .= '__ajaxUpdater__[n]))); }';

				e($this->Javascript->codeBlock($out, false));

			}

			$scripts = $this->Javascript->getCache();

			if (!empty($scripts)) {

				e($this->Javascript->codeBlock($scripts, false));

			}

			$this->_stop();

		}

	}

}

?>