package atlantis;
 
 import java.awt.Rectangle;
 import java.awt.Toolkit;
 import java.io.File;
 import java.io.InputStream;
 
 import javax.swing.UIManager;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 
 import org.w3c.dom.Node;
 import org.apache.commons.cli.Option;
 import org.apache.commons.cli.OptionBuilder;
 import org.apache.commons.cli.OptionGroup;
 import org.apache.commons.cli.Options;
 import org.apache.commons.cli.HelpFormatter;
 import org.apache.commons.cli.CommandLine;
 import org.apache.commons.cli.CommandLineParser;
 import org.apache.commons.cli.GnuParser;
 import org.apache.commons.cli.ParseException;
 
 import atlantis.canvas.ACanvas;
 import atlantis.config.ADefaultValues;
 import atlantis.config.AConfigUpdater;
 import atlantis.event.AEventManager;
 import atlantis.event.AEventSource.InvalidEventSourceException;
 import atlantis.event.AEventSource.NoMoreEventsException;
 import atlantis.event.AEventSource.ReadEventException;
 import atlantis.event.AEventSourceException;
 import atlantis.geometry.AAtlasDetector;
 import atlantis.geometry.ADetectorSystem;
 import atlantis.gui.AColorMap;
 import atlantis.gui.ADemoDialog;
 import atlantis.gui.AEventQueue;
 import atlantis.gui.AExceptionHandler;
 import atlantis.gui.AGUI;
 import atlantis.gui.ACursorFactory;
 import atlantis.gui.AStartupWindow;
 import atlantis.gui.AReadEventFromServerDialog;
 import atlantis.list.AListManager;
 import atlantis.parameters.APar;
 import atlantis.projection.AProjectionsManager;
 import atlantis.utils.AAtlantisException;
 import atlantis.utils.AUtilities;
 import atlantis.utils.AMath;
 import atlantis.utils.xml.AXMLErrorHandler;
 import atlantis.utils.xml.AXMLUtils;
 import atlantis.event.AEventHistory;
 import atlantis.utils.ALogger;
 import javax.swing.JOptionPane;
 
 
 
 public class Atlantis
 {    
     // the attribute gets initialized after command line options
     // are processed. all other classes will just do 
     // logger = ALogger.getLogger(Class.class) in their attribute definitions
     private static ALogger logger = null;
 
     // expands into CVS tag
     public static String versionAtlantisJava = "$Name: AtlantisJava-09-11-11 $";
 
     public static final String fileSep = System.getProperty("file.separator");
     public static final String lineSep = System.getProperty("line.separator");
     public static final String userHome = System.getProperty("user.home");
 
     // flag for displaying HLTAutoKey data
     public static boolean SHOW_HLTAUTOKEY = false;
     // limit the total width of Atlantis to this number of pixels (0 = screen width)
     public static int MAX_WIDTH = 0;
     
     public static boolean inDemo = false;
 
     // main Atlantis components
     // static final declaration ensures these objects are always there
     private static final AEventManager eventManager = new AEventManager();
     private static final ACursorFactory cursors = new ACursorFactory();
 
     private static ADetectorSystem detector;
     private static ACanvas canvas;
     private static AGUI gui;
 
     private static final String JDK_VERSION_ERROR_MSG =
         "Atlantis requires Java (JDK or JRE) version 1.5 or newer.\n" +
         "Please visit: http://java.sun.com/j2se/1.5/ and download Java 1.5";
     
     private static final String INIT_ERROR_MSG = 
         "Error during Atlantis initialization.\n" +
         "(configuration file related issues might be\n" +
         "corrected by running with -x (updating customised configuration)).\n" +
         "See console output for more information.";
 
     public static final String LIVE_POINT_1_EVENTS_URL =
         "http://pcatdwww.cern.ch/atlas-point1/EventDisplayFiles";
 
     // force Atlantis to update the personal configuration file
     private static boolean updateConfig = false;
     // configuration file specified as command line argument
     private static String configCommandLine = null;
     // colormap file specified as command line argument
     private static String colormapCommandLine = null;
     // server name specified as command line argument for reading event remotely
     private static String serverName = null;
     // server port specified as command line argument for reading event remotely
     private static Integer serverPort = 48965;
     // archive name specified as command line argument for looping
     private static String archiveName = null;
     // access order when using -l to loop through an archive
     private static boolean accessOrder = ADemoDialog.SEQUENTIAL;
     // demo mode when using -l to loop through an archive
     private static boolean demoMode = ADemoDialog.SINGLE_WINDOW_MODE;
     // selected projections specified as command line argument for looping
     private static String selectedProjections = null;
     // timer delay for reading events from server automatically
     private static Integer loopInterval = null;
     // default event file specified from command line
     private static String defaultEventFile = null;
     // Object for saving event history in a directory
     private static AEventHistory eventHistory = null;
     
     public static final boolean atlantisWithOpenGL = false;
 
     
     /**
      * Returns the name of the server specified as a command line option or null
      * @return the server name
      */
     private static String getServerName()
     {
         return serverName;
     }  
    
     /**
      * Returns the port number of the server specified as a command line option or null
      * @return the port number of the server
      */
     private static Integer getServerPort()
     {
         return serverPort;
     }
   
     /**
      * Returns the delay for timer for automatic event reading from server
      * when this option was specified as command line argument 
      * @return the delay in seconds
      */
     private static Integer getLoopInterval()
     {
         return loopInterval;
     }
  
     /**
      * Return the eventHistory object, which saves raw event data, images and
      * thumbnails into files, keeping a maximum number of files
      * @return the AEventHistoryObject
      */
     public static AEventHistory getEventHistory() {
       return eventHistory;
     }
  
  
     /**
      * Checks the version of user's Java Runtime Environment
      */
     private static void checkJDKVersion()
     {
         try
         {
             UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
         }
         catch(Exception e)
         {
             AExceptionHandler.processException("Error During Setting Look and Feel", e);
         }
 
         String version = System.getProperty("java.version");
         if(version == null || version.compareTo("1.5") < 0)
         {
             AExceptionHandler.processException("fatal", JDK_VERSION_ERROR_MSG);
         }
 
     } // checkJDKVersion() --------------------------------------------------
 
 
     private static void updateStartupWindow(AStartupWindow win, String msg)
     {
         win.updateText(msg);
         
     } // updateStartupWindow() ----------------------------------------------
 
 
     
     private static void initAtlantis() {
     AStartupWindow startupWin = null;
 
     try {
       // replace event queue by AEventQueue ---------------------------
       System.setProperty("sun.awt.exception.handler",
               "AAWTExceptionHandler");
       Toolkit.getDefaultToolkit().getSystemEventQueue().push(new AEventQueue());
 
       startupWin = AStartupWindow.getInstance();
       updateStartupWindow(startupWin, "Atlantis initialisation");
 
       logger.info("Atlantis home: " + Atlantis.getHomeDirectory());
 
       // reading Atlantis runtime configuration
       logger.info("Reading Atlantis runtime configuration");
       ADefaultValues.readRuntimeValues();
 
       // read the configuration xml files -------------------------
       updateStartupWindow(startupWin, "Reading Atlantis configuration");
       logger.info("Reading the configuration...");
       // configuration file from the Atlantis distributon
       String fileNameDist = getHomeDirectory() + "configuration" +
               fileSep + "config.xml";
       String fileNameUser = userHome + fileSep + ".Atlantis-config.xml";
       // this is checksum of the distribution's configuration file
       // if it doesn't match, Atlantis tries to update user's configuration
       String fileNameChk = userHome + fileSep + ".Atlantis-config.chk";
 
       // check if the checksum file (.chk) is up-to-date,
       // create one if not exist or not is not up-to-date
       if ((new File(fileNameChk).exists() &&
               !AConfigUpdater.compareChecksums(fileNameDist, fileNameChk)) ||
               !new File(fileNameChk).exists()) {
         AConfigUpdater.createChecksumFile(fileNameDist, fileNameChk);
         Atlantis.updateConfig = true;
         logger.info("Updating customised configuration forced.");
       }
 
       // if configuration file is specified as command line argument
       // take it rather than configuration in user's home directory
 
       if (Atlantis.configCommandLine != null) {
         logger.info("Configuration file specified on command line: " +
                 Atlantis.configCommandLine);
         fileNameUser = Atlantis.configCommandLine;
       }
 
       //check if we can read the user configuration file
       InputStream isConfig = null; // configuration file input stream
 
       try {
         logger.info("Using configuration file: " + fileNameUser);
         if (Atlantis.updateConfig) {
           updateStartupWindow(startupWin, "Updating user's configuration");
           logger.info("Updating user's customised configuration file ...");
           AConfigUpdater.updateConfigurationFile(fileNameDist, fileNameUser);
         } else {
           logger.info("User's configuration file is up-to-date.");
         }
         // read the configuration file from user's home directory
         isConfig = AUtilities.getFileAsStream(fileNameUser);
       } catch (AAtlantisException aae) {
         // read the configuration file from atlantis distribution
         logger.error("Could not read " + fileNameUser + " reason: " +
                 aae.getMessage());
         logger.info("Using configuration file: " + fileNameDist);
         isConfig = AUtilities.getFileAsStream(fileNameDist);
       }
 
       //Get document parser instance
       DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
       factory.setValidating(true);
       DocumentBuilder parser = factory.newDocumentBuilder();
       parser.setErrorHandler(new AXMLErrorHandler());
 
       //Get the root node
       Node rootNode = parser.parse(isConfig).getDocumentElement();
 
       // read the XML initialization node, and performs initialization
       Node initializationNode = AXMLUtils.getChild(rootNode, "Initialization");
 
       // read colour map (colormap.xml) configuration -----------------
       logger.info("Reading the colour map...");
       updateStartupWindow(startupWin, "Reading Atlantis colour map");
       AColorMap.readColorMap(Atlantis.colormapCommandLine);
 
       // creating canvas ----------------------------------------------
       logger.info("Building Canvas, Projections...");
       updateStartupWindow(startupWin, "Building Atlantis Canvas, Projections");
       Node canvasNode = AXMLUtils.getChild(initializationNode, "Canvas");
       canvas = new ACanvas(canvasNode);
 
 
       // reading parameters ------------------------------------------
       logger.info("Building Parameters...");
       new APar(AXMLUtils.getChild(rootNode, "Parameters")).update(
               AXMLUtils.getChild(rootNode, "ParameterDifferences"));
       // creating the Projections Manager (reading the projections)
       Node interactionsNode =
               AXMLUtils.getChild(initializationNode, "Interactions");
       AProjectionsManager.initialise(interactionsNode);
 
       // reading  the geometry ----------------------------------------
       logger.info("Reading the geometry...");
       updateStartupWindow(startupWin, "Reading Atlantis geometry");
       String geomPrefix = Atlantis.getHomeDirectory() + "geometry" +
               Atlantis.fileSep;
       String geomName = ADefaultValues.get("GeometryName");
       if (!"".equals(geomName)) {
         // name of the geometry considered after underscore
         geomName = "_" + geomName;
 
         // do the geometry files exist - just try loading the files
         String geomNameFull1 = geomPrefix + "AGeometry" + geomName + ".xml";
         String geomNameFull2 = geomPrefix + "AMuonGeometry" + geomName + ".xml";
         try {
           // just accessibility test
           InputStream i = AUtilities.getFileAsStream(geomNameFull1);
           i = AUtilities.getFileAsStream(geomNameFull2);
           i = null;
         } catch (AAtlantisException ae) {
           geomName = ""; // will fall back to default geometry
         }
       }
       String geomIdCalo = geomPrefix + "AGeometry" + geomName + ".xml";
       String geomMuon = geomPrefix + "AMuonGeometry" + geomName + ".xml";
       detector = new AAtlasDetector(geomIdCalo, geomMuon);
 
       canvas.finalizeConstruction();
       canvas.readCorners(AXMLUtils.getChild(rootNode, "WindowCorners"));
       // This is needed here, design should be changed to remove this problem
       canvas.setCurrentWindow(canvas.getCurrentWindowName());
       //Add the canvas as a NewEvent event listener
       getEventManager().addNewEventListener(canvas);
 
       // reading the event --------------------------------------------
 
       updateStartupWindow(startupWin, "Reading event file");
 
       if (Atlantis.archiveName == null && Atlantis.serverName == null) {
         // read default event from local file system
         getDefaultEvent();
       }
 
       logger.info("Atlantis Ready...");
       updateStartupWindow(startupWin, "Atlantis Ready");
 
       // displaying GUI, Canvas ---------------------------------------
       logger.info("Displaying GUI, Canvas...");
       updateStartupWindow(startupWin, "Displaying Atlantis GUI and Canvas");
       // update colors to those selected in the config file
       AColorMap.setColorMap(APar.get("Prefs", "ColorMap").getI());
       // NB: must calculate the size of GUI after calling
       // canvas.setVisible(true), in which the real final size of Canvas
       // will be calculated
       canvas.setVisible(true);
 
       // Now the canvas is on the screen and have a size, check if we need
       // to rework the aspect ratio on YX projections at all as is the case
       // when going to control room projectors for example - AD
       canvas.correctAspectRatios();
       
       //Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
       //This will stretch the GUI over multiple displays
       //Rather use the canvases graphics config
       Rectangle screenSize = canvas.getGraphicsConfiguration().getBounds();
 
       int useWidth = screenSize.width;
       if (MAX_WIDTH > 0 && useWidth > MAX_WIDTH) {
         useWidth = MAX_WIDTH;
       }
       int guiHeight = canvas.getBounds().height;
       gui = new AGUI(guiHeight);
       if (canvas.getCurrentLayout().getName().equals("FULL SCREEN")) {
         int guiWidth = useWidth / 4;
         gui.setBounds(useWidth * 3 / 4, 0, guiWidth, guiHeight);
       } else {
         int guiWidth = useWidth - canvas.getBounds().width - canvas.getBounds().x;
         gui.setBounds(canvas.getBounds().x + canvas.getBounds().width,
                 canvas.getBounds().y, guiWidth, guiHeight);
       }
       gui.setVisible(true);
 
       if (Atlantis.serverName != null) {
         if (Atlantis.loopInterval != null) {
           // both server name (-s) and timer delay (-p) were specified
           // so create a server dialog
           AReadEventFromServerDialog dialog =  AReadEventFromServerDialog.getInstance();
           //set all properties
           dialog.setServerName(getServerName());
           dialog.setPortNumber(getServerPort());
           dialog.setUpdateInterval(getLoopInterval());
           dialog.showDialog();
           dialog.startEventLoop();
         } else {
           // read a single event from the server
           //Assemble the xmlrpc source string
           String sourceName = "xmlrpc://" + getServerName() + ":" + getServerPort();
           //set new event source and read first event
           try {
             Atlantis.getEventManager().setEventSource(sourceName);
             Atlantis.getEventManager().nextEvent();
           } catch (AEventSourceException aes) {
             JOptionPane.showMessageDialog(AGUI.getGUI(), "Cannot read event from server - " +
                     "reading default event instead", "Bad Event Source", JOptionPane.ERROR_MESSAGE);
             //be a bit verbose
             logger.error("Unable to read event from server:");
             logger.error(aes.getCauseMessges());
             //If we fail, read default event instead
             logger.info("Reading default event instead");
             getDefaultEvent();
           }
         }
       }
 
       if (Atlantis.archiveName != null) // loop an archive in demo mode
       {
         // NB: ADemoDialog need GUI to be present to initialize
         // properly, so put here after GUI's construction
         ADemoDialog.getInstance().setSelectedFile(Atlantis.archiveName);
         ADemoDialog.getInstance().setMode(Atlantis.demoMode);
         ADemoDialog.getInstance().setAccessOrder(Atlantis.accessOrder);
         if (getLoopInterval() != null)
             ADemoDialog.getInstance().setTimerInterval(getLoopInterval());
         
         if (Atlantis.selectedProjections != null) {
           ADemoDialog.getInstance().clearProjSelection();
           if (selectedProjections.indexOf("1") >= 0) {
             ADemoDialog.getInstance().setProjStatus("YX", true);
           }
           if (selectedProjections.indexOf("2") >= 0) {
             ADemoDialog.getInstance().setProjStatus("VP", true);
           }
           if (selectedProjections.indexOf("3") >= 0) {
             ADemoDialog.getInstance().setProjStatus("EG", true);
           }
           if (selectedProjections.indexOf("4") >= 0) {
             ADemoDialog.getInstance().setProjStatus("RZ", true);
           }
           if (selectedProjections.indexOf("5") >= 0) {
             ADemoDialog.getInstance().setProjStatus("FR", true);
           }
           if (selectedProjections.indexOf("6") >= 0) {
             ADemoDialog.getInstance().setProjStatus("FZ", true);
           }
           if (selectedProjections.indexOf("7") >= 0) {
             ADemoDialog.getInstance().setProjStatus("XZ", true);
           }
           if (selectedProjections.indexOf("8") >= 0) {
             ADemoDialog.getInstance().setProjStatus("YZ", true);
           }
           if (selectedProjections.indexOf("9") >= 0) {
             ADemoDialog.getInstance().setProjStatus("LegoPlot", true);
           }
           if (!ADemoDialog.getInstance().checkProjSelection()) {
             ADemoDialog.getInstance().setDefaultProjSelection();
           }
         }
         String order = (Atlantis.accessOrder) ? "random" : "sequential";
         logger.info("Reading event from " + Atlantis.archiveName + " in " + order + " access order");
         ADemoDialog.getInstance().setVisible(true);
         ADemoDialog.getInstance().startDemo();
       }
       
       //If we have a history saver, add it now as new event listener
       if (eventHistory != null)
         getEventManager().addNewEventListener(eventHistory);
       
     } catch (Exception e) {
       logger.fatal(INIT_ERROR_MSG);
       logger.fatal(e.getMessage(), e);
       AExceptionHandler.processException(INIT_ERROR_MSG, e);
     } finally {
       if (startupWin != null) {
         startupWin.dispose();
       }
     }
 
   } // initAtlantis() -----------------------------------------------------
 
 
     /**
      * @return the event manager object
      */
     public static AEventManager getEventManager()
     {
         return eventManager;
     }
 
     /**
      * @return the detector system object
      */
     public static ADetectorSystem getDetector()
     {
         return detector;
 
     }
 
     /**
      * Call from AReadGeometryChooser where the Atlantis geometry is changed
      * on-the-fly
      * @param currentDetector the dectector
      */
     public static void setDetector(ADetectorSystem currentDetector)
     {
         Atlantis.detector = currentDetector;
 
     } // setDetector() ------------------------------------------------------
 
 
     /**
      * Restore all the default configuration
      */
     public static void restoreDefaults()
     {
       //restore default parameters
       APar.restoreDefaults();
       //reset primary vertex in current event if there is one
       if (getEventManager().getCurrentEvent() != null) {
          getEventManager().getCurrentEvent().setPrimaryVertex();
       }
       //reset all list
       AListManager.getInstance().reset();
       //Finally refresh GUI and canvas
       AGUI.refresh();
       ACanvas.getCanvas().restoreDefaults();
 
     } // restoreDefaults() --------------------------------------------------
 
 
     public static String getHomeDirectory()
     {
         // where was this class loaded from
         String temp = Atlantis.class.getResource("Atlantis.class").getFile();
         // remove "file:"
         temp = temp.substring(5);
         if(temp.indexOf("!") > -1)
         {
             // atlantis is in a .jar file
             temp = temp.substring(0, temp.indexOf("!"));
             temp = temp.replaceAll("%20", " ");
             return temp.substring(0, temp.lastIndexOf('/') + 1);
         }
         // must be the current working directory of the user
         return System.getProperty("user.dir") + fileSep;
 
     } // getHomeDirectory() -------------------------------------------------
 
     private static void processCommandLineParameters(String args[])
     {
         HelpFormatter formatter = new HelpFormatter();
 
         Options o = new Options();
         Option hltautokey = new Option("a", false, "show HLTAutoKey tracks");
         o.addOption(hltautokey);
 
         System.out.print("Command line arguments:\n   ");
         for(int i = 0; i < args.length; i++)
         {
             System.out.print(args[i] + " ");
         }
         System.out.println("\n");
         
         Option config = OptionBuilder.withArgName("file")
             .hasArg()
             .withDescription("read configuration from specified file")
             .withLongOpt("config")
             .create("c");
         o.addOption(config);
         
         
         String debugDescr = "log debug messages of severity level to " +
                             "stdout, if destination (filename) is set " +
                             "then also to a file. severity levels are " +
                             ALogger.getStringLevels() + " (INFO is default)"; 
         Option debug = OptionBuilder.hasArgs(2)
                        .withArgName("severity destination")
                        .withDescription(debugDescr)
                        .withLongOpt("debug").create('d');
         o.addOption(debug);
         
         
         Option defaultEvent = OptionBuilder.withArgName("file")
             .hasArg()
             .withDescription("set default event file at startup")
             .withLongOpt("default")
             .create("f");
         o.addOption(defaultEvent);
         
         
         Option configMode = new Option("g", false, "use configuration demo mode with -l (single window mode by default)");
         Option help = new Option("h", "help", false, "display this help message");
         Option projection = OptionBuilder.withArgName("number")
             .hasArg()
             .withDescription("set projections used in single window demo mode with -l (e.g. -j 123)"
                 + "\n 1 --- YX"
                 + "\n 2 --- " + AMath.PHI + AMath.ETA
                 + "\n 3 --- " + AMath.PHI + AMath.LAMBDA
                 + "\n 4 --- " + AMath.RHO + "Z"
                 + "\n 5 --- " + AMath.PHI + AMath.RHO
                 + "\n 6 --- " + AMath.PHI + "Z"
                 + "\n 7 --- X'Z"
                 + "\n 8 --- Y'Z"
                 + "\n 9 --- LegoPlot")
             .withLongOpt("projection")
             .create("j");
         Option loop = OptionBuilder.withArgName("file")
             .hasArg()
             .withDescription("loop through all events in specified file (.zip archive)")
             .withLongOpt("loop")
             .create("l");
         Option colormap = OptionBuilder.withArgName("file")
             .hasArg()
             .withDescription("read colourmap from specified file")
             .withLongOpt("colormap")
             .create("m");
         Option pause = OptionBuilder.withArgName("seconds")
             .hasArg()
             .withDescription("set timer interval for -s or -l options")
             .withLongOpt("pause")
             .create("p");
         Option random = new Option("r", "random", false, "use random access order with -l (sequential by default)");
         Option server = OptionBuilder.withArgName("hostname[:port]")
             .hasArg()
             .withDescription("read event from specified remote server")
             .withLongOpt("server")
             .create("s");
         Option updateConfig = new Option("x", "updateconfig", false, "update user's configuration file");
         Option maxWidth = OptionBuilder.withArgName("maxwidth")
             .hasArg()
             .withDescription("maximum screen width used by Atlantis")
             .withLongOpt("maxwidth")
             .create("w");
         
         // -o --overview - used for monitoring in the ACR - when reading xml
         // from JiveXML server, save png canvas plot and xml event event
         // date every N events into specified directory where history of 
         // M length files is kept
         String overviewDescr = "save history overview when reading files from " +
                                "JiveXML server: save PNG and XML " +
                                "files into directory dir every n events and " +
                                " keep m events in total";
         Option monitOverview = OptionBuilder.hasArgs(3)
                                .withArgName("dir n m")
                                .withDescription(overviewDescr).
                                withLongOpt("overview").create('o');        
         o.addOption(monitOverview);
         
  
         o.addOption(help);
         OptionGroup group1 = new OptionGroup();
         group1.addOption(loop);
         group1.addOption(server);
         o.addOptionGroup(group1);
         OptionGroup group2 = new OptionGroup();
         group2.addOption(configMode);
         group2.addOption(projection);
         o.addOptionGroup(group2);
         o.addOption(colormap);
         o.addOption(pause);
         o.addOption(random);
         o.addOption(updateConfig);
         o.addOption(maxWidth);
 
         CommandLineParser parser = new GnuParser();
         String headerMsg = "\nMandatory arguments to long options are " +
                            "mandatory for short options too.\n";
         String footerMsg = "\n-l and -s are mutually exclusive\n";
         footerMsg += "-g and -j are mutually exclusive\n";
         footerMsg += "\nAtlFast objects were supported up to " +
                      "AtlantisJava-09-05-28 via \"Fast\" option.\n";
         footerMsg += "Beginner simplified GUI was supported up to " +
                      "AtlantisJava-09-05-28 via \"Beginner\" option.\n";
         footerMsg += "CTB 2004 geometry was supported up to " +
                      "AtlantisJava-09-07-42 via -t, --testbeam option.\n";
 
         try
         {
             CommandLine l = parser.parse(o, args);
 
             // retrieve the argument for options
             if(l.hasOption('a'))
             {
                 Atlantis.SHOW_HLTAUTOKEY = true;
             }
             if(l.hasOption('c'))
             {
                 Atlantis.configCommandLine = l.getOptionValue('c', null);
             }
             if(l.hasOption('d'))
             {
                 String[] vals = l.getOptionValues('d');
                 // vals[0] - severity level
                 // vals[1] - destination to write logs to
                 try
                 {
                     ALogger.initialize(vals); // need to check vals
                 }
                 catch(Exception aa)
                 {
                     //aa.printStackTrace();
                     throw new ParseException(debug.getLongOpt() + 
                             " settings incorrect: " + aa.getMessage()); 
                 }                   
             }
             if(l.hasOption('f'))
             {
                 Atlantis.defaultEventFile = l.getOptionValue('f', null);
             }
             if(l.hasOption('h'))
             {
                 formatter.printHelp("Atlantis", headerMsg, o, footerMsg);
                 System.exit(0);
             }
             if(l.hasOption('l'))
             {
                 Atlantis.archiveName = l.getOptionValue('l', null);
                 if(l.hasOption('g'))
                 {
                     Atlantis.demoMode = ADemoDialog.CONFIGURATION_MODE;
                 }
                 else
                 {
                     // only valid with one window demo mode
                     if(l.hasOption('j'))
                     {
                         Atlantis.selectedProjections = l.getOptionValue('j', null);
                     }
                 }
                 if(l.hasOption('r'))
                 {
                     Atlantis.accessOrder = ADemoDialog.RANDOM;
                 }
             }
             if(l.hasOption('m'))
             {
                 // retrieve the argument for options or assign default value
                 Atlantis.colormapCommandLine = l.getOptionValue('m', null);
             }
             if (l.hasOption('s')) {
               //Get the combined server name:port string
               String[] serverPortName = l.getOptionValue('s', null).split(":");
               if ((serverPortName.length < 1) || (serverPortName.length > 2))
                 throw new ParseException("Server option needs argument in the format 'hostname:port'");
 
               //Set server name if given
               if (!((serverPortName[0]).equals("")))
                 Atlantis.serverName = serverPortName[0];
 
               //Check if port number is given
               if (serverPortName.length == 2) {
                 if (!(serverPortName[1]).equals("")) {
                   try {
                     //Check wether this was an integer
                     Atlantis.serverPort = Integer.parseInt(serverPortName[1]);
                   } catch (NumberFormatException nfe) {
                     throw new ParseException("Port number " + serverPortName[1] + " is not valid for -s option");
                   }
                 }
               }
             }
             /**
              * Loop intervall - currently only when reading from server
              */
             if (l.hasOption('p')) {
               String s = l.getOptionValue('p', null);
               // just check whether integer was supplied
               try {
                 loopInterval = Integer.parseInt(s);
               } catch (NumberFormatException nfe) {
                 throw new ParseException(s + " is not integer for -p option");
               }
             }
           
             if(l.hasOption('w'))
             {
                 try 
                 {
                     Atlantis.MAX_WIDTH = Integer.parseInt(l.getOptionValue('w', null));
                 } 
                 catch (NumberFormatException e) 
                 {
                     Atlantis.MAX_WIDTH = 0;
                 }
             }
             if(l.hasOption('x'))
             {
                 Atlantis.updateConfig = true;
             }
             if(l.hasOption('o'))
             {
                 String[] vals = l.getOptionValues('o');
                 if(vals.length != monitOverview.getArgs())
                 {
                     throw new ParseException(monitOverview.getLongOpt() + 
                             " options takes exactly 3 arguments");
                 }
                 // vals[0] - directory to store events and png into
                 // vals[1] - n - save every n events
                 // vals[2] - m - keep m files in the directory
                 try
                 {
                 String dir = vals[0];
                 short n = Short.parseShort(vals[1]);
                 short m = Short.parseShort(vals[2]);
                     Atlantis.eventHistory = new AEventHistory(dir,n,m);
               } catch (NumberFormatException nfe){
                 throw new ParseException("Invalid parameters to option -o");
               } catch(Exception aa){
                     throw new ParseException(aa.getMessage());
                 }
             }
         } // try
         catch(ParseException ex)
         {
             System.err.println("\n" + ex.getMessage() + "\n");
             formatter.printHelp("Atlantis", headerMsg, o, footerMsg);
             System.exit(1);
         }
 
     } // processCommandLineParameters() -------------------------------------
 
 
     /**
      * Read in the default event shipped with Atlantis
      */
     public static void getDefaultEvent()
     {
         //Get the file where the default event is stored
         String eventPath;
         
         //Check if default event is set in command line options
         if(Atlantis.defaultEventFile != null) {
             eventPath = Atlantis.defaultEventFile;
         } else {
           //Otherwise set it to the current home
           eventPath = Atlantis.getHomeDirectory() + "events" + Atlantis.fileSep +
             "test_events.zip";
         }
         
         //be verbose
         logger.info("Reading the default event: " + eventPath);
         //set the event source and read an event
         try {
           getEventManager().setEventSource(eventPath);
           getEventManager().nextEvent();
         } catch (InvalidEventSourceException ies){
           //Write error message
           String msg = "Can not access "+eventPath+": "+ies.getMessage();
           logger.error(msg);
           //Show error dialog
           JOptionPane.showMessageDialog(ACanvas.getCanvas(), msg,
                 "Invalid Event Source",JOptionPane.ERROR_MESSAGE);
         } catch (NoMoreEventsException nme){
           String msg = "No events in "+eventPath+": "+nme.getMessage();
           logger.error(msg);
           //Show error dialog
           JOptionPane.showMessageDialog(ACanvas.getCanvas(), msg,
                 "No Events found",JOptionPane.ERROR_MESSAGE);
         } catch (ReadEventException rex){
           String msg = "Can not read events from "+eventPath+": "+rex.getMessage();
           logger.error(msg);
           //Show error dialog
           JOptionPane.showMessageDialog(ACanvas.getCanvas(), msg,
                 "Can not read event",JOptionPane.ERROR_MESSAGE);
         }
     }
 
 
     private static void setCVSTagInfo()
     {
         // CVS expands into $Name: AtlantisJava-09-11-11 $, we only want the tag name
         String s = Atlantis.versionAtlantisJava;
         s = Atlantis.versionAtlantisJava.replaceAll("Name", "");
         s = s.replaceAll("\\$", "").replaceAll(":", "").trim();
         if("".compareTo(s) == 0)
         {
             s = "AtlantisJava (CVS tag n/a)";
         }
         Atlantis.versionAtlantisJava = s;
 
     }  // setCVSTagInfo() ---------------------------------------------------
 
 
 
     public static void main(String[] args)
     {
         processCommandLineParameters(args);
         
         // logger should be initialized from processCommandLineParameters()
         logger = ALogger.getLogger(Atlantis.class);
 
         checkJDKVersion();        
         
         setCVSTagInfo();
         String msg = "Running AtlantisJava version (CVS tag): " +
                      Atlantis.versionAtlantisJava;        
         logger.info(msg);
     
         if (Atlantis.atlantisWithOpenGL) {
             logger.info("Testing for OpenGL");
             logger.info(AOpenGLTools.isOpenGLAvailable() ? "Open GL Available" : "Open GL Unavailable");
         }
         
         initAtlantis();
 
     } // main() -------------------------------------------------------------
 
 
 } // Atlantis class =========================================================
 

Due to the LXR bug, the updates fail sometimes to remove references to deleted files. The Saturday's full rebuilds fix these problems
This page was automatically generated by the LXR engine.