Triggers all actions meant to trigger on the board state from `source`.
499431
def trigger(self, source):
		
		actions = self.evaluate(source)
		if actions:
			if not hasattr(actions, "__iter__"):
				actions = (actions, )
			source.game.trigger_actions(source, actions)
862470
def setup_actions(self):
        
        self.actionOpen.triggered.connect(self.on_open)
        self.actionNew.triggered.connect(self.on_new)
        self.actionSave.triggered.connect(self.on_save)
        self.actionSave_as.triggered.connect(self.on_save_as)
        self.actionQuit.triggered.connect(QtWidgets.QApplication.instance().quit)
        self.tabWidget.current_changed.connect(
            self.on_current_tab_changed)
        self.actionAbout.triggered.connect(self.on_about)
836405
def setActions(self, actions):
        
        self.clear(autoBuild=False)
        for action in actions:
            self.addAction(action, autoBuild=False)
        self.rebuild()
640954
def trigger_hook(self, __name, *args, **kwargs):
        '''  '''
        return [hook(*args, **kwargs) for hook in self._hooks[__name][:]]
1273504
void releaseTriggers() {

        // look in each trigger list of each type of trigger
        for (int i = 0; i < TriggerDef.NUM_TRIGS; i++) {
            for (int j = 0; j < triggerLists[i].length; j++) {
                triggerLists[i][j].terminate();
            }

            triggerLists[i] = TriggerDef.emptyArray;
        }
    }
69970
def trigger(self, *args, **kwargs):
		
		current = self.name.split('/')
		while current:
			name = '/'.join(current)
			current.pop()
			if name in self.context.handlers:
				self.all_handlers += [(name, h) for h in self.context.handlers[name]] 
				if name == self.name:
					self.handlers += self.context.handlers[name]

		for name, handler in self.all_handlers:
			res = handler(self, *args, **kwargs)
			self.all_executed += 1
			self.all_result.append(res)
			if name == self.name:
				self.executed += 1
				self.result.append(res)
			if self.stopped:
				break

		self.all_handlers = [h for name, h in self.all_handlers]
1146499
def trigger(self, name, *args, **kwargs):
        

        # Relevant middleware is cached so we don't have to rediscover it
        # every time. Fetch the cached value if possible.

        listeners = self._triggers.get(name, [])

        # Execute each piece of middleware
        for listener in listeners:
            result = listener(*args, **kwargs)

            if result == break_trigger:
                return False

        return True
848622
public void execute() {
		if (condition == null) {
			throw new SystemException("Rule cannot be executed as it has no condition");
		}

		if (condition.isTrue()) {
			for (Action action : onTrue) {
				action.execute();
			}
		} else {
			for (Action action : onFalse) {
				action.execute();
			}
		}
	}
690676
private void actionWillProduce()
    {
        if (checker.checkProduction(current))
        {
            startProduction(current);
            state = ProducerState.PRODUCING;
        }
        else
        {
            for (final ProducerListener listener : listeners)
            {
                listener.notifyCanNotProduce(current);
            }
        }
    }
1154081
def trigger_all_callbacks(self, callbacks=None):
        
        return [ret
                for key in self
                for ret in self.trigger_callbacks(key, callbacks=None)]
761715
def trigger_step(step, input, output, output_by_tag)
      arguments = step['arguments'] || {}

      # TODO: Move to a normal object: TriggerArgument
      step['arguments'] = transform_arguments(arguments, output, input)
      step['arguments'] = add_config_argument(arguments)

      # TODO: Move to a normal object: TriggerArgument
      output = plugin_manager.action_from_step(step)
      output_by_tag[step['tag']] = output if step.key? 'tag'

      output.merge(output_by_tag)
    end
636157
def trigger(trigger, input)
      # TODO: Change by: Configuration.not_empty_key?
      # TODO: Move to this class: Flow.trigger?
      unless @config.flow_trigger?(trigger)
        raise FlowTriggerNotFound, "Unable to trigger: #{trigger}"
      end

      # TODO: Move in a normal object tree: Flow > Trigger > Action
      output_by_tag = {}
      output = {}
      @config['flow'][trigger.to_s].each do |step|
        output = trigger_step(step, input, output, output_by_tag)
      end
    end
1269975
def trigger(self, *args, **kwargs):
        """"""
        for h in self.handlers:
            h(*args, **kwargs)
1009965
def trigger(action_class, *args)
      if uses_concurrency_control
        trigger_with_concurrency_control(action_class, *args)
      else
        world.trigger { world.plan_with_options(action_class: action_class, args: args, caller_action: self) }
      end
    end
1235164
async def trigger(self, action: str, args: typing.Iterable):
        
        for app in self.applications:
            await app.trigger(action, args)
302715
void fireUpdated(Object source) {
		if (updateDisable) {
			return;
		}
		
		if (source == maxSpinner) {
			if (getMax() < getMin()) {
				setMin(getMax());
			}
		}
		if (source == minSpinner) {
			if (getMax() < getMin()) {
				setMax(getMin());
			}
		}
		
		for (int i=0;i<listeners.size();i++) {
			((InputPanelListener) listeners.get(i)).minMaxUpdated(this);
		}
	}
599901
def trigger(proxy_action_name, input)
      response = begin
                   proxy.trigger_task(proxy_action_name, input).merge('result' => 'success')
                 rescue RestClient::Exception => e
                   logger.warn "Could not trigger task on the smart proxy: #{e.message}"
                   {}
                 end
      update_from_batch_trigger(response)
      save!
    end