Returns the action that is currently checked in the system.
        
        :return     <QAction> || None
338070
def currentAction( self ):
        
        if ( not self._actionGroup ):
            return None
            
        for act in self._actionGroup.actions():
            if ( act.isChecked() ):
                return act
        return None
1131633
def findUiActions( widget ):
    
    import_qt(globals())
    
    output = []
    for action in widget.findChildren(QtGui.QAction):
        name = nativestring(action.objectName()).lower()
        if ( name.startswith('ui') and name.endswith('act') ):
            output.append(action)
    return output
492643
def checkState(self):
        
        if self.data is True:
            return Qt.Checked
        elif self.data is False:
            return Qt.Unchecked
        else:
            raise ValueError("Unexpected data: {!r}".format(self.data))
566297
def checkState(self):
        
        #commonData = self.childItems[0].data if self.childItems else Qt.PartiallyChecked
        commonData = None

        for child in self.childItems:
            if isinstance(child, BoolCti):
                if commonData is not None and child.data != commonData:
                    return Qt.PartiallyChecked
                commonData = child.data

        if commonData is True:
            return Qt.Checked
        elif commonData is False:
            return Qt.Unchecked
        else:
            raise AssertionError("Please report this bug: commonData: {!r}".format(commonData))
1002050
def get_active_state(self) -> Optional[str]:
        """"""
        for state in self.get_run_states():
            if state.active:
                return state.name
        return None
923820
def action_checkbox(self, obj):
        
        if self.check_concurrent_action:
            return helpers.checkbox.render(helpers.ACTION_CHECKBOX_NAME,
                                           force_text("%s,%s" % (obj.pk,
                                                                 get_revision_of_object(obj))))
        else:  # pragma: no cover
            return super(ConcurrencyActionMixin, self).action_checkbox(obj)
195884
def select_action(self, next_action_arr, next_q_arr):
        '''
        
        '''
        key_arr = self.select_action_key(next_action_arr, next_q_arr)
        return next_action_arr[key_arr], next_q_arr[key_arr]
927018
def query( self ):
        
        widget = self.uiWidgetAREA.widget()
        if ( widget and type(widget) != QWidget ):
            value = nativestring(widget.text())
        else:
            value = ''
        
        op = nativestring(self.uiOperatorDDL.currentText())
        if ( self.currentRule() ):
            op = self.currentRule().labelOperator(op)
        
        return (nativestring(self.uiTermDDL.currentText()), op, value)
952755
def get_new_checks(self, queue, return_queue):
        
        try:
            logger.debug("get_new_checks: %s / %s", len(self.checks), self.processes_by_worker)
            while len(self.checks) < self.processes_by_worker:
                msg = queue.get_nowait()
                if msg is None:
                    time.sleep(0.01)
                    continue
                logger.debug("Got a message: %s", msg)
                if msg.get_type() == 'Do':
                    logger.debug("Got an action: %s", msg.get_data())
                    self.checks.append(msg.get_data())
                    self.actions_got += 1
                elif msg.get_type() == 'ping':
                    msg = Message(_type='pong', data='pong!', source=self._id)
                    logger.debug("Queuing message: %s", msg)
                    return_queue.put_nowait(msg)
                    logger.debug("Queued")
                else:
                    logger.warning("Ignoring message of type: %s", msg.get_type())
        except Full:
            logger.warning("Actions queue is full")
        except Empty:
            logger.debug("Actions queue is empty")
            if not self.checks:
                self._idletime += 1
        # Maybe the Queue() has been deleted by our master ?
        except (IOError, EOFError) as exp:
            logger.warning("My actions queue is no more available: %s", str(exp))
            self.interrupted = True
        except Exception as exp:  # pylint: disable=broad-except
            logger.error("Failed getting messages in actions queue: %s", str(exp))

        logger.debug("get_new_checks exit")
660490
def get_check(self, check):
        
        chk = self._check_manager.get(check)
        chk.set_entity(self)
        return chk
1149788
private function checkInput()
    {
        $actions = $this->getAllowedActions();
        $pendingActionName = 'check' . $actions[$this->options['action']].'Input';
        if (method_exists($this, $pendingActionName)) {
            return $this->$pendingActionName();
        }
    }
1184340
def action_is_satisfied(action):
    ''' 
    '''
    num_consumed_args = getattr(action, 'num_consumed_args', 0)

    if action.nargs == ONE_OR_MORE and num_consumed_args < 1:
        return False
    else:
        if action.nargs is None:
            action.nargs = 1
        try:
            return num_consumed_args == action.nargs
        except:
            return True
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);
	}
136409
def getResponseAction(self, ps, action):
        '''
        '''
        opName = self.getOperationName(ps, action)
        if self.wsAction.has_key(opName) is False:
            raise WSActionNotSpecified, 'wsAction dictionary missing key(%s)' %opName
        return self.wsAction[opName]
1158446
def getActionHandle(self, pchActionName):
        """"""

        fn = self.function_table.getActionHandle
        pHandle = VRActionHandle_t()
        result = fn(pchActionName, byref(pHandle))
        return result, pHandle
1193053
public function getAction() : ?string 
    {
        if ( ! $this->hasAction()) {
            $this->setAction($this->getDefaultAction());
        }
        return $this->action;
    }
989935
def update_actions(self):
        
        self.clear()
        self.recent_files_actions[:] = []
        for file in self.manager.get_recent_files():
            action = QtWidgets.QAction(self)
            action.setText(os.path.split(file)[1])
            action.setToolTip(file)
            action.setStatusTip(file)
            action.setData(file)
            action.setIcon(self.icon_provider.icon(QtCore.QFileInfo(file)))
            action.triggered.connect(self._on_action_triggered)
            self.addAction(action)
            self.recent_files_actions.append(action)
        self.addSeparator()
        action_clear = QtWidgets.QAction(_('Clear list'), self)
        action_clear.triggered.connect(self.clear_recent_files)
        if isinstance(self.clear_icon, QtGui.QIcon):
            action_clear.setIcon(self.clear_icon)
        elif self.clear_icon:
            theme = ''
            if len(self.clear_icon) == 2:
                theme, path = self.clear_icon
            else:
                path = self.clear_icon
            icons.icon(theme, path, 'fa.times-circle')
        self.addAction(action_clear)