Changeset 6 in tmcsimulator for trunk/src/tmcsim/simulationmanager


Ignore:
Timestamp:
04/20/2016 02:29:52 PM (10 years ago)
Author:
jdalbey
Message:

Multifile commit. Add version # to Paramics Communicator. Move Load button in Sim Mgr. Add several tests. Add package jars target.

Location:
trunk/src/tmcsim/simulationmanager
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/tmcsim/simulationmanager/SimulationManager.java

    r2 r6  
    99import java.util.logging.Level; 
    1010import java.util.logging.Logger; 
    11  
    1211import javax.swing.JOptionPane; 
    1312import javax.swing.UIManager; 
    14  
     13import tmcsim.common.CADEnums.PARAMICS_STATUS; 
    1514import tmcsim.common.SimulationException; 
    16 import tmcsim.common.CADEnums.PARAMICS_STATUS; 
    1715 
    1816/** 
    19  * Simulation Manager is the main class for this module.  The Simulation Manager 
    20  * is used to control the view and control the simulation.  Simulation incidents 
    21  * are loaded, removed, reschedule, and added from the Simulation Manager.  The 
     17 * Simulation Manager is the main class for this module. The Simulation Manager 
     18 * is used to control the view and control the simulation. Simulation incidents 
     19 * are loaded, removed, reschedule, and added from the Simulation Manager. The 
    2220 * Simulation Manager provides functionality for connecting to the paramics 
    23  * communicator and applying diversions.  A history of all events is shown as well.<br>  
    24  * The SimulationManager may be started at any point before, during, or after  
    25  * a simulation has begun. The SimulationManager connects to the CADSimulator  
    26  * and communicates through Java RMI methods.  If two SimulationManagers are started, 
    27  * the second one started, chronologically, will receive communication from the  
    28  * CADSimulator. <br><br>   
    29  * The properties file for the SimulationManager class contains the following data.<br> 
     21 * communicator and applying diversions. A history of all events is shown as 
     22 * well.<br> 
     23 * The SimulationManager may be started at any point before, during, or after a 
     24 * simulation has begun. The SimulationManager connects to the CADSimulator and 
     25 * communicates through Java RMI methods. If two SimulationManagers are started, 
     26 * the second one started, chronologically, will receive communication from the 
     27 * CADSimulator. <br><br> 
     28 * The properties file for the SimulationManager class contains the following 
     29 * data.<br> 
    3030 * <code> 
    3131 * -----------------------------------------------------------------------------<br> 
    32  * Host Name              The host name where the CADSimulator is located.<br> 
    33  * Error File             The target file to use for error logging.<br> 
     32 * Host Name The host name where the CADSimulator is located.<br> 
     33 * Error File The target file to use for error logging.<br> 
    3434 * -----------------------------------------------------------------------------<br> 
    3535 * Example File: <br> 
    36  * CADSimulatorHost    = localhost <br> 
    37  * ErrorFile           = sim_mgr_error.xml <br> 
     36 * CADSimulatorHost = localhost <br> 
     37 * ErrorFile = sim_mgr_error.xml <br> 
    3838 * -----------------------------------------------------------------------------<br> 
    3939 * </code> 
    4040 * 
    4141 * @author Matthew Cechini (mcechini@calpoly.edu) 
    42  * @version $Date: 2009/04/17 16:27:47 $ $Revision: 1.7  
     42 * @version $Date: 2009/04/17 16:27:47 $ $Revision: 1.7 
    4343 */ 
    44 public class SimulationManager { 
    45          
    46     /** Error logger. */ 
     44public class SimulationManager 
     45{ 
     46 
     47    /** 
     48     * Error logger. 
     49     */ 
    4750    private static Logger simManLogger = Logger.getLogger("tmcsim.simulationmanager"); 
    48      
     51 
    4952    /** 
    5053     * Enumeration containing property names. 
     54     * 
    5155     * @author Matthew Cechini 
    5256     */ 
    53     private static enum PROPERTIES { 
    54         CAD_SIM_HOST  ("CADSimulatorHost"), 
    55         CAD_SIM_PORT  ("CADSimulatorRMIPort"), 
    56         SCRIPT_DIR    ("ScriptDir"), 
    57         FAKE_PARAMICS ("FakeParamicsConnection"); 
    58          
     57    private static enum PROPERTIES 
     58    { 
     59 
     60        CAD_SIM_HOST("CADSimulatorHost"), 
     61        CAD_SIM_PORT("CADSimulatorRMIPort"), 
     62        SCRIPT_DIR("ScriptDir"), 
     63        FAKE_PARAMICS("FakeParamicsConnection"); 
    5964        public String name; 
    60          
    61         private PROPERTIES(String n) { 
     65 
     66        private PROPERTIES(String n) 
     67        { 
    6268            name = n; 
    6369        } 
    64          
    6570    } 
    66          
    67     /** 
    68      * Instance of the SimulationManagerModel which communicates with the  
    69      * CAD Simulator to display the current simulation information.  This 
    70      * model class contains the data that is displayed by the SimulationManagerView 
    71      * class.  The View purely provides a GUI interface for the data contained within 
     71    /** 
     72     * Instance of the SimulationManagerModel which communicates with the CAD 
     73     * Simulator to display the current simulation information. This model class 
     74     * contains the data that is displayed by the SimulationManagerView class. 
     75     * The View purely provides a GUI interface for the data contained within 
    7276     * the model. 
    7377     */ 
    74     private SimulationManagerModel  theSimManagerModel; 
    75      
    76     /** 
    77      * Instance of the SimulationManagerView class which provides a GUI for the user 
    78      * to view the current simulation information and to manage the simulation.  The  
    79      * view communicates to the SimulationManagerModel class to get and set data. 
    80      */ 
    81     SimulationManagerView   theSimManagerView; 
    82      
    83     /** The Properties object for the Simulation Manager. */ 
     78    SimulationManagerModel theSimManagerModel; 
     79    /** 
     80     * Instance of the SimulationManagerView class which provides a GUI for the 
     81     * user to view the current simulation information and to manage the 
     82     * simulation. The view communicates to the SimulationManagerModel class to 
     83     * get and set data. 
     84     */ 
     85    SimulationManagerView theSimManagerView; 
     86    /** 
     87     * The Properties object for the Simulation Manager. 
     88     */ 
    8489    private Properties simManagerProperties; 
    85      
    86     /** 
    87      * Constructor.  Set communication data members from properties file.  Instantiate 
    88      * the SimulationManager Model and View objects, and set visibility to true. 
    89      *  
    90      * @param propertiesFile Properties file containing info for Simulation Manager. 
    91      */ 
    92     public SimulationManager(String propertiesFile) throws SimulationException {     
    93  
    94         try { 
     90 
     91    /** 
     92     * Constructor. Set communication data members from properties file. 
     93     * Instantiate the SimulationManager Model and View objects, and set 
     94     * visibility to true. 
     95     * 
     96     * @param propertiesFile Properties file containing info for Simulation 
     97     * Manager. 
     98     */ 
     99    public SimulationManager(String propertiesFile) throws SimulationException 
     100    { 
     101 
     102        try 
     103        { 
    95104            simManagerProperties = new Properties(); 
    96105            simManagerProperties.load(new FileInputStream(new File(propertiesFile))); 
    97              
    98             SimulationManagerView.SCRIPT_DIR =  
    99                 simManagerProperties.getProperty(PROPERTIES.SCRIPT_DIR.name).trim(); 
     106 
     107            SimulationManagerView.SCRIPT_DIR = 
     108                    simManagerProperties.getProperty(PROPERTIES.SCRIPT_DIR.name).trim(); 
    100109 
    101110            //make sure properties aren't null 
    102             if(simManagerProperties.getProperty(PROPERTIES.CAD_SIM_HOST.name) == null) 
    103                 throw new Exception("CAD Simulator host property is null.");   
    104                  
    105             if(simManagerProperties.getProperty(PROPERTIES.CAD_SIM_PORT.name) == null) 
     111            if (simManagerProperties.getProperty(PROPERTIES.CAD_SIM_HOST.name) == null) 
     112            { 
     113                throw new Exception("CAD Simulator host property is null."); 
     114            } 
     115 
     116            if (simManagerProperties.getProperty(PROPERTIES.CAD_SIM_PORT.name) == null) 
     117            { 
    106118                throw new Exception("CAD Simulator port property is null."); 
    107              
    108         } 
    109         catch (Exception e) 
    110         {      
    111             simManLogger.logp(Level.SEVERE, "SimulationManager", "Constructor",  
     119            } 
     120 
     121        } catch (Exception e) 
     122        { 
     123            simManLogger.logp(Level.SEVERE, "SimulationManager", "Constructor", 
    112124                    "Exception in reading properties file.", e); 
    113              
     125 
    114126            throw new SimulationException(SimulationException.INITIALIZE_ERROR, e); 
    115127        } 
    116128 
    117129        //Construct the SimulationManagerModel 
    118         try  
    119         {                 
     130        try 
     131        { 
    120132            theSimManagerModel = new SimulationManagerModel( 
    121                     simManagerProperties.getProperty(PROPERTIES.CAD_SIM_HOST.name).trim(),  
     133                    simManagerProperties.getProperty(PROPERTIES.CAD_SIM_HOST.name).trim(), 
    122134                    simManagerProperties.getProperty(PROPERTIES.CAD_SIM_PORT.name).trim()); 
    123135 
    124136            //Construct the SimulationManagerView and set up the Model-View references. 
    125137            theSimManagerView = new SimulationManagerView(theSimManagerModel); 
    126             theSimManagerModel.setView(theSimManagerView);                            
    127         } 
    128         catch (RemoteException re)  
    129         { 
    130             simManLogger.logp(Level.SEVERE, "SimulationManager", "Constructor",  
     138            theSimManagerModel.setView(theSimManagerView); 
     139        } catch (RemoteException re) 
     140        { 
     141            simManLogger.logp(Level.SEVERE, "SimulationManager", "Constructor", 
    131142                    "Unable to establish RMI ", re); 
    132143 
    133             throw new SimulationException(SimulationException.CAD_SIM_CONNECT, re);  
    134         } 
    135  
    136         theSimManagerView.addWindowListener(new WindowListener() { 
    137             public void windowClosed(WindowEvent e)  {} 
    138             public void windowOpened(WindowEvent e)  {}             
    139             public void windowIconified(WindowEvent e)  {}          
    140             public void windowDeiconified(WindowEvent e)  {}     
    141             public void windowActivated(WindowEvent e)  {}                              
    142             public void windowDeactivated(WindowEvent e)  {}          
    143             public void windowClosing(WindowEvent e)  {      
     144            throw new SimulationException(SimulationException.CAD_SIM_CONNECT, re); 
     145        } 
     146 
     147        theSimManagerView.addWindowListener(new WindowListener() 
     148        { 
     149            public void windowClosed(WindowEvent e) 
     150            { 
     151            } 
     152 
     153            public void windowOpened(WindowEvent e) 
     154            { 
     155            } 
     156 
     157            public void windowIconified(WindowEvent e) 
     158            { 
     159            } 
     160 
     161            public void windowDeiconified(WindowEvent e) 
     162            { 
     163            } 
     164 
     165            public void windowActivated(WindowEvent e) 
     166            { 
     167            } 
     168 
     169            public void windowDeactivated(WindowEvent e) 
     170            { 
     171            } 
     172 
     173            public void windowClosing(WindowEvent e) 
     174            { 
    144175                theSimManagerModel.disconnect(); 
    145176                System.exit(0); 
    146             }            
     177            } 
    147178        }); 
    148179 
    149         if(Boolean.parseBoolean(simManagerProperties.getProperty( 
     180        if (Boolean.parseBoolean(simManagerProperties.getProperty( 
    150181                PROPERTIES.FAKE_PARAMICS.name).trim())) 
    151182        { 
    … …  
    154185 
    155186        //Show the SimulationManager 
    156         theSimManagerView.setVisible(true);         
     187        theSimManagerView.setVisible(true); 
    157188    } 
    158      
    159     /** 
    160      * Main class.   
    161      *  
     189 
     190    /** 
     191     * Main class. 
     192     * 
    162193     * @param args Command line arguments. 
    163194     */ 
    164     static public void main(String[] args) { 
     195    static public void main(String[] args) 
     196    { 
    165197        System.setProperty("SIM_MGR_PROPERTIES", "config/sim_manager_config.properties"); 
    166  
    167         try { 
    168             if(System.getProperty("SIM_MGR_PROPERTIES") != null) 
     198        //System.setProperty("swing.defaultlaf", "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel"); 
     199 
     200        try 
     201        { 
     202            if (System.getProperty("SIM_MGR_PROPERTIES") != null) 
    169203            { 
    170204                UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); 
    171                  
     205 
    172206                new SimulationManager(System.getProperty("SIM_MGR_PROPERTIES")); 
    173             } 
    174             else 
    175             { 
    176                 throw new Exception ("SIM_MGR_PROPERTIES system property not defined."); 
    177             } 
    178         }  
    179         catch (Exception e)  
    180         { 
    181             simManLogger.logp(Level.SEVERE, "SimulationManager", "Main",  
     207            } else 
     208            { 
     209                throw new Exception("SIM_MGR_PROPERTIES system property not defined."); 
     210            } 
     211        } catch (Exception e) 
     212        { 
     213            simManLogger.logp(Level.SEVERE, "SimulationManager", "Main", 
    182214                    "Error occured initializing application", e); 
    183              
    184             JOptionPane.showMessageDialog(null, e.getMessage(),  
    185                 "Error - Program Exiting", JOptionPane.ERROR_MESSAGE);   
    186              
     215 
     216            JOptionPane.showMessageDialog(null, e.getMessage(), 
     217                    "Error - Program Exiting", JOptionPane.ERROR_MESSAGE); 
     218 
    187219            System.exit(-1); 
    188         }    
    189          
     220        } 
     221 
    190222    } 
    191223} 
    192  
    193  
    194  
    195  
    196  
    197  
    198  

  • trunk/src/tmcsim/simulationmanager/SimulationManagerModel.java

    r2 r6  
    1010import java.util.logging.Level; 
    1111import java.util.logging.Logger; 
    12  
    1312import tmcsim.cadmodels.CMSDiversion; 
    1413import tmcsim.cadmodels.CMSInfo; 
    1514import tmcsim.client.cadclientgui.data.Incident; 
    1615import tmcsim.client.cadclientgui.data.IncidentEvent; 
     16import tmcsim.common.CADEnums.PARAMICS_STATUS; 
     17import tmcsim.common.CADEnums.SCRIPT_STATUS; 
    1718import tmcsim.common.ScriptException; 
    1819import tmcsim.common.SimulationException; 
    19 import tmcsim.common.CADEnums.PARAMICS_STATUS; 
    20 import tmcsim.common.CADEnums.SCRIPT_STATUS; 
    2120import tmcsim.interfaces.CoordinatorInterface; 
    2221import tmcsim.interfaces.SimulationManagerInterface; 
    2322 
    24  
    2523/** 
    26  * SimulationManagerModel is the model class for the Simulation Manager.  All communication 
    27  * between the Coordinator and the Simulation Manager passes through this object.  The view 
    28  * passes requests through local methods, and the Coordinator calls remote functions in this 
    29  * object to update the viewed simulation data. 
    30  * <br/>  
    31  * At construction, the SimulationManagerModel registers itself with the coordinator.   
    32  * Administrative commands for the simulation are received from the SimlationManagerView  
    33  * class, and then the appropriate Coordinator remote method is executed.  During a  
    34  * simulation, the Coordinator calls remote methods contained in the SimulationManagerInterface.   
    35  * For a description of those methods, see the interface's documentation.  After construction,  
    36  * this model class must have its setView() method called to set the reference to its view class. 
    37  *  
     24 * SimulationManagerModel is the model class for the Simulation Manager. All 
     25 * communication between the Coordinator and the Simulation Manager passes 
     26 * through this object. The view passes requests through local methods, and the 
     27 * Coordinator calls remote functions in this object to update the viewed 
     28 * simulation data. 
     29 * <br/> 
     30 * At construction, the SimulationManagerModel registers itself with the 
     31 * coordinator. Administrative commands for the simulation are received from the 
     32 * SimlationManagerView class, and then the appropriate Coordinator remote 
     33 * method is executed. During a simulation, the Coordinator calls remote methods 
     34 * contained in the SimulationManagerInterface. For a description of those 
     35 * methods, see the interface's documentation. After construction, this model 
     36 * class must have its setView() method called to set the reference to its view 
     37 * class. 
     38 * 
    3839 * @see SimulationManagerView 
    3940 * @see SimulationManagerInterface 
    40  * @author Matthew Cechini  
     41 * @author Matthew Cechini 
    4142 * @version $Revision: 1.3 $ $Date: 2006/06/06 20:46:41 $ 
    4243 */ 
    4344@SuppressWarnings("serial") 
    44 public class SimulationManagerModel extends UnicastRemoteObject  
    45     implements SimulationManagerInterface { 
    46      
    47     /** Error Logger. */ 
     45public class SimulationManagerModel extends UnicastRemoteObject 
     46        implements SimulationManagerInterface 
     47{ 
     48 
     49    /** 
     50     * Error Logger. 
     51     */ 
    4852    private Logger simManagerLogger = Logger.getLogger("tmcsim.simulationmanager"); 
    49      
    50     /** RMI interface for communication with the remote Coordinator. */  
     53    /** 
     54     * RMI interface for communication with the remote Coordinator. 
     55     */ 
    5156    private static CoordinatorInterface theCoorInt; 
    52      
    53     /** The SimulationManagerView object. */ 
    54     private SimulationManagerView theSimManagerView;     
    55      
    56  
    57     /** 
    58      * Constructor.  Establishes the RMI communication with the Coordinator. 
    59      * 
    60      * @param hostname Host name of the CAD Simulator.     
    61      * @param portNumber Port number of the CAD Simulator RMI communication.  
     57    /** 
     58     * The SimulationManagerView object. 
     59     */ 
     60    private SimulationManagerView theSimManagerView; 
     61 
     62    /** 
     63     * Constructor. Establishes the RMI communication with the Coordinator. 
     64     * 
     65     * @param hostname Host name of the CAD Simulator. 
     66     * @param portNumber Port number of the CAD Simulator RMI communication. 
    6267     * @throws RemoteException if error in RMI communication 
    63      * @throws SimulationException if there is an error in registering RMI methods. 
    64      */ 
    65     public SimulationManagerModel(String hostname, String portNumber)  
    66             throws RemoteException, SimulationException { 
    67         super();                                 
    68                                          
     68     * @throws SimulationException if there is an error in registering RMI 
     69     * methods. 
     70     */ 
     71    public SimulationManagerModel(String hostname, String portNumber) 
     72            throws RemoteException, SimulationException 
     73    { 
     74        super(); 
     75 
    6976        connect(hostname, portNumber); 
    70     }        
    71      
     77    } 
     78 
    7279    /** 
    7380     * Connect to the Coordinator's RMI object, and register this object for 
    7481     * callback with the Coordinator. 
    75      * @param hostname Host name of the CAD Simulator.     
    76      * @param portNumber Port number of the CAD Simulator RMI communication.  
    77      * @throws SimulationException if there is an error creating the RMI connection. 
    78      */  
    79     protected void connect(String hostname, String portNumber)  
    80         throws SimulationException { 
    81          
     82     * 
     83     * @param hostname Host name of the CAD Simulator. 
     84     * @param portNumber Port number of the CAD Simulator RMI communication. 
     85     * @throws SimulationException if there is an error creating the RMI 
     86     * connection. 
     87     */ 
     88    protected void connect(String hostname, String portNumber) 
     89            throws SimulationException 
     90    { 
     91 
    8292        String coorIntURL = ""; 
    83          
    84         try {   
    85             coorIntURL = "rmi://" + hostname + ":" + portNumber + "/coordinator";  
    86              
    87             theCoorInt = (CoordinatorInterface)Naming.lookup(coorIntURL); 
    88             theCoorInt.registerForCallback(this);            
    89              
    90         } 
    91         catch (Exception e) { 
    92             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    93                     "establishRMIConnection", "Unable to establish RMI " + 
    94                     "communication with the CAD Simulator.  URL <" + coorIntURL + ">", e); 
    95              
     93 
     94        try 
     95        { 
     96            coorIntURL = "rmi://" + hostname + ":" + portNumber + "/coordinator"; 
     97 
     98            theCoorInt = (CoordinatorInterface) Naming.lookup(coorIntURL); 
     99            theCoorInt.registerForCallback(this); 
     100 
     101        } catch (Exception e) 
     102        { 
     103            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     104                    "establishRMIConnection", "Unable to establish RMI " 
     105                    + "communication with the CAD Simulator.  URL <" + coorIntURL + ">", e); 
     106 
    96107            throw new SimulationException(SimulationException.CAD_SIM_CONNECT, e); 
    97         }    
    98     } 
    99      
    100     /** 
    101      * This method unregisters this SimulationManager from the Coordinator and closes 
    102      * the RMI communication. 
    103      */ 
    104     public void disconnect() { 
    105         try { 
     108        } 
     109    } 
     110 
     111    /** 
     112     * This method unregisters this SimulationManager from the Coordinator and 
     113     * closes the RMI communication. 
     114     */ 
     115    public void disconnect() 
     116    { 
     117        try 
     118        { 
    106119            theCoorInt.unregisterForCallback(this); 
    107120            theCoorInt = null; 
    108         } 
    109         catch (Exception e) { 
    110             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    111                     "closeSimManager", "Exception in unregistering Simulation" + 
    112                     "Manager from the CAD Simulator.", e); 
    113         } 
    114     } 
    115      
    116     /** 
    117      * Set the local reference to the SimulationManagerView object.  The view 
    118      * is updated with the current simulation time, script status, and Paramics 
    119      * connection status.  
     121        } catch (Exception e) 
     122        { 
     123            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     124                    "closeSimManager", "Exception in unregistering Simulation" 
     125                    + "Manager from the CAD Simulator.", e); 
     126        } 
     127    } 
     128 
     129    /** 
     130     * Set the local reference to the SimulationManagerView object. The view is 
     131     * updated with the current simulation time, script status, and Paramics 
     132     * connection status. 
    120133     * 
    121134     * @param newView The instance of the SimulationManagerView class. 
    122      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    123      */ 
    124     public void setView(SimulationManagerView newView) throws SimulationException { 
    125         try { 
     135     * @throws SimulationException if there is an error in RMI communication to 
     136     * the CAD Simulator. 
     137     */ 
     138    public void setView(SimulationManagerView newView) throws SimulationException 
     139    { 
     140        try 
     141        { 
    126142            theSimManagerView = newView; 
    127              
    128             theSimManagerView.tick(theCoorInt.getCurrentSimulationTime());   
     143 
     144            theSimManagerView.tick(theCoorInt.getCurrentSimulationTime()); 
    129145            theSimManagerView.setScriptStatus(theCoorInt.getScriptStatus()); 
    130146            theSimManagerView.setParamicsStatus(theCoorInt.getParamicsStatus()); 
    131              
     147 
    132148            initialize(); 
    133         } 
    134         catch (RemoteException re) { 
    135             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    136                     "startSimulation", "Unable to communicate with the " + 
    137                     "CAD Simulator.", re); 
    138              
    139             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    140         }    
    141          
    142     }    
    143      
     149        } catch (RemoteException re) 
     150        { 
     151            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     152                    "startSimulation", "Unable to communicate with the " 
     153                    + "CAD Simulator.", re); 
     154 
     155            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     156        } 
     157 
     158    } 
     159 
    144160    /** 
    145161     * This method initializes the SimulationManager with all current simulation 
    146      * data from the Coordinator.  If the simulation is running when the Simulation 
    147      * Manager is initialized, all previously occured incidents, events, and current 
    148      * diversion must be displayed.  This method first loads the list of current 
    149      * incidents from the coordinator, then the triggered events, followed by  
    150      * all CMSInfo objects.  The SimulationManagerView is notified of any current 
    151      * diversions within the CMSInfo objects.   
    152      *  
    153      * @throws SimulationException if there is an error in RMI communication or if the  
    154      *         SimulationManagerView reference has not been set. 
    155      */ 
    156     protected void initialize() throws SimulationException { 
    157          
    158         try { 
    159          
     162     * data from the Coordinator. If the simulation is running when the 
     163     * Simulation Manager is initialized, all previously occured incidents, 
     164     * events, and current diversion must be displayed. This method first loads 
     165     * the list of current incidents from the coordinator, then the triggered 
     166     * events, followed by all CMSInfo objects. The SimulationManagerView is 
     167     * notified of any current diversions within the CMSInfo objects. 
     168     * 
     169     * @throws SimulationException if there is an error in RMI communication or 
     170     * if the SimulationManagerView reference has not been set. 
     171     */ 
     172    protected void initialize() throws SimulationException 
     173    { 
     174 
     175        try 
     176        { 
     177 
    160178            //Load all incidents from Coordinator 
    161             loadIncidents();  
    162              
     179            loadIncidents(); 
     180 
    163181            //Load all triggered incidents from Coordinator 
    164182            TreeMap<Integer, Vector<IncidentEvent>> tempEvents = theCoorInt.getTriggeredEvents(); 
    165             for(Integer key : tempEvents.keySet())  {            
    166                 for(IncidentEvent ie : tempEvents.get(key))  
    167                     eventOccured(key, ie);            
    168             }            
    169                    
     183            for (Integer key : tempEvents.keySet()) 
     184            { 
     185                for (IncidentEvent ie : tempEvents.get(key)) 
     186                { 
     187                    eventOccured(key, ie); 
     188                } 
     189            } 
     190 
    170191            //Load all current diversions from the Coordinator 
    171192            TreeSet<String> cmsIDs = theCoorInt.getCMSIDs(); 
    172             CMSInfo cmsinfo  = null; 
    173             for(String cms_id : cmsIDs) { 
     193            CMSInfo cmsinfo = null; 
     194            for (String cms_id : cmsIDs) 
     195            { 
    174196                cmsinfo = theCoorInt.getCMSDiversionInfo(cms_id); 
    175                  
    176                 for(CMSDiversion div : cmsinfo.possibleDiversions) { 
    177                     if(div.getCurrDiv() != 0) {                      
     197 
     198                for (CMSDiversion div : cmsinfo.possibleDiversions) 
     199                { 
     200                    if (div.getCurrDiv() != 0) 
     201                    { 
    178202                        theSimManagerView.addDiversion(cmsinfo, div); 
    179                     }        
     203                    } 
    180204                } 
    181             }    
    182              
     205            } 
     206 
    183207            //Send the list of CMS IDs to the View. 
    184208            theSimManagerView.setCMS_IDList(cmsIDs.toArray()); 
    185         } 
    186         catch (Exception e) { 
    187             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
     209 
     210        } catch (Exception e) 
     211        { 
     212            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
    188213                    "initialize", "Unable to initialize the SimulationManager.", e); 
    189              
     214 
    190215            throw new SimulationException(SimulationException.CAD_SIM_COMM, e); 
    191         }    
    192     } 
    193  
    194     public void tick(long theTime) throws RemoteException { 
    195         if(theSimManagerView != null) 
    196             theSimManagerView.tick(theTime);     
    197     } 
    198      
    199     public void incidentAdded(Incident newIncident) throws RemoteException { 
    200         if(theSimManagerView != null) { 
     216        } 
     217    } 
     218 
     219    public void tick(long theTime) throws RemoteException 
     220    { 
     221        if (theSimManagerView != null) 
     222        { 
     223            theSimManagerView.tick(theTime); 
     224        } 
     225    } 
     226 
     227    public void incidentAdded(Incident newIncident) throws RemoteException 
     228    { 
     229        if (theSimManagerView != null) 
     230        { 
    201231            Integer logNum = new Integer(newIncident.getLogNumber()); 
    202              
    203             theSimManagerView.addIncident(newIncident);          
     232 
     233            theSimManagerView.addIncident(newIncident); 
    204234            theSimManagerView.addIncidentTab(logNum); 
    205235        } 
    206236    } 
    207237 
    208     public void incidentStarted(Integer logNumber) throws RemoteException { 
    209         if(theSimManagerView != null) { 
     238    public void incidentStarted(Integer logNumber) throws RemoteException 
     239    { 
     240        if (theSimManagerView != null) 
     241        { 
    210242            theSimManagerView.startIncident(logNumber); 
    211243        } 
    212244    } 
    213245 
    214     public void incidentRemoved(Integer logNumber) throws RemoteException { 
    215         if(theSimManagerView != null) { 
     246    public void incidentRemoved(Integer logNumber) throws RemoteException 
     247    { 
     248        if (theSimManagerView != null) 
     249        { 
    216250            theSimManagerView.removeIncident(logNumber); 
    217251            theSimManagerView.removeIncidentTab(logNumber); 
    218252        } 
    219253    } 
    220      
    221     public void eventOccured(Integer logNumber, IncidentEvent theEvent) throws RemoteException { 
    222         if(theSimManagerView != null) { 
     254 
     255    public void eventOccured(Integer logNumber, IncidentEvent theEvent) throws RemoteException 
     256    { 
     257        if (theSimManagerView != null) 
     258        { 
    223259            theSimManagerView.addIncidentEvent(logNumber, theEvent); 
    224260        } 
    225261    } 
    226      
    227     public void setScriptStatus(SCRIPT_STATUS newStatus) throws RemoteException { 
    228         if(theSimManagerView != null) 
    229             theSimManagerView.setScriptStatus(newStatus);        
    230     } 
    231  
    232     public void setParamicsStatus(PARAMICS_STATUS newStatus) throws RemoteException { 
    233         if(theSimManagerView != null) 
    234             theSimManagerView.setParamicsStatus(newStatus);      
    235          
    236     } 
    237      
    238     /** 
    239      * This method passes the view's request to start the simulation  
    240      * on to the remote coordinator. 
     262 
     263    public void setScriptStatus(SCRIPT_STATUS newStatus) throws RemoteException 
     264    { 
     265        if (theSimManagerView != null) 
     266        { 
     267            theSimManagerView.setScriptStatus(newStatus); 
     268        } 
     269    } 
     270 
     271    public void setParamicsStatus(PARAMICS_STATUS newStatus) throws RemoteException 
     272    { 
     273        if (theSimManagerView != null) 
     274        { 
     275            theSimManagerView.setParamicsStatus(newStatus); 
     276        } 
     277 
     278    } 
     279 
     280    /** 
     281     * This method passes the view's request to start the simulation on to the 
     282     * remote coordinator. 
    241283     * 
    242284     * @throws ScriptException if an error occurs in started the simulation. 
    243      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    244      */   
    245     public void startSimulation() throws ScriptException, SimulationException { 
    246  
    247         try { 
     285     * @throws SimulationException if there is an error in RMI communication to 
     286     * the CAD Simulator. 
     287     */ 
     288    public void startSimulation() throws ScriptException, SimulationException 
     289    { 
     290 
     291        try 
     292        { 
    248293            theCoorInt.startSimulation(); 
    249         } 
    250         catch (RemoteException re) { 
    251             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    252                     "startSimulation", "Unable to communicate with the " + 
    253                     "CAD Simulator.", re); 
    254              
    255             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    256         }    
    257  
    258     } 
    259      
    260     /** 
    261      * This method passes the view's request to reset the simulation  
    262      * on to the remote coordinator.  The View's simulation time is reset to 0. 
    263      * The view's incident tabs are cleared and incident list reset and initialized 
    264      * with the current list of incidents.  The list of diversions is also reset. 
    265      *  
    266      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    267      */ 
    268     public void resetSimulation() throws SimulationException {       
    269  
    270         try { 
     294        } catch (RemoteException re) 
     295        { 
     296            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     297                    "startSimulation", "Unable to communicate with the " 
     298                    + "CAD Simulator.", re); 
     299 
     300            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     301        } 
     302 
     303    } 
     304 
     305    /** 
     306     * This method passes the view's request to reset the simulation on to the 
     307     * remote coordinator. The View's simulation time is reset to 0. The view's 
     308     * incident tabs are cleared and incident list reset and initialized with 
     309     * the current list of incidents. The list of diversions is also reset. 
     310     * 
     311     * @throws SimulationException if there is an error in RMI communication to 
     312     * the CAD Simulator. 
     313     */ 
     314    public void resetSimulation() throws SimulationException 
     315    { 
     316 
     317        try 
     318        { 
    271319            theCoorInt.resetSimulation(); 
    272              
     320 
    273321            tick(0); 
    274322            theSimManagerView.resetIncidentTabs(); 
    … …  
    276324            theSimManagerView.resetDiversions(); 
    277325 
    278             loadIncidents();  
    279         } 
    280         catch (RemoteException re) { 
    281             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    282                     "resetSimulation", "Unable to communicate with the " + 
    283                     "CAD Simulator.", re); 
    284              
    285             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    286         }    
    287  
    288     } 
    289      
    290     /** 
    291      * This method passes the view's request to pause the simulation  
    292      * on to the remote coordinator. 
    293      *       
    294      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    295      */ 
    296     public void pauseSimulation() throws SimulationException { 
    297  
    298         try { 
     326            loadIncidents(); 
     327        } catch (RemoteException re) 
     328        { 
     329            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     330                    "resetSimulation", "Unable to communicate with the " 
     331                    + "CAD Simulator.", re); 
     332 
     333            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     334        } 
     335 
     336    } 
     337 
     338    /** 
     339     * This method passes the view's request to pause the simulation on to the 
     340     * remote coordinator. 
     341     * 
     342     * @throws SimulationException if there is an error in RMI communication to 
     343     * the CAD Simulator. 
     344     */ 
     345    public void pauseSimulation() throws SimulationException 
     346    { 
     347 
     348        try 
     349        { 
    299350            theCoorInt.pauseSimulation(); 
    300          } 
    301         catch (RemoteException re) { 
    302             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    303                     "pauseSimulation", "Unable to communicate with the " + 
    304                     "CAD Simulator.", re); 
    305              
    306             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    307         }    
    308  
    309     } 
    310      
    311     /** 
    312      * This method passes the view's request to goto a new simulation  
    313      * time on to the remote coordinator. 
    314      *  
    315      * @param time Simulation time  
    316      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    317      */ 
    318     public void gotoSimulationTime(long time) throws SimulationException { 
    319          
    320         try { 
     351        } catch (RemoteException re) 
     352        { 
     353            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     354                    "pauseSimulation", "Unable to communicate with the " 
     355                    + "CAD Simulator.", re); 
     356 
     357            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     358        } 
     359 
     360    } 
     361 
     362    /** 
     363     * This method passes the view's request to goto a new simulation time on to 
     364     * the remote coordinator. 
     365     * 
     366     * @param time Simulation time 
     367     * @throws SimulationException if there is an error in RMI communication to 
     368     * the CAD Simulator. 
     369     */ 
     370    public void gotoSimulationTime(long time) throws SimulationException 
     371    { 
     372 
     373        try 
     374        { 
    321375            theCoorInt.gotoSimulationTime(time); 
    322         } 
    323         catch (RemoteException re) { 
    324             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    325                     "gotoSimulationTime", "Unable to communicate with the " + 
    326                     "CAD Simulator.", re); 
    327              
    328             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    329         }    
    330     } 
    331      
    332     /** 
    333      * This method passes the view's request to load a script file on to the  
    334      * remote Coordinator.  If this is successful, the View's incident tabs  
    335      * are cleared and incident list reset and initialized with the current  
    336      * list of incidents.  If the load is not successful, the View's incident tabs 
    337      * and incident list are cleared. The list of diversions is also reset. 
     376        } catch (RemoteException re) 
     377        { 
     378            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     379                    "gotoSimulationTime", "Unable to communicate with the " 
     380                    + "CAD Simulator.", re); 
     381 
     382            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     383        } 
     384    } 
     385 
     386    /** 
     387     * This method passes the view's request to load a script file on to the 
     388     * remote Coordinator. If this is successful, the View's incident tabs are 
     389     * cleared and incident list reset and initialized with the current list of 
     390     * incidents. If the load is not successful, the View's incident tabs and 
     391     * incident list are cleared. The list of diversions is also reset. 
    338392     * 
    339393     * @param scriptFile the File chosen by the user in the open file dialog. 
    340394     * @throws ScriptException if an error occurs in reading the script file. 
    341      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    342      */ 
    343     public void loadScript(File scriptFile) throws ScriptException, SimulationException{     
    344          
    345         try { 
     395     * @throws SimulationException if there is an error in RMI communication to 
     396     * the CAD Simulator. 
     397     */ 
     398    public void loadScript(File scriptFile) throws ScriptException, SimulationException 
     399    { 
     400 
     401        try 
     402        { 
    346403            theCoorInt.loadScriptFile(scriptFile); 
    347              
     404 
    348405            tick(0); 
    349406            theSimManagerView.resetIncidentTabs(); 
    350407            theSimManagerView.resetIncidents(); 
    351408            theSimManagerView.resetDiversions(); 
    352              
     409 
    353410            loadIncidents(); 
    354          }  
    355          catch(ScriptException se) { 
     411        } catch (ScriptException se) 
     412        { 
    356413            theSimManagerView.resetIncidentTabs(); 
    357414            theSimManagerView.resetIncidents(); 
    358415            theSimManagerView.resetDiversions(); 
    359416            throw se; 
    360          } 
    361         catch (RemoteException re) { 
    362             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    363                     "loadScript", "Unable to communicate with the " + 
    364                     "CAD Simulator.", re); 
    365              
    366             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    367         }            
    368     } 
    369      
    370      /** 
    371       * This method passes the view's request to create a connection between 
    372       * the CADSimulator and the Paramics Communicator on to the remote Coordinator.  
    373       * 
    374       * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    375       */ 
    376      public void connectToParamics() throws SimulationException { 
    377  
    378         try { 
     417        } catch (RemoteException re) 
     418        { 
     419            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     420                    "loadScript", "Unable to communicate with the " 
     421                    + "CAD Simulator.", re); 
     422 
     423            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     424        } 
     425    } 
     426 
     427    /** 
     428     * This method passes the view's request to create a connection between the 
     429     * CADSimulator and the Paramics Communicator on to the remote Coordinator. 
     430     * 
     431     * @throws SimulationException if there is an error in RMI communication to 
     432     * the CAD Simulator. 
     433     */ 
     434    public void connectToParamics() throws SimulationException 
     435    { 
     436 
     437        try 
     438        { 
    379439            theCoorInt.connectToParamics(); 
    380         }  
    381         catch (RemoteException re) { 
    382             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    383                     "connectToParamics", "Unable to communicate with the " + 
    384                     "CAD Simulator.", re); 
    385              
    386             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    387         } 
    388      } 
    389       
    390      /**  
    391       * This method passes the view's request to drop the connection between 
    392       * the CADSimulator and the Paramics Communicator on to the 
    393       * remote Coordinator.  
    394       * 
    395       * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    396       */ 
    397      public void disconnectFromParamics() throws SimulationException {  
    398  
    399         try { 
     440        } catch (RemoteException re) 
     441        { 
     442            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     443                    "connectToParamics", "Unable to communicate with the " 
     444                    + "CAD Simulator.", re); 
     445 
     446            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     447        } 
     448    } 
     449 
     450    /** 
     451     * This method passes the view's request to drop the connection between the 
     452     * CADSimulator and the Paramics Communicator on to the remote Coordinator. 
     453     * 
     454     * @throws SimulationException if there is an error in RMI communication to 
     455     * the CAD Simulator. 
     456     */ 
     457    public void disconnectFromParamics() throws SimulationException 
     458    { 
     459 
     460        try 
     461        { 
    400462            theCoorInt.disconnectFromParamics(); 
    401         }  
    402         catch (RemoteException re) { 
    403             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    404                     "disconnectFromParamics", "Unable to communicate with the " + 
    405                     "CAD Simulator.", re); 
    406              
    407             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    408         } 
    409      } 
    410       
    411      /** 
    412       * This method passes the view's request to load a paramics 
    413       * network on to the remote Coordinator.  
    414       * 
    415       * @param networkID The unique network ID that is being loaded 
    416       * 
    417       * @throws ScriptException if there is an error in loading the network 
    418       * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    419       */ 
    420      public void loadParamicsNetwork(int networkID) throws ScriptException, SimulationException { 
    421         try { 
    422              theCoorInt.loadParamicsNetwork(networkID);          
    423         } catch (RemoteException re) { 
    424             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    425                     "loadParamicsNetwork", "Unable to communicate with the " + 
    426                     "CAD Simulator.", re); 
    427              
    428             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    429         } 
    430      } 
    431           
    432      /** 
    433       * This method passes the view's request to get the value of the 
    434       * currently loaded paramics network on to the remote Coordinator. 
    435       *  
    436       * @return Value of the loaded paramics network.   
    437       * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    438       */ 
    439      public int getParamicsNetworkLoaded() throws SimulationException { 
    440          try { 
    441             return theCoorInt.getParamicsNetworkLoaded();            
    442         } catch (RemoteException re) { 
    443             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    444                     "getParamicsNetworkLoaded", "Unable to communicate with the " + 
    445                     "CAD Simulator.", re); 
    446              
    447             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    448         } 
    449      } 
    450      
    451     /** 
    452      * This method passes the view's request to trigger an incident  
    453      * on to the remote Coordinator. 
     463        } catch (RemoteException re) 
     464        { 
     465            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     466                    "disconnectFromParamics", "Unable to communicate with the " 
     467                    + "CAD Simulator.", re); 
     468 
     469            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     470        } 
     471    } 
     472 
     473    /** 
     474     * This method passes the view's request to load a paramics network on to 
     475     * the remote Coordinator. 
     476     * 
     477     * @param networkID The unique network ID that is being loaded 
     478     * 
     479     * @throws ScriptException if there is an error in loading the network 
     480     * @throws SimulationException if there is an error in RMI communication to 
     481     * the CAD Simulator. 
     482     */ 
     483    public void loadParamicsNetwork(int networkID) throws ScriptException, SimulationException 
     484    { 
     485        try 
     486        { 
     487            theCoorInt.loadParamicsNetwork(networkID); 
     488        } catch (RemoteException re) 
     489        { 
     490            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     491                    "loadParamicsNetwork", "Unable to communicate with the " 
     492                    + "CAD Simulator.", re); 
     493 
     494            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     495        } 
     496    } 
     497 
     498    /** 
     499     * This method passes the view's request to get the value of the currently 
     500     * loaded paramics network on to the remote Coordinator. 
     501     * 
     502     * @return Value of the loaded paramics network. 
     503     * @throws SimulationException if there is an error in RMI communication to 
     504     * the CAD Simulator. 
     505     */ 
     506    public int getParamicsNetworkLoaded() throws SimulationException 
     507    { 
     508        try 
     509        { 
     510            return theCoorInt.getParamicsNetworkLoaded(); 
     511        } catch (RemoteException re) 
     512        { 
     513            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     514                    "getParamicsNetworkLoaded", "Unable to communicate with the " 
     515                    + "CAD Simulator.", re); 
     516 
     517            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     518        } 
     519    } 
     520 
     521    /** 
     522     * This method passes the view's request to trigger an incident on to the 
     523     * remote Coordinator. 
    454524     * 
    455525     * @throws ScriptException if an error occurs in triggering an event. 
    456      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    457      */ 
    458     public void triggerIncident(int logNumber) throws ScriptException, SimulationException { 
    459         try { 
     526     * @throws SimulationException if there is an error in RMI communication to 
     527     * the CAD Simulator. 
     528     */ 
     529    public void triggerIncident(int logNumber) throws ScriptException, SimulationException 
     530    { 
     531        try 
     532        { 
    460533            theCoorInt.triggerIncident(logNumber); 
    461              
    462         } catch (RemoteException re) { 
    463             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    464                     "startIncident", "Unable to communicate with the " + 
    465                     "CAD Simulator.", re); 
    466              
    467             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    468         } 
    469     } 
    470  
    471      /** 
    472       * This method passes the view's request to add an incident into the  
    473       * simulation on to the remote Coordinator. 
    474       * 
    475       * @param newIncident Incident to add to the simulation 
    476       * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    477       */ 
    478      public void addIncident(final Incident newIncident) throws SimulationException {        
    479  
    480         try { 
     534 
     535        } catch (RemoteException re) 
     536        { 
     537            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     538                    "startIncident", "Unable to communicate with the " 
     539                    + "CAD Simulator.", re); 
     540 
     541            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     542        } 
     543    } 
     544 
     545    /** 
     546     * This method passes the view's request to add an incident into the 
     547     * simulation on to the remote Coordinator. 
     548     * 
     549     * @param newIncident Incident to add to the simulation 
     550     * @throws SimulationException if there is an error in RMI communication to 
     551     * the CAD Simulator. 
     552     */ 
     553    public void addIncident(final Incident newIncident) throws SimulationException 
     554    { 
     555 
     556        try 
     557        { 
    481558            theCoorInt.addIncident(newIncident); 
    482      
    483         } catch (RemoteException re) { 
    484             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    485                     "addIncident", "Unable to communicate with the " + 
    486                     "CAD Simulator.", re); 
    487              
    488             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    489         }        
    490  
    491     } 
    492      
    493     /** 
    494      * This method passes the view's request to delete an incident from the  
     559 
     560        } catch (RemoteException re) 
     561        { 
     562            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     563                    "addIncident", "Unable to communicate with the " 
     564                    + "CAD Simulator.", re); 
     565 
     566            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     567        } 
     568 
     569    } 
     570 
     571    /** 
     572     * This method passes the view's request to delete an incident from the 
    495573     * simulation on to the remote Coordinator. 
    496574     * 
    497575     * @throws ScriptException if an error occurs in deleting an event. 
    498      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    499      */ 
    500     public void deleteIncident(int logNumber) throws ScriptException, SimulationException { 
    501  
    502         try { 
    503             theCoorInt.deleteIncident(logNumber);    
    504      
    505         } catch (RemoteException re) { 
    506             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    507                     "deleteIncident", "Unable to communicate with the " + 
    508                     "CAD Simulator.", re); 
    509              
    510             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    511         }        
    512     }    
    513      
    514      
    515     /** 
    516      * This method passes the view's request to reschedule an incident on to  
    517      * the remote Coordinator. 
     576     * @throws SimulationException if there is an error in RMI communication to 
     577     * the CAD Simulator. 
     578     */ 
     579    public void deleteIncident(int logNumber) throws ScriptException, SimulationException 
     580    { 
     581 
     582        try 
     583        { 
     584            theCoorInt.deleteIncident(logNumber); 
     585 
     586        } catch (RemoteException re) 
     587        { 
     588            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     589                    "deleteIncident", "Unable to communicate with the " 
     590                    + "CAD Simulator.", re); 
     591 
     592            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     593        } 
     594    } 
     595 
     596    /** 
     597     * This method passes the view's request to reschedule an incident on to the 
     598     * remote Coordinator. 
    518599     * 
    519600     * @param newTime New simulation time (in seconds). 
    520      * @throws ScriptException if the Incident has already started or the time for  
    521      *         recheduling has already passed. 
    522      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    523      */ 
    524      public void rescheduleIncident(long newTime, int logNumber) throws ScriptException, SimulationException { 
    525              
    526         try { 
     601     * @throws ScriptException if the Incident has already started or the time 
     602     * for recheduling has already passed. 
     603     * @throws SimulationException if there is an error in RMI communication to 
     604     * the CAD Simulator. 
     605     */ 
     606    public void rescheduleIncident(long newTime, int logNumber) throws ScriptException, SimulationException 
     607    { 
     608 
     609        try 
     610        { 
    527611            theCoorInt.rescheduleIncident(logNumber, newTime); 
    528         } catch (RemoteException re) { 
    529             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    530                     "rescheduleIncident", "Unable to communicate with the " + 
    531                     "CAD Simulator.", re); 
    532              
    533             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    534         }                
    535      } 
    536       
    537     /** 
    538      * This method passes the view's request to get the current list of  
     612        } catch (RemoteException re) 
     613        { 
     614            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     615                    "rescheduleIncident", "Unable to communicate with the " 
     616                    + "CAD Simulator.", re); 
     617 
     618            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     619        } 
     620    } 
     621 
     622    /** 
     623     * This method passes the view's request to get the current list of 
    539624     * Incidents loaded into the simulation on to the remote Coordinator. 
    540625     * 
    541626     * @return Vector The Vector of currently loaded incidents. 
    542      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    543      */ 
    544     public Vector<Incident> getIncidentList() throws SimulationException { 
    545  
    546         try { 
     627     * @throws SimulationException if there is an error in RMI communication to 
     628     * the CAD Simulator. 
     629     */ 
     630    public Vector<Incident> getIncidentList() throws SimulationException 
     631    { 
     632 
     633        try 
     634        { 
    547635            return theCoorInt.getIncidentList(); 
    548              
    549         } catch (RemoteException re) { 
    550             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    551                     "getIncidentList", "Unable to communicate with the " + 
    552                     "CAD Simulator.", re); 
    553              
    554             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    555         } 
    556     }     
    557               
    558     /** 
    559      * This method passes the view's request to get the CMSInfo object  
    560      * that corresponds to a unique CMS ID String on to the remote Coordinator. 
    561      *  
     636 
     637        } catch (RemoteException re) 
     638        { 
     639            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     640                    "getIncidentList", "Unable to communicate with the " 
     641                    + "CAD Simulator.", re); 
     642 
     643            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     644        } 
     645    } 
     646 
     647    /** 
     648     * This method passes the view's request to get the CMSInfo object that 
     649     * corresponds to a unique CMS ID String on to the remote Coordinator. 
     650     * 
    562651     * @param cms_id Unique CMS ID String. 
    563652     * @return CMSInfo object corresponding to the parameter CMS id. 
    564      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    565      */ 
    566     public CMSInfo getCMSDiversionInfo(String cms_id) throws SimulationException { 
    567          
    568         try { 
     653     * @throws SimulationException if there is an error in RMI communication to 
     654     * the CAD Simulator. 
     655     */ 
     656    public CMSInfo getCMSDiversionInfo(String cms_id) throws SimulationException 
     657    { 
     658 
     659        try 
     660        { 
    569661            return theCoorInt.getCMSDiversionInfo(cms_id); 
    570         } catch (RemoteException re) { 
    571             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    572                     "getCMSDiversionInfo", "Unable to communicate with the " + 
    573                     "CAD Simulator.", re); 
    574              
    575             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    576         } 
    577     } 
    578       
    579     /** 
    580      * This method passes the view's request to update diversions for a 
    581      * CMS on to the remote Coordinator. 
    582      *  
     662        } catch (RemoteException re) 
     663        { 
     664            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     665                    "getCMSDiversionInfo", "Unable to communicate with the " 
     666                    + "CAD Simulator.", re); 
     667 
     668            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     669        } 
     670    } 
     671 
     672    /** 
     673     * This method passes the view's request to update diversions for a CMS on 
     674     * to the remote Coordinator. 
     675     * 
    583676     * @param diversion CMS diversions information to apply. 
    584      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    585      */ 
    586     public void applyDiversions(CMSInfo diversion) throws SimulationException { 
    587          
    588         try { 
     677     * @throws SimulationException if there is an error in RMI communication to 
     678     * the CAD Simulator. 
     679     */ 
     680    public void applyDiversions(CMSInfo diversion) throws SimulationException 
     681    { 
     682 
     683        try 
     684        { 
    589685            theCoorInt.applyDiversions(diversion); 
    590686 
    591         } catch (RemoteException re) { 
    592             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    593                     "applyDiversions", "Unable to communicate with the " + 
    594                     "CAD Simulator.", re); 
    595              
    596             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    597         } 
    598     } 
    599      
    600     /** 
    601      * This method loads the current list of incidents from the Coordinator into the 
    602      * SimulationManager.  For each incident in the simulation, notify the view to 
    603      * add a new incident tab.  If the Incident has begun in the simulation,  
    604      * call the incidentStarted() method to update the view accordingly. 
    605      *  
    606      * @throws SimulationException if there is an error in RMI communication to the CAD Simulator. 
    607      */  
    608     private void loadIncidents() throws SimulationException {        
    609          
    610         try {            
    611             for(Incident inc : theCoorInt.getIncidentList()) { 
    612      
     687        } catch (RemoteException re) 
     688        { 
     689            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     690                    "applyDiversions", "Unable to communicate with the " 
     691                    + "CAD Simulator.", re); 
     692 
     693            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     694        } 
     695    } 
     696 
     697    /** 
     698     * This method loads the current list of incidents from the Coordinator into 
     699     * the SimulationManager. For each incident in the simulation, notify the 
     700     * view to add a new incident tab. If the Incident has begun in the 
     701     * simulation, call the incidentStarted() method to update the view 
     702     * accordingly. 
     703     * 
     704     * @throws SimulationException if there is an error in RMI communication to 
     705     * the CAD Simulator. 
     706     */ 
     707    private void loadIncidents() throws SimulationException 
     708    { 
     709 
     710        try 
     711        { 
     712            for (Incident inc : theCoorInt.getIncidentList()) 
     713            { 
     714 
    613715                Integer logNum = new Integer(inc.getLogNumber()); 
    614                  
     716 
    615717                theSimManagerView.addIncidentTab(logNum); 
    616718                theSimManagerView.addIncident(inc); 
    617              
    618                 if(inc.getSecondsToStart() < theCoorInt.getCurrentSimulationTime()) { 
     719 
     720                if (inc.getSecondsToStart() < theCoorInt.getCurrentSimulationTime()) 
     721                { 
    619722                    incidentStarted(logNum); 
    620723                } 
    621724            } 
    622         } catch (RemoteException re) { 
    623             simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel",  
    624                     "loadIncidentListTable", "Unable to communicate with the " + 
    625                     "CAD Simulator.", re); 
    626              
    627             throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
    628         } 
    629          
    630     } 
    631      
    632  
     725        } catch (RemoteException re) 
     726        { 
     727            simManagerLogger.logp(Level.SEVERE, "SimulationManagerModel", 
     728                    "loadIncidentListTable", "Unable to communicate with the " 
     729                    + "CAD Simulator.", re); 
     730 
     731            throw new SimulationException(SimulationException.CAD_SIM_COMM, re); 
     732        } 
     733 
     734    } 
    633735} 

  • trunk/src/tmcsim/simulationmanager/SimulationManagerView.java

    r2 r6  
    737737        simulationStatus     = new JLabel("Simulation Status"); 
    738738        simulationStatusText = new JLabel("No Script"); 
     739        simulationStatusText.setName("simulationStatusText"); 
    739740        simulationStatusText.setFont(new Font("Geneva", Font.BOLD, 14)); 
    740741         
    … …  
    746747        pauseButton  = new JButton(new PauseSimulationAction(this)); 
    747748        resetButton = new JButton(new ResetSimulationAction(this)); 
     749        loadScriptButton = new JButton(new LoadScriptAction(this)); 
     750        loadScriptButton.setAlignmentX(Box.CENTER_ALIGNMENT); 
    748751         
    749752        startButton.setEnabled(false); 
    … …  
    756759        simulationTimeButtonBox = new Box(BoxLayout.X_AXIS); 
    757760         
     761        simulationTimeButtonBox.add(loadScriptButton); 
    758762        simulationTimeButtonBox.add(startButton); 
    759763        simulationTimeButtonBox.add(pauseButton); 
    760764        simulationTimeButtonBox.add(resetButton); 
     765//        currentScript = new JLabel(" no script loaded"); 
     766        //currentScript.setAlignmentX(Box.LEFT_ALIGNMENT); 
     767//        simulationTimeButtonBox.add (currentScript); 
    761768         
    762769        simulationStatus.setAlignmentX(Box.CENTER_ALIGNMENT); 
    763770        simulationStatusText.setAlignmentX(Box.CENTER_ALIGNMENT); 
    764         simulationStatusText.setName("simulationStatusText"); 
    765771         
    766772        TitledBorder title = BorderFactory.createTitledBorder( 
    … …  
    779785        scriptBox.setAlignmentX(Box.CENTER_ALIGNMENT); 
    780786         
    781         loadScriptButton = new JButton(new LoadScriptAction(this)); 
    782         loadScriptButton.setAlignmentX(Box.CENTER_ALIGNMENT); 
    783          
    784787        scriptBox.add(simulationStatusBox); 
    785788        scriptBox.add(Box.createVerticalStrut(5)); 
    786         scriptBox.add(loadScriptButton); 
    787789         
    788790        simulationClockLabel = new JLabel("0:00:00"); 
    … …  
    800802        simulationTimeAndStatusBox = Box.createHorizontalBox(); 
    801803        simulationTimeAndStatusBox.setAlignmentX(Box.LEFT_ALIGNMENT); 
    802         simulationTimeAndStatusBox.setMaximumSize(new Dimension(640, 200)); 
    803         simulationTimeAndStatusBox.setPreferredSize(new Dimension(640, 160)); 
     804        simulationTimeAndStatusBox.setMaximumSize(new Dimension(640, 300)); 
     805        simulationTimeAndStatusBox.setPreferredSize(new Dimension(640, 1600)); 
    804806        simulationTimeAndStatusBox.add(Box.createHorizontalStrut(5)); 
    805807        simulationTimeAndStatusBox.add(simulationTimeBox); 
    … …  
    12241226    private JLabel timeScheduledLabel; 
    12251227    private JLabel CADClientClockLabel; 
    1226              
     1228    private JLabel currentScript; 
    12271229    private Box adminInteractionBox;     
    12281230    private Box simulationRightSideBox; 

  • trunk/src/tmcsim/simulationmanager/actions/LoadScriptAction.java

    r2 r6  
    5454                    try{  
    5555                        theSimManagerView.getModel().loadScript(selectedFile); 
     56                        theSimManagerView.setTitle("Simulation Manager: " + selectedFile.getName()); 
    5657                    } 
    5758                    catch (ScriptException se) { 
Note: See TracChangeset for help on using the changeset viewer.