Do some applet-wide action.
For example, submit or reset. Pass this action down to all the JBaseScreens.
Remember to override this method to send the actual data!
@param iOptions Extra command options
320223
public boolean doAction(String strAction, int iOptions)
    {
        if (Constants.BACK.equalsIgnoreCase(strAction))
        {
            String strPrevAction = this.popHistory(1, false);   // Current screen
            strAction = this.popHistory(1, false);   // Last screen
            if (strAction != null)		// I don't back up into the browser history if the user hit the java back button.
            {	// If that wasn't the first screen, redo pop and update the browser this time
            	this.pushHistory(strAction, false);
            	strAction = this.popHistory(1, true);
            }
            if (strAction != null)
            {
            	iOptions = iOptions | Constants.DONT_PUSH_TO_BROWSER;	// Don't push the back command
                if (!Constants.BACK.equalsIgnoreCase(strAction)) // Never (prevent endless recursion)
                    return this.doAction(strAction, iOptions);
            }
            else if (strPrevAction != null)
                this.pushHistory(strPrevAction, false);    // If top of stack, leave it alone.
        }
        if (Constants.HELP.equalsIgnoreCase(strAction))
        {
            String strPrevAction = this.popHistory(1, true);   // Current screen
            this.pushHistory(strPrevAction, ((iOptions & Constants.DONT_PUSH_TO_BROWSER) == Constants.PUSH_TO_BROWSER));    // If top of stack, leave it alone.
            if ((strPrevAction != null)
                && (strPrevAction.length() > 0)
                && (strPrevAction.charAt(0) != '?'))
                    strPrevAction = "?" + strPrevAction;
            String strURL = Util.addURLParam(strPrevAction, Params.HELP, Constants.BLANK);
            iOptions = this.getHelpPageOptions(iOptions);
            return this.getApplication().showTheDocument(strURL, this, iOptions);
        }
        if (strAction != null)
            if (strAction.indexOf('=') != -1)
        {
            Map<String,Object> properties = new Hashtable<String,Object>();
            Util.parseArgs(properties, strAction);
            String strApplet = (String)properties.get(Params.APPLET);
            if (strApplet != null)
            {
                this.setProperties(properties);
                if (!this.addSubPanels(null, iOptions))
                	return false;	// If error, return false
                this.popHistory(1, false);      // Pop the default command, the action command is better.
                this.pushHistory(UrlUtil.propertiesToUrl(properties), false);    // Since it was pushed to the browser on addSubPanels
                return true;	// Command handled
            }
        }
        if (Util.isURL(strAction))
            this.getApplication().showTheDocument(strAction, this, ThinMenuConstants.EXTERNAL_LINK);
        return false;
    }
194435
public void activateOptions() {
    if (!isActive()) {
      try {
        remoteInfo = topicFactoryName + ":" + topicName;

        Context ctx = null;
        if (jndiPath == null || jndiPath.equals("")) {
                ctx = new InitialContext();
        } else {
                FileInputStream is = new FileInputStream(jndiPath);
                Properties p = new Properties();
                p.load(is);
                is.close();
                ctx = new InitialContext(p);
        }

        // give some more flexibility about the choice of a tab name
        providerUrl = (String)ctx.getEnvironment().get(Context.PROVIDER_URL);
        TopicConnectionFactory topicConnectionFactory;
        topicConnectionFactory = 
          (TopicConnectionFactory) lookup(ctx, topicFactoryName);
        
        if (userId != null && password != null) {
          topicConnection =
    	       topicConnectionFactory.createTopicConnection(userId, password);
        } else {
          topicConnection =
    	       topicConnectionFactory.createTopicConnection();
        }
  	       
        TopicSession topicSession =
          topicConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
  
        Topic topic = (Topic)ctx.lookup(topicName);
  
        TopicSubscriber topicSubscriber = topicSession.createSubscriber(topic);
      
        topicSubscriber.setMessageListener(this);
 
        topicConnection.start();
 
        setActive(true);
      } catch(Exception e) {
        setActive(false);
        if (topicConnection != null) {
          try {
            topicConnection.close();
          } catch (Exception e2) {
            // do nothing
          }
          topicConnection = null;
        }
        getLogger().error("Could not start JMSReceiver.", e);
      }
    }
  }
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)
66620
public void setActionStates(java.util.Collection<ActionState> actionStates) {
        if (actionStates == null) {
            this.actionStates = null;
            return;
        }

        this.actionStates = new java.util.ArrayList<ActionState>(actionStates);
    }
1227067
public void modifyOptions(Map<String, Object> options) throws ProvisioningApiException {
        try {

            OptionsPostResponseStatusSuccess resp = optionsApi.optionsPost(new OptionsPost().data(new OptionsPostData().options(options)));

            if (!resp.getStatus().getCode().equals(0)) {
                throw new ProvisioningApiException("Error modifying options. Code: " + resp.getStatus().getCode());
            }

        } catch (ApiException e) {
            throw new ProvisioningApiException("Error modifying options", e);
        }
    }
645314
function(options) {
      inputEx.Field.superclass.setOptions.call(this, options);
      
      this.options.wirable = lang.isUndefined(options.wirable) ? false : options.wirable;
      this.options.container = options.container;
      options.container = null;
   }
1069704
public void process(Map<String, String> options) {
        Log.info("Initializing Commands...");
        for (Map.Entry<String, String> entry : options.entrySet()) {
            AbstractCommand command = PreConfigurationContext.getCommandByName(entry.getKey());
            if (null != command) {
                command.setCommands(options);
                try {
                    command.init();
                } catch (InitializationException e) {
                    Log.error("There is a problem in the option you configured: ", entry.getKey(),
                            ErrorGuide.getGuide(ErrorGuide.OPTION_ERROR));
                }
                command.execute();
                command.stop();
            }
            Log.info(entry.getKey() + " Command Initialized.");
        }
    }
571809
public static void bindActionListeners(IActionTarget target, List<ActionListener> actionListeners) {
        if (actionListeners != null) {
            for (ActionListener actionListener : actionListeners) {
                actionListener.bind(target);
            }
        }
    }
1240324
public
  void activateOptions() {
      if (header) {
        getLocalHostname();
      }
      if (layout != null && layout.getHeader() != null) {
          sendLayoutMessage(layout.getHeader());
      }
      layoutHeaderChecked = true;
  }
716999
public void setOptions(com.google.api.ads.admanager.axis.v201808.CustomFieldOption[] options) {
        this.options = options;
    }
916565
public void setActions(java.util.Collection<String> actions) {
        if (actions == null) {
            this.actions = null;
            return;
        }

        this.actions = new java.util.ArrayList<String>(actions);
    }
780062
protected void handleOptions(HttpServletRequest request,
                              HttpServletResponse response)
        throws IOException
    {
        // Handle OPTIONS request for entire server
        if ("*".equals(request.getRequestURI()))
        {
            // 9.2
            response.setIntHeader(HttpFields.__ContentLength,0);
            response.setHeader(HttpFields.__Allow,__AllowString);                
            response.flushBuffer();
        }
        else
            response.sendError(HttpResponse.__404_Not_Found);
    }
1142934
function (options) {
			
			inputEx.SelectTwiceField.superclass.setOptions.call(this, options);
			
			this.options.choices = lang.isArray(options.choices) ? options.choices : [];
			
			this.options.valueSeparator = options.valueSeparator || "_";
			
		}
1138067
@SuppressWarnings("static-access")
	private static void initOptions() {

		List<String> actions = new ArrayList<>(KNOWN_ACTIONS.keySet());
		Collections.sort(actions);
		Option action = OptionBuilder
				.hasArg()
				.withArgName("action")
				.withDescription(
						"define the action that should be performed; avaible actions: "
								+ actions).withLongOpt(OPTION_ACTION)
				.create(CMD_OPTION_ACTION);

		Option destination = OptionBuilder.withArgName("path").hasArg()
				.withDescription("place the output into the file at <path>")
				.withLongOpt(OPTION_OUTPUT_DESTINATION)
				.create(CMD_OPTION_OUTPUT_DESTINATION);

		Option dumplocation = OptionBuilder
				.hasArg()
				.withArgName("path")
				.withDescription(
						"set the directory where downloaded dump files are stored")
				.withLongOpt(OPTION_DUMP_LOCATION)
				.create(CMD_OPTION_DUMP_LOCATION);

		Option config = OptionBuilder
				.hasArg()
				.withArgName("file")
				.withDescription(
						"set a config file; use this to define multiple actions for a single run")
				.withLongOpt(OPTION_CONFIG_FILE).create(CMD_OPTION_CONFIG_FILE);

		Option rdfdump = OptionBuilder
				.hasArgs()
				.withArgName("task")
				.withDescription(
						"specify which data to include in RDF dump (use with action \"rdf\"); run with options \"-a rdf -n\" for help")
				.withLongOpt(OPTION_OUTPUT_RDF_TYPE).create();

		Option filterLanguages = OptionBuilder
				.hasArgs()
				.withArgName("languages")
				.withDescription(
						"specifies a list of language codes; if given, only terms in languages in this list will be processed; the value \"-\" denotes the empty list (no terms are processed)")
				.withLongOpt(OPTION_FILTER_LANGUAGES).create();

		Option filterSites = OptionBuilder
				.hasArgs()
				.withArgName("sites")
				.withDescription(
						"specifies a list of site keys; if given, only site links to sites in this list will be processed; the value \"-\" denotes the empty list (no site links are processed)")
				.withLongOpt(OPTION_FILTER_SITES).create();

		Option filterProperties = OptionBuilder
				.hasArgs()
				.withArgName("ids")
				.withDescription(
						"specifies a list of property ids; if given, only statements for properties in this list will be processed; the value \"-\" denotes the empty list (no statements are processed)")
				.withLongOpt(OPTION_FILTER_PROPERTIES).create();

		Option compressionExtention = OptionBuilder
				.hasArg()
				.withArgName("type")
				.withDescription(
						"define a compression format to be used for the output; possible values: "
								+ DumpProcessingOutputAction.COMPRESS_GZIP
								+ ", "
								+ DumpProcessingOutputAction.COMPRESS_BZ2)
				.withLongOpt(OPTION_OUTPUT_COMPRESSION)
				.create(CMD_OPTION_OUTPUT_COMPRESSION);

		Option report = OptionBuilder
				.hasArg()
				.withArgName("path")
				.withDescription(
						"specifies a path to print a final report after dump generations")
				.withLongOpt(OPTION_CREATE_REPORT)
				.create(CMD_OPTION_CREATE_REPORT);

		Option localDump = OptionBuilder
				.hasArg()
				.withArgName("path")
				.withDescription(
						"select a dump file for processing; if omitted, then the latest dump from Wikidata will be used (and possibly downloaded)")
				.withLongOpt(OPTION_LOCAL_DUMPFILE)
				.create(CMD_OPTION_LOCAL_DUMPFILE);

		options.addOption(config);
		options.addOption(action);
		options.addOption(
				CMD_OPTION_QUIET,
				OPTION_QUIET,
				false,
				"perform all actions quietly, without printing status messages to the console; errors/warnings are still printed to stderr");
		options.addOption(destination);
		options.addOption(dumplocation);
		options.addOption(filterLanguages);
		options.addOption(filterSites);
		options.addOption(filterProperties);
		options.addOption(compressionExtention);
		options.addOption(report);
		options.addOption(localDump);
		options.addOption(rdfdump);
		options.addOption(CMD_OPTION_OFFLINE_MODE, OPTION_OFFLINE_MODE, false,
				"execute all operations in offline mode, especially do not download new dumps");
		options.addOption(CMD_OPTION_HELP, OPTION_HELP, false,
				"print this message");

		options.addOption(CMD_OPTION_OUTPUT_STDOUT, OPTION_OUTPUT_STDOUT,
				false, "write output to stdout");
	}
497961
@Override
    public void setOptions(@Nonnull Map<String, String> options){
        insertFirst = Boolean.parseBoolean(options.get("insertFirst"));
    }
36556
public void setOptions(java.util.Collection<Option> options) {
        if (options == null) {
            this.options = null;
            return;
        }

        this.options = new com.amazonaws.internal.SdkInternalList<Option>(options);
    }
1346383
public void submit() throws IOException, InterruptedException,
                              ClassNotFoundException {
    ensureState(JobState.DEFINE);
    setUseNewAPI();
    info = jobClient.submitJobInternal(conf);
    state = JobState.RUNNING;
   }