MeetmeUnmute Action.
@constructor
@see Action(String)
@augments Action
182930
function MeetmeUnmute(meetme, usernum) {
  MeetmeUnmute.super_.call(this, 'MeetmeUnmute');
  this.set('Meetme', meetme);
  this.set('Usernum', usernum);
}
512848
def do_action(self, action, objects):
        
        transitioned = []
        ActionHandlerPool.get_instance().queue_pool()
        for obj in objects:
            obj = api.get_object(obj)
            success, message = do_action_for(obj, action)
            if success:
                transitioned.append(obj)
        ActionHandlerPool.get_instance().resume()
        return transitioned
1296229
function(action, data) {

    if(isUndefined(data)) {
      data = {};
    } else if(!isObject(data) && !isFunction) {
      throw new Error('Data passed to an advisor action must be in instance of Object.');
    }

    var executeAction;
    if(isFunction(data)) {
      executeAction = compose(this._askAdvisor.actions[action], data)
    } else {
      executeAction = partial(this._askAdvisor.actions[action], data);
    }

    this.then(function(advisorEvent, deferred, consequenceActions, streamEvent) {
      data.triggeringEvents = {
        advisor: advisorEvent,
        stream: streamEvent
      };
      if(isFunction(data)) {
        executeAction(advisorEvent, streamEvent);
      } else {
        if(this._waitTime) {
          setTimeout(function(){
            executeAction();
            deferred.resolve();
          }, this._waitTime);
          return;
        } else {
          executeAction();
        }
      }
      deferred.resolve();
    });

    // terminate chain
    return this;
  }
1023141
def execute(action, *args, &block)
      action_name = action.to_s.gsub(/_with(out)?_callback_.*$/, '')
      result = nil
      run_callbacks(action_name) do
        result = send(action, *args, &block)
      end
      result
    end
436100
def action a
      text a.name
      mnemonic a.mnemonic unless a.mnemonic.nil?
      command { a.call }
    end
629821
function(actionName) {
		self[actionName] = function() {
			var args = arguments;
			self._stack.push({action : actionName, args : args});
			return self;
		};
	}
708159
function ActionEase (opts) {
    if (!opts.action) {
        throw "Ease: action argument must be non-nil"
    }
    ActionEase.superclass.constructor.call(this, {duration: opts.action.duration})

    this.other = opts.action
}
593551
function (name, help) {
  var options = {
    optionStrings: [],
    dest: name,
    help: help
  };

  Action.call(this, options);
}
8436
function doaction(type, data) {
		if (gui.hosted) {
			gui.Action.ascendGlobal(document, type, data);
		}
	}
729634
async function action_handler(req, h) {
    const data = req.payload
    const json = 'string' === typeof data ? tu.parseJSON(data) : data
    if (json instanceof Error) {
      throw json
    }

    const seneca = prepare_seneca(req, json)
    const msg = tu.internalize_msg(seneca, json)

    return await new Promise(resolve => {
      var out = null
      for (var i = 0; i < modify_action.length; i++) {
        out = modify_action[i].call(seneca, msg, req)
        if (out) {
          return resolve(out)
        }
      }

      seneca.act(msg, function(err, out, meta) {
        if (err && !options.debug) {
          err.stack = null
        }

        resolve(tu.externalize_reply(this, err, out, meta))
      })
    })
  }
601968
def perform(action, options = {})
      return unless %i[
        backtrace
        down
        finish
        frame
        next
        step
        up
      ].include?(action)

      send("perform_#{action}", options)
    end
355042
function(action, thisp) {
		var res;
		if (this.observes) {
			if (++this._suspend === 1) {
				this._connect(false);
			}
		}
		if (gui.Type.isFunction(action)) {
			res = action.call(thisp);
		}
		if (this.observes) {
			this.resume();
		}
		return res;
	}
37781
function _processActionQueue()
	{	
		if( _actionQueue.length > 0 ) {
			var stateEvent = _actionQueue.shift();
			
			if(!_currentState.getTarget(stateEvent.action)) {
				_processActionQueue();
			} 
			else {
			}	FSM.action( stateEvent.action, stateEvent.data );

			return false;
		}

		FSM.log('State transition Completed! Current State :: ' + _currentState.name );
		stateChanged.dispatch(_currentState);
	}
872505
@Override
    public <V> Future<V> submit(String name, Callable<V> action) {
        ActionEvent<V> event = ActionEvent.create(name, action);
        return sink.add(event, Channel.BROADCAST);
    }
93968
function(a) {
		gui.Spirit.prototype.onaction.call(this, a);
		this.action.$handleownaction = false;
		var base;
		switch (a.type) {
			case gui.ACTION_DOC_ONDOMCONTENT:
				this.contentLocation = new gui.URL(document, a.data);
				this.life.dispatch(gui.LIFE_IFRAME_DOMCONTENT);
				this.action.remove(a.type);
				a.consume();
				break;
			case gui.ACTION_DOC_ONLOAD:
				this.contentLocation = new gui.URL(document, a.data);
				this.life.dispatch(gui.LIFE_IFRAME_ONLOAD);
				this.action.remove(a.type);
				a.consume();
				break;
			case gui.ACTION_DOC_ONHASH:
				base = this.contentLocation.href.split("#")[0];
				this.contentLocation = new gui.URL(document, base + a.data);
				this.life.dispatch(gui.LIFE_IFRAME_ONHASH);
				a.consume();
				break;
			case gui.ACTION_DOC_ONSPIRITUALIZED:
				this._onspiritualized();
				this.life.dispatch(gui.LIFE_IFRAME_SPIRITUALIZED);
				this.action.remove(a.type);
				a.consume();
				break;
			case gui.ACTION_DOC_UNLOAD:
				this._onunload();
				this.life.dispatch(gui.LIFE_IFRAME_UNLOAD);
				this.action.add([
					gui.ACTION_DOC_ONCONSTRUCT,
					gui.ACTION_DOC_ONDOMCONTENT,
					gui.ACTION_DOC_ONLOAD,
					gui.ACTION_DOC_ONSPIRITUALIZED
				]);
				a.consume();
				break;
		}
	}
151567
private void sendSolutionActions(String action, String reqId){
        if(reqId!=null && !reqId.equals("")) {
            Map<String, String> map = Maps.newHashMap();
            map.put("action", action);
            map.put("reqid", reqId);
            this.sendEvent(map);
        }
    }
978615
def init_actions
      am = action_manager()
      am.add_action(Action.new("&Disable selection") { @selection_mode = :none; unbind_key(32); bind_key(32, :scroll_forward); } )
      am.add_action(Action.new("&Edit Toggle") { @edit_toggle = !@edit_toggle; $status_message.value = "Edit toggle is #{@edit_toggle}" })
    end