Command-line

The Command-line handler framework is an elaborate framework allowing to take into account the command-line arguments which are managed by the application and each Plugin.

CommandLine listener

The CommandLineListener class is an interface (implemented by the application and each of the Plugins) which handles the command-line arguments:

• The CommandLineListener.getCommandLineConfiguration() method specifies the URL of the arguments XML file which specifies which arguments are managed by the listener
• The CommandLineListener.handleCommandLineArguments(Map, Map) method handle the management of the arguments by the listener. Note that only the arguments which are defined in the XML file and which are present in the command-line will be present
• The CommandLineListener.handleCommandLineException(SAXParseException) method is fired if the command-line configuration file is invalid

Application listener

The AbstractApplication class is a CommandLine listener, but it has several additional methods to manage the arguments:

• The AbstractApplication.setCommandLineArguments(String[]) method allows to set the command-line arguments to the application. This method will internally use the LauncherConf class to set the value of the AbstractApplication.getCommandLineArguments() map
• Alternatively, you can use the AbstractApplication.setCommandLineArguments(String[], boolean) method to specify how you want to handle the dash character at the beginning of each argument ^[1]
  See LauncherConf for more information
• The AbstractApplication.applyCommandLineArguments() method will handle the command-line arguments for both the application and its plugins

Arguments file

The XML file specifying the arguments managed by the listener is returned by the CommandLineListener.getCommandLineConfiguration() method.

For example:

      public class MyMDI extends AbstractMDIApplication {

        public MyMDI(String[] args) {
          super("My MDI");
          ...
        }

        @Override
        public URL getCommandLineConfiguration() {
          return this.getClass().getResource("commandline.xml");
        }

      }

Example

First example: default handling of command-line arguments

The following example shows how an application can handle arguments. In this example, we have the following commandline.xmlarguments file:

      <arguments>
         <argument key="sizeX" type="int" />
         <argument key="sizeY" type="int" />
      </arguments>

And the following code for the application:

      public class MyMDI extends AbstractMDIApplication {
        private int sizeX = 200;
        private int sizeY = 200;

        public MyMDI(String[] args) {
          super("My MDI");
          super.preparePanels();

          // set the command-line arguments
          this.setCommandLineArguments(args);
          // apply the arguments for the application (it will indirectly call the handleCommandLineArguments method)
          super.applyCommandLineArguments();
          // set the size of the Application window
          this.setSize(sizeX, sizeY);
        }

        @Override
        public URL getCommandLineConfiguration() {
          // specify the xml file specifying the arguments
          return this.getClass().getResource("commandline.xml");
        }

        @Override
        public void handleCommandLineArguments(Map<String, ArgumentGroup> argumentGroups, Map<String, Argument> arguments) {
          // handle the arguments
          if (arguments.containsKey("sizeX")) {
            Argument arg = arguments.get("sizeX");
            sizeX = (Integer)arg.getValue();
          }
          if (arguments.containsKey("sizeY")) {
            Argument arg = arguments.get("sizeY");
            sizeY = (Integer)arg.getValue();
          }
      }

        public static void main(String[] args) {
          MyMDI mdi = new MyMDI(args);
          mdi.setVisible(true);
        }
      }

We can for example start the application with:

      java -jar MyMDI.jar -sizeX=800 -sizeY=300

or even with:

      java -jar MyMDI.jar sizeX=800 sizeY 300

First example: keeping dash characters in command-line arguments

In this example, will explicitely specify our arguments with dash characters in the commandline.xmlarguments file:

      <arguments>
         <argument key="-sizeX" type="int" />
         <argument key="-sizeY" type="int" />
      </arguments>

The code for the application will be almost identical to the previous example:

      public class MyMDI extends AbstractMDIApplication {
        private int sizeX = 200;
        private int sizeY = 200;

        public MyMDI(String[] args) {
          super("My MDI");
          super.preparePanels();

          // set the command-line arguments
          this.setCommandLineArguments(args, true);
          // apply the arguments for the application (it will indirectly call the handleCommandLineArguments method)
          super.applyCommandLineArguments();
          // set the size of the Application window
          this.setSize(sizeX, sizeY);
        }

        @Override
        public URL getCommandLineConfiguration() {
          // specify the xml file specifying the arguments
          return this.getClass().getResource("commandline.xml");
        }

        @Override
        public void handleCommandLineArguments(Map<String, ArgumentGroup> argumentGroups, Map<String, Argument> arguments) {
          // handle the arguments
      
             if (arguments.containsKey("-sizeX")) {
               Argument arg = arguments.get("-sizeX");
               sizeX = (Integer)arg.getValue();
             }
             if (arguments.containsKey("-sizeY")) {
               Argument arg = arguments.get("-sizeY");
               sizeY = (Integer)arg.getValue();
             }
      
      }

        public static void main(String[] args) {
          MyMDI mdi = new MyMDI(args);
          mdi.setVisible(true);
        }
      }

We can for example start the application with:

      java -jar MyMDI.jar -sizeX=800 -sizeY=300