Sets the current action for this button to the inputed action.
        
        :param      action | <QAction> || <str>
978914
def setCurrentAction(self, action):
        
        self._actionGroup.blockSignals(True)
        for act in self._actionGroup.actions():
            act.setChecked(act == action or act.text() == action)
        self._actionGroup.blockSignals(False)
431541
def _set_data(self, action):
        
        if 'query' in action:
            self._set_query_data(action)
        elif action == 'imageinfo':
            self._set_imageinfo_data()
        elif action == 'parse':
            self._set_parse_data()
        elif action == 'random':
            self._set_random_data()
        elif action == 'labels':
            self._set_labels()
        elif action == 'wikidata':
            self._set_wikidata()
            self.get_labels()
        elif action == 'restbase':
            self._set_restbase_data()

        self._update_imageinfo()
        self._update_params()
51248
def setActions( self, actions ):
        
        self._actions = actions
        
        self.uiActionTREE.blockSignals(True)
        self.uiActionTREE.setUpdatesEnabled(False)
        
        self.uiActionTREE.clear()
        actions = actions.items()
        actions.sort(key = lambda x: nativestring(x[1].text()).replace('&', ''))
        
        for key, action in actions:
            item = self.createActionItem(key)
            self.uiActionTREE.addTopLevelItem(item)
        
        self.uiActionTREE.setUpdatesEnabled(True)
        self.uiActionTREE.blockSignals(False)
273690
def _set_selected_action(self, action):
        """"""
        assert action in self._action_sets

        if self._selected_action is not None:
            raise ValueError("The action has already been selected.")
        self._selected_action = action
798374
def execute_action action, silence=false
      action = action.strip
      if wait_for_prompt
        stdout.puts(action) unless silence
        @prompted = false
        process_runner.puts action
      end
    end
473006
def action=(action)
      if !VALID_ACTIONS.include?(action.to_s.upcase)
        raise ArgumentError, "Action must be one of #{VALID_ACTIONS.join(', ')}"
      end
      @action = action.downcase.to_sym
    end
1152099
def emitTriggered(self, action):
        
        self.currentActionChanged.emit(action)
        self.currentIndexChanged.emit(self.indexOf(action))
        
        if not self.signalsBlocked():
            self.triggered.emit(action)
378772
def skip_action(self, action):
        
        if 'skip' not in self.flags:
            self.flags['skip'] = []
        self.flags['skip'].append(action)
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)
896794
public void setActionSequence (String action)
    {
        // sanity check
        if (action == null) {
            log.warning("Refusing to set null action sequence " + this + ".", new Exception());
            return;
        }

        // no need to noop
        if (action.equals(_action)) {
            return;
        }
        _action = action;
        updateActionFrames();
    }
725877
def performAction(self, action):
        
        self._lastAction = []

        n = self.numOffbids * len(self.generators)

        if self.maxWithhold is not None:
            markups = action[:n]
            withholds = action[n:]
        else:
            markups = action
            withholds = [0.0] * n

        self._offbid(markups, withholds)
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);
        }
    }
365576
def add(self, action):
        """"""
        self._state_machine.transition_to_add()
        self._actions.append(action)
763094
def send_action(action, params=None):
	
	data={"msg_type":"action", "action":action}
	if params is not None:
		data['params']=params
	_comm.send(data)
1352625
def add_event_handler(self, action):
        
        if action.uuid in self.actions:
            logger.info("Already existing event handler: %s", action)
            return

        self.actions[action.uuid] = action
        self.nb_event_handlers += 1
1272299
def _set_data(self, action):
        
        if action == 'labels':
            self._set_labels()

        if action == 'wikidata':
            self._set_wikidata()
            self.get_labels(show=False)
606236
def add_action_to(cls, parser, action, subactions, level):
        
        p = parser.add_parser(action.name,
                              description=action.description,
                              argument_default=argparse.SUPPRESS)
        for arg in action.args:
            arg.add_argument_to(p)

        if subactions:
            subparsers = cls._add_subparsers_required(p,
                dest=settings.SUBASSISTANT_N_STRING.format(level),
                title=cls.subactions_str,
                description=cls.subactions_desc)
            for subact, subsubacts in sorted(subactions.items(), key=lambda x: x[0].name):
                cls.add_action_to(subparsers, subact, subsubacts, level + 1)