API Docs for: undefined
Show:

File: js/async-pause.js

  1. /**
  2.  * @module gallery-async-pause
  3.  */
  4. (function (Y, moduleName) {
  5.     'use strict';
  6.     
  7.     var _string__args = '_args',
  8.         _string__resumed = '_resumed',
  9.         _string_host = 'host',
  10.         _string_paused = 'paused',
  11.         
  12.         _false = false,
  13.         _true = true,
  14.         
  15.         _DoPrevent = Y.Do.Prevent,
  16.         _Plugin = Y.Plugin;

  18.     /**
  19.      * Asynchronous command runner pause plugin.
  20.      * @class AsyncPause
  21.      * @extends Plugin.Base
  22.      * @namespace Plugin
  23.      * @param {Object} config Configuration Object.
  24.      */
  25.     _Plugin.AsyncPause = Y.Base.create(moduleName, _Plugin.Base, [], {
  26.         initializer: function () {
  27.             var me = this;
  28.                 
  29.             if (me.get(_string_host).get('mode') === 'queue') {
  30.                 me.beforeHostMethod('_runQueue', function () {
  31.                     if (me.get(_string_paused)) {
  32.                         me._set(_string__args, arguments);
  33.                         return new _DoPrevent(_string_paused);
  34.                     }

  36.                     return null;
  37.                 });
  38.             }
  39.         },
  40.         /**
  41.          * Pause the run.  Does not stop a command that is currently running,
  42.          * the run will pause before the next command runs.
  43.          * @method pause
  44.          * @chainable
  45.          */
  46.         pause: function () {
  47.             return this._set(_string_paused, _true);
  48.         },
  49.         /**
  50.          * Resumes a paused run.  If a command is currently running, the paused
  51.          * state may not be updated immediately.  Resume does nothing if the run
  52.          * is not paused or not started yet or already complete.
  53.          * @method resume
  54.          * @chainable
  55.          */
  56.         resume: function () {
  57.             var argsChangeListener,
  58.                 completeListener,
  59.                 me = this,
  60.                 
  61.                 args = me.get(_string__args),
  62.                 host = me.get(_string_host),
  63.                 runQueue = host._runQueue,
  64.                 
  65.                 resume = function (args) {
  66.                     me._setAttrs({
  67.                         paused: _false,
  68.                         _args: null,
  69.                         _resumed: _false
  70.                     });
  71.                     runQueue.apply(host, args);
  72.                 };
  73.             
  74.             if (!me.get(_string_paused) || me.get(_string__resumed)) {
  75.                 return me;
  76.             }
  77.             
  78.             if (!host.get('started') || host.get('completed')) {
  79.                 me._set(_string_paused, _false);
  80.                 return me;
  81.             }

  83.             if (args) {
  84.                 resume(args);
  85.                 return me;
  86.             }
  87.             
  88.             me._set(_string__resumed, _true);
  89.             
  90.             argsChangeListener = me.once('_argsChange', function (eventFacade) {
  91.                 completeListener.detach();
  92.                 resume(eventFacade.newVal);
  93.             });
  94.             
  95.             completeListener = host.on('complete', function () {
  96.                 argsChangeListener.detach();
  97.             });
  98.             
  99.             return me;
  100.         }
  101.     }, {
  102.         ATTRS: {
  103.             /**
  104.              * Boolean value indicating the paused status of the run.
  105.              * @attribute paused
  106.              * @default false
  107.              * @readonly
  108.              * @type Boolean
  109.              */
  110.             paused: {
  111.                 readonly: _true,
  112.                 value: _false
  113.             },
  114.             /**
  115.              * Paused _runQueue arguments.
  116.              * @attribute _args
  117.              * @protected
  118.              * @readonly
  119.              * @type Array
  120.              */
  121.             _args: {
  122.                 readOnly: _true,
  123.                 value: null
  124.             },
  125.             /**
  126.              * Boolean value indicating the resumed status of the run.
  127.              * @attribute _resumed
  128.              * @protected
  129.              * @readonly
  130.              * @type Array
  131.              */
  132.             _resumed: {
  133.                 readOnly: _true,
  134.                 value: _false
  135.             }
  136.         },
  137.         NS: 'pause'
  138.     });
  139. }(Y, arguments[1]));
  140.