Subversion Repositories SmartDukaan

<?php
/**
 * jQuery Engine Helper for JsHelper
 *
 * Provides jQuery specific JavaScript for JsHelper.
 *
 * Implements the JsHelper interface for jQuery. All $options arrays
 * support all options found in the JsHelper, as well as those in the jQuery
 * documentation.
 *
 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 * @link          http://cakephp.org CakePHP(tm) Project
 * @package       Cake.View.Helper
 * @since         CakePHP(tm) v 1.3
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */

App::uses('AppHelper', 'View/Helper');
App::uses('JsBaseEngineHelper', 'View/Helper');

/**
 * jQuery Engine Helper for JsHelper
 *
 * Provides jQuery specific JavaScript for JsHelper.
 *
 * Implements the JsHelper interface for jQuery. All $options arrays
 * support all options found in the JsHelper, as well as those in the jQuery
 * documentation.
 *
 * @package       Cake.View.Helper
 */
class JqueryEngineHelper extends JsBaseEngineHelper {

/**
 * Option mappings for jQuery
 *
 * @var array
 */
        protected $_optionMap = array(
                'request' => array(
                        'type' => 'dataType',
                        'before' => 'beforeSend',
                        'method' => 'type',
                ),
                'sortable' => array(
                        'complete' => 'stop',
                ),
                'drag' => array(
                        'snapGrid' => 'grid',
                        'container' => 'containment',
                ),
                'drop' => array(
                        'leave' => 'out',
                        'hover' => 'over'
                ),
                'slider' => array(
                        'complete' => 'stop',
                        'direction' => 'orientation'
                )
        );

/**
 * Callback arguments lists
 *
 * @var string
 */
        protected $_callbackArguments = array(
                'slider' => array(
                        'start' => 'event, ui',
                        'slide' => 'event, ui',
                        'change' => 'event, ui',
                        'stop' => 'event, ui'
                ),
                'sortable' => array(
                        'start' => 'event, ui',
                        'sort' => 'event, ui',
                        'change' => 'event, ui',
                        'beforeStop' => 'event, ui',
                        'stop' => 'event, ui',
                        'update' => 'event, ui',
                        'receive' => 'event, ui',
                        'remove' => 'event, ui',
                        'over' => 'event, ui',
                        'out' => 'event, ui',
                        'activate' => 'event, ui',
                        'deactivate' => 'event, ui'
                ),
                'drag' => array(
                        'start' => 'event, ui',
                        'drag' => 'event, ui',
                        'stop' => 'event, ui',
                ),
                'drop' => array(
                        'activate' => 'event, ui',
                        'deactivate' => 'event, ui',
                        'over' => 'event, ui',
                        'out' => 'event, ui',
                        'drop' => 'event, ui'
                ),
                'request' => array(
                        'beforeSend' => 'XMLHttpRequest',
                        'error' => 'XMLHttpRequest, textStatus, errorThrown',
                        'success' => 'data, textStatus',
                        'complete' => 'XMLHttpRequest, textStatus',
                        'xhr' => ''
                )
        );

/**
 * The variable name of the jQuery Object, useful
 * when jQuery is put into noConflict() mode.
 *
 * @var string
 */
        public $jQueryObject = '$';

/**
 * Helper function to wrap repetitive simple method templating.
 *
 * @param string $method The method name being generated.
 * @param string $template The method template
 * @param array $options Array of options for method
 * @param array $extraSafeKeys Extra safe keys
 * @return string Composed method string
 */
        protected function _methodTemplate($method, $template, $options, $extraSafeKeys = array()) {
                $options = $this->_mapOptions($method, $options);
                $options = $this->_prepareCallbacks($method, $options);
                $callbacks = array_keys($this->_callbackArguments[$method]);
                if (!empty($extraSafeKeys)) {
                        $callbacks = array_merge($callbacks, $extraSafeKeys);
                }
                $options = $this->_parseOptions($options, $callbacks);
                return sprintf($template, $this->selection, $options);
        }

/**
 * Create javascript selector for a CSS rule
 *
 * @param string $selector The selector that is targeted
 * @return $this
 */
        public function get($selector) {
                if ($selector === 'window' || $selector === 'document') {
                        $this->selection = $this->jQueryObject . '(' . $selector . ')';
                } else {
                        $this->selection = $this->jQueryObject . '("' . $selector . '")';
                }
                return $this;
        }

/**
 * Add an event to the script cache. Operates on the currently selected elements.
 *
 * ### Options
 *
 * - 'wrap' - Whether you want the callback wrapped in an anonymous function. (defaults true)
 * - 'stop' - Whether you want the event to stopped. (defaults true)
 *
 * @param string $type Type of event to bind to the current dom id
 * @param string $callback The JavaScript function you wish to trigger or the function literal
 * @param array $options Options for the event.
 * @return string completed event handler
 */
        public function event($type, $callback, $options = array()) {
                $defaults = array('wrap' => true, 'stop' => true);
                $options += $defaults;

                $function = 'function (event) {%s}';
                if ($options['wrap'] && $options['stop']) {
                        $callback .= "\nreturn false;";
                }
                if ($options['wrap']) {
                        $callback = sprintf($function, $callback);
                }
                return sprintf('%s.bind("%s", %s);', $this->selection, $type, $callback);
        }

/**
 * Create a domReady event. For jQuery. This method does not
 * bind a 'traditional event' as `$(document).bind('ready', fn)`
 * Works in an entirely different fashion than  `$(document).ready()`
 * The first will not run the function when eval()'d as part of a response
 * The second will. Because of the way that ajax pagination is done
 * `$().ready()` is used.
 *
 * @param string $functionBody The code to run on domReady
 * @return string completed domReady method
 */
        public function domReady($functionBody) {
                return $this->jQueryObject . '(document).ready(function () {' . $functionBody . '});';
        }

/**
 * Create an iteration over the current selection result.
 *
 * @param string $callback The function body you wish to apply during the iteration.
 * @return string completed iteration
 */
        public function each($callback) {
                return $this->selection . '.each(function () {' . $callback . '});';
        }

/**
 * Trigger an Effect.
 *
 * @param string $name The name of the effect to trigger.
 * @param array $options Array of options for the effect.
 * @return string completed string with effect.
 * @see JsBaseEngineHelper::effect()
 */
        public function effect($name, $options = array()) {
                $speed = null;
                if (isset($options['speed']) && in_array($options['speed'], array('fast', 'slow'))) {
                        $speed = $this->value($options['speed']);
                }
                $effect = '';
                switch ($name) {
                        case 'slideIn':
                        case 'slideOut':
                                $name = ($name === 'slideIn') ? 'slideDown' : 'slideUp';
                        case 'hide':
                        case 'show':
                        case 'fadeIn':
                        case 'fadeOut':
                        case 'slideDown':
                        case 'slideUp':
                                $effect = ".$name($speed);";
                                break;
                }
                return $this->selection . $effect;
        }

/**
 * Create an $.ajax() call.
 *
 * If the 'update' key is set, success callback will be overridden.
 *
 * @param string|array $url URL
 * @param array $options See JsHelper::request() for options.
 * @return string The completed ajax call.
 * @see JsBaseEngineHelper::request() for options list.
 */
        public function request($url, $options = array()) {
                $url = html_entity_decode($this->url($url), ENT_COMPAT, Configure::read('App.encoding'));
                $options = $this->_mapOptions('request', $options);
                if (isset($options['data']) && is_array($options['data'])) {
                        $options['data'] = $this->_toQuerystring($options['data']);
                }
                $options['url'] = $url;
                if (isset($options['update'])) {
                        $wrapCallbacks = isset($options['wrapCallbacks']) ? $options['wrapCallbacks'] : true;
                        $success = '';
                        if (isset($options['success']) && !empty($options['success'])) {
                                $success .= $options['success'];
                        }
                        $success .= $this->jQueryObject . '("' . $options['update'] . '").html(data);';
                        if (!$wrapCallbacks) {
                                $success = 'function (data, textStatus) {' . $success . '}';
                        }
                        $options['dataType'] = 'html';
                        $options['success'] = $success;
                        unset($options['update']);
                }
                $callbacks = array('success', 'error', 'beforeSend', 'complete', 'xhr');
                if (!empty($options['dataExpression'])) {
                        $callbacks[] = 'data';
                        unset($options['dataExpression']);
                }
                $options = $this->_prepareCallbacks('request', $options);
                $options = $this->_parseOptions($options, $callbacks);
                return $this->jQueryObject . '.ajax({' . $options . '});';
        }

/**
 * Create a sortable element.
 *
 * Requires both Ui.Core and Ui.Sortables to be loaded.
 *
 * @param array $options Array of options for the sortable.
 * @return string Completed sortable script.
 * @see JsBaseEngineHelper::sortable() for options list.
 */
        public function sortable($options = array()) {
                $template = '%s.sortable({%s});';
                return $this->_methodTemplate('sortable', $template, $options);
        }

/**
 * Create a Draggable element
 *
 * Requires both Ui.Core and Ui.Draggable to be loaded.
 *
 * @param array $options Array of options for the draggable element.
 * @return string Completed Draggable script.
 * @see JsBaseEngineHelper::drag() for options list.
 */
        public function drag($options = array()) {
                $template = '%s.draggable({%s});';
                return $this->_methodTemplate('drag', $template, $options);
        }

/**
 * Create a Droppable element
 *
 * Requires both Ui.Core and Ui.Droppable to be loaded.
 *
 * @param array $options Array of options for the droppable element.
 * @return string Completed Droppable script.
 * @see JsBaseEngineHelper::drop() for options list.
 */
        public function drop($options = array()) {
                $template = '%s.droppable({%s});';
                return $this->_methodTemplate('drop', $template, $options);
        }

/**
 * Create a Slider element
 *
 * Requires both Ui.Core and Ui.Slider to be loaded.
 *
 * @param array $options Array of options for the droppable element.
 * @return string Completed Slider script.
 * @see JsBaseEngineHelper::slider() for options list.
 */
        public function slider($options = array()) {
                $callbacks = array('start', 'change', 'slide', 'stop');
                $template = '%s.slider({%s});';
                return $this->_methodTemplate('slider', $template, $options, $callbacks);
        }

/**
 * Serialize a form attached to $selector. If the current selection is not an input or
 * form, errors will be created in the JavaScript.
 *
 * @param array $options Options for the serialization
 * @return string completed form serialization script.
 * @see JsBaseEngineHelper::serializeForm() for option list.
 */
        public function serializeForm($options = array()) {
                $options += array('isForm' => false, 'inline' => false);
                $selector = $this->selection;
                if (!$options['isForm']) {
                        $selector = $this->selection . '.closest("form")';
                }
                $method = '.serialize()';
                if (!$options['inline']) {
                        $method .= ';';
                }
                return $selector . $method;
        }

}