Changeset 54 in tmcsimulator for trunk/src/tmcsim/client/CADClockView.java


Ignore:
Timestamp:
03/14/2017 04:20:05 PM (9 years ago)
Author:
jdalbey
Message:

Coordinator.java: updates with error checking for bad input parameters, add CADicon.png, mp3 jar

File:
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/src/tmcsim/client/CADClockView.java

    r37 r54  
    4545/** 
    4646 * The CADClientView class is the view component to the CAD Client application. 
    47  * The CADSCreen is displayed with three separate view components: Command Line, 
    48  * Main Text Area, and Footer.  User input is handled by the Command Line Pane. 
    49  * Any commands are sent to the model which are then transmitted to the 
    50  * CAD Simulator.  The view keeps track of current CAD Screen Number and the 
    51  * current page being displayed on each screen.  This allows for the screen 
    52  * refresh and cycle commands to return the screen to its previous page.  
    53  *  
     47 * 
    5448 * This view class observers the CADClientModel, listening for updates 
    55  * from the CAD Simulator.  Updates include new CADScreenModel objects notifying  
    56  * that a new screen is to be displayed.  Other update data includes the current  
    57  * CAD time, number of routed messages, screen update map, and information messages.   
    58  * These are all displayed in the CAD Footer. 
    59  *  
    60  * @author Matthew Cechini (mcechini@calpoly.edu) 
    61  * @version $Date: 2009/04/20 17:58:27 $ $Revision: 1.7 $ 
    62  */ 
     49 * from the CAD Simulator.  Updates includes the current  
     50 * CAD time  */ 
    6351@SuppressWarnings("serial") 
    64 public class CADClientView extends JFrame implements KeyListener, Observer { 
     52public class CADClockView extends JFrame implements KeyListener, Observer { 
    6553     
    6654    /** Error Logger. */ 
    … …  
    6957    /** Reference to the CADClient model object. */ 
    7058    private CADClientModel theModel = null; 
    71        
    72     /** View pane for the CAD Screen command line area. */ 
    73     private CADCommandLineView CADCommandLinePane = null; 
    74        
    75     /** View pane for the CAD Screen main area. */ 
    76     private CADMainView        CADMainPane        = null; 
    77        
    78     /** View pane for the CAD Screen footer area. */ 
    79     private CADFooterView      CADFooterPane      = null;     
    80      
    81     /** CAD Command Line Parser.  */ 
    82     private CADCommandParser cmdParser; 
    83  
    84     /** Boolean flag to designate whether the shift key is being pressed. */ 
    85     private boolean shiftKeyPressed = false; 
    86            
     59               
    8760    /** Current CAD Screen number. */ 
    8861    private CADScreenNum currentScreenNum = null; 
    8962     
    90     /** Map of CADScreen numbers and the current page displayed on that screen. */ 
    91     private TreeMap<CADScreenNum, Integer> pageLocationMap = null; 
    92      
    93     /** Flag designating whether the screen's page location has been saved. */ 
    94     private boolean pageLocationSaved = false; 
    9563 
    9664    /** 
    … …  
    10169     *            The CAD position for this client terminal. 
    10270     */ 
    103     public CADClientView(CADClientModel mod) { 
     71    public CADClockView(CADClientModel mod) { 
    10472        super("CAD Client"); 
    10573        theModel = mod; 
    10674         
    107          
    108         cmdParser = new CADCommandParser(); 
    109          
    110         //Build and initialize all initial screens to the first page. 
    111         pageLocationMap = new TreeMap<CADScreenNum, Integer>(); 
    112         for(CADScreenNum screen : CADScreenNum.values())  
    113         { 
    114             pageLocationMap.put(screen, 1); 
    115         } 
    116          
    117         currentScreenNum = CADScreenNum.orderedList().get(0); 
    118          
    119         buildPanes();        
    120         buildPanels(); 
    121  
    122         cmdLineTextPane.addKeyListener(this); 
    123         mainTextPane.addKeyListener(this); 
    124         footerTextPane.addKeyListener(this); 
    125      
    126  
    127         CADMainPane.addObserver(CADFooterPane); 
    128          
    129     } 
    130      
    131     /** 
    132      * Build the command line, main, and footer text panes. 
    133      */ 
    134     private void buildPanes() { 
    135  
    136         cmdLineTextPane    = new JTextPane(); 
    137         cmdLineTextPane.setSize(new Dimension(730, 50));  
    138         cmdLineTextPane.setMinimumSize(new Dimension(730, 50)); 
    139         cmdLineTextPane.setMaximumSize(new Dimension(730, 50)); 
    140         cmdLineTextPane.setBorder(BorderFactory.createLineBorder(Color.black)); 
    141  
    142         cmdLineTextPane.setBackground(Color.black); 
    143         cmdLineTextPane.setEditable(false); 
    144         CADCommandLinePane = new CADCommandLineView(cmdLineTextPane); 
    145          
    146         mainTextPane = new JTextPane(); 
    147         mainTextPane.setSize(new Dimension(730, 455)); 
    148         mainTextPane.setMaximumSize(new Dimension(730, 455)); 
    149         mainTextPane.setMinimumSize(new Dimension(730, 455)); 
    150         mainTextPane.setBorder(BorderFactory.createLineBorder(Color.black));    
    151         mainTextPane.setBackground(Color.black); 
    152         mainTextPane.setEditable(false);   
    153         CADMainPane  = new CADMainView(mainTextPane.getDocument());       
    154  
    155         footerTextPane = new JTextPane(); 
    156         footerTextPane.setSize(new Dimension(730, 95));  
    157         footerTextPane.setMaximumSize(new Dimension(730, 95)); 
    158         footerTextPane.setMinimumSize(new Dimension(730, 95)); 
    159         footerTextPane.setBorder(BorderFactory.createLineBorder(Color.black));     
    160         footerTextPane.setBackground(Color.black); 
    161         footerTextPane.setEditable(false); 
    162         CADFooterPane  = new CADFooterView(footerTextPane.getDocument()); 
    163     } 
    164      
    165      
    166     /** 
    167      * Build the command line, main, and footer panels. 
    168      */ 
    169     private void buildPanels() { 
    170          
    171         cmdLinePanel = new JPanel(); 
    172         cmdLinePanel.setSize(new Dimension(800, 50));  
    173         cmdLinePanel.setMinimumSize(new Dimension(800, 50)); 
    174         cmdLinePanel.setMaximumSize(new Dimension(800, 50)); 
    175         cmdLinePanel.setBackground(Color.black); 
    176          
    177         Box cmdLineBox = new Box(BoxLayout.Y_AXIS); 
    178         cmdLineBox.add(Box.createHorizontalStrut(35)); 
    179         cmdLineBox.add(cmdLineTextPane); 
    180         cmdLineBox.add(Box.createHorizontalStrut(35)); 
    181          
    182         cmdLinePanel.add(cmdLineBox); 
    183          
    184         //***************************************************// 
    185          
    186         mainPanel    = new JPanel(); 
    187         mainPanel.setSize(new Dimension(800, 455));  
    188         mainPanel.setMaximumSize(new Dimension(800, 455)); 
    189         mainPanel.setMinimumSize(new Dimension(800, 455)); 
    190         mainPanel.setBackground(Color.black); 
    191         
    192          
    193         Box mainBox = new Box(BoxLayout.Y_AXIS); 
    194         mainBox.add(Box.createHorizontalStrut(35)); 
    195         mainBox.add(mainTextPane); 
    196         mainBox.add(Box.createHorizontalStrut(35)); 
    197          
    198         mainPanel.add(mainBox); 
    199  
    200         //***************************************************// 
    201          
    202         footerPanel  = new JPanel();         
    203         footerPanel.setSize(new Dimension(800, 95));  
    204         footerPanel.setMaximumSize(new Dimension(800, 95)); 
    205         footerPanel.setMinimumSize(new Dimension(800, 95)); 
    206         footerPanel.setBackground(Color.black); 
    207          
    208         Box footerBox = new Box(BoxLayout.Y_AXIS); 
    209         footerBox.add(Box.createHorizontalStrut(35)); 
    210         footerBox.add(footerTextPane); 
    211         footerBox.add(Box.createHorizontalStrut(35)); 
    212          
    213         footerPanel.add(footerBox); 
    214          
    215     } 
    216          
    217      
    218     /** 
    219      * Method adds the three CAD Screen components (CommandLine, MainTextArea,  
    220      * Footer) to this view class.  The background is set to black, resized 
    221      * to 800x600, and shown to the screen. 
    222      */ 
    223     public void initWindow() { 
    224         add(initBox()); 
    225  
    226         addKeyListener(this); 
    227         setBackground(Color.black);      
    228         setSize(new Dimension(800, 600)); 
    229         setUndecorated(true);   
    230         setDefaultCloseOperation(EXIT_ON_CLOSE); 
    231         //setVisible(true);        
    232                  
    233     } 
    234      
    235     /** 
    236      * Method contructs a box out of the three CAD Screen components: 
    237      * CommandLine, MainTextArea, Footer.  The Command Line panel is placed 
    238      * above the main text area panel, which is above the footer panel. 
    239      * 
    240      * @return Box Box containing all three panels. 
    241      */ 
    242     public Box initBox() { 
    243         Box theBox = new Box(BoxLayout.Y_AXIS); 
    244         theBox.add(cmdLinePanel); 
    245         theBox.add(mainPanel); 
    246         theBox.add(footerPanel);     
    247         theBox.setBackground(Color.black); 
    248          
    249         return theBox; 
    250     } 
    251  
    252     /**   
    253      * This method is called by the implemented KeyListener whenever a key is pressed.  The following 
    254      * keystrokes are listened for in this method.  Each keystroke pressed is referenced by the keycode  
    255      * for the associated key.  These key codes are defined in the CADProtocol class. 
    256      * 
    257      *  
    258      *<table cellpadding="2" cellspacing="2" border="1" 
    259      * style="text-align: left; width: 250px;"> 
    260      *  <tbody> 
    261      *    <tr> 
    262      *      <th>CAD Protocol Command<br></th> 
    263      *      <th>Action Taken<br></th> 
    264      *    </tr> 
    265      *    <tr> 
    266      *      <td>SHIFT_KEY<br></td> 
    267      *      <td>Set shiftKeyPressed flag to true.<br></td> 
    268      *    </tr> 
    269      *    <tr> 
    270      *      <td>COMMAND_LINE_CLEAR<br></td> 
    271      *      <td>If the shift key is pressed, clear the current CAD Screen's command line.<br></td> 
    272      *    </tr> 
    273      *    <tr> 
    274      *      <td>SCREEN_CLEAR<br></td> 
    275      *      <td>If the shift key is pressed, transmit the SCREEN_CLEAR 
    276      *          command as a TERMINAL_FUNCTION to the CAD Simulator<br></td> 
    277      *   </tr> 
    278      *  </tbody> 
    279      *</table> 
    280      * 
    281      * @param e KeyEvent 
    282      */ 
    283     public void keyPressed(KeyEvent evt) {  
    284        //System.out.println("keyPressed" + evt.getKeyCode());    
    285         
    286         switch(CAD_KEYS.fromValue(CAD_KEYS.keyboard_type, evt.getKeyCode())) {   
    287             case  SHIFT_KEY:  
    288                 shiftKeyPressed = true; 
    289                 break;  
    290                  
    291             case COMMAND_LINE_CLEAR:         
    292                 if(shiftKeyPressed)  { 
    293                     CADCommandLinePane.clearCommandLine(); 
    294                 } 
    295                 break; 
    296      
    297             case SCREEN_CLEAR:      
    298                 if(shiftKeyPressed) {           
    299                     try { 
    300                         Document cmdDoc = DocumentBuilderFactory.newInstance() 
    301                             .newDocumentBuilder().newDocument(); 
    302                         Element cmdElem = cmdDoc.createElement( 
    303                                 CAD_CLIENT_CMD.TERMINAL_FUNCTION.type);                  
    304                         cmdElem.appendChild(cmdDoc.createTextNode( 
    305                                 CAD_KEYS.keyboard_type + ":" +  
    306                                 String.valueOf(evt.getKeyCode())));                  
    307                         cmdDoc.appendChild(cmdElem);             
    308                         theModel.transmitCommand(cmdDoc);                            
    309                     } catch (Exception e) { 
    310                         cadLogger.logp(Level.SEVERE, "CADClientView", "keyPressed()", 
    311                                 "Exception in sending screen clear command.", e); 
    312                     } 
    313                 } 
    314                 break;       
    315         } 
    316     } 
    317          
    318     /** 
    319      * This method is called by the implemented KeyListener whenever a key is released.  The following 
    320      * keystrokes are listened for in this method.  Each keystroke released is referenced by the keycode  
    321      * for the associated key.  These key codes are defined in the CADProtocol class. 
    322      * 
    323      *<table cellpadding="2" cellspacing="2" border="1" 
    324      * style="text-align: left; width: 250px;"> 
    325      *  <tbody> 
    326      *    <tr> 
    327      *      <th>CAD Protocol Command<br></th> 
    328      *      <th>Action Taken<br></th> 
    329      *    </tr> 
    330      *    <tr> 
    331      *      <td>SHIFT_KEY<br></td> 
    332      *      <td>Set the shiftKeyPressed flag to false.<br></td> 
    333      *    </tr> 
    334      *    <tr> 
    335      *      <td>CYCLE<br></td> 
    336      *      <td>Preserve the current page number to return the screen to the same location after  
    337      *          the cycle.  Transmit the current command line to the CAD Simulator with a  
    338      *          SAVE_COMMAND_LINE message type.  Transmit the CYCLE command as a  
    339      *          TERMINAL_FUNCTION to the CAD Simulator.<br></td> 
    340      *    </tr> 
    341      *    <tr> 
    342      *      <td>REFRESH<br></td> 
    343      *      <td>Preserve the current page number to return the screen to the same location after  
    344      *          the refresh.  Transmit the current command line to the CAD Simulator with a  
    345      *          SAVE_COMMAND_LINE message type.  Transmit the CYCLE command as a  
    346      *          TERMINAL_FUNCTION to the CAD Simulator.<br></td> 
    347      *    </tr> 
    348      *    <tr> 
    349      *      <td>PGDN</td> 
    350      *      <td>Notify the main pane object of the received page down command.<br></td> 
    351      *    </tr> 
    352      *    <tr> 
    353      *      <td>PGUP</td> 
    354      *      <td>Notify the main pane object of the received page up command.<br> </td> 
    355      *    </tr> 
    356      *    <tr> 
    357      *      <td>LEFT_ARROW</td> 
    358      *      <td>Notify the command line pane object of the received left arrow.<br> </td> 
    359      *    </tr> 
    360      *    <tr> 
    361      *      <td>UP_ARROW</td> 
    362      *      <td>Notify the command line pane object of the received up arrow.<br> </td> 
    363      *    </tr> 
    364      *    <tr> 
    365      *      <td>RIGHT_ARROW</td> 
    366      *      <td>Notify the command line pane object of the received right arrow.<br> </td> 
    367      *    </tr> 
    368      *    <tr> 
    369      *      <td>DOWN_ARROW</td> 
    370      *      <td>Notify the command line pane object of the received down arrow.<br> </td> 
    371      *    </tr> 
    372      *    <tr> 
    373      *      <td>COMMAND_LINE_TX<br> </td> 
    374      *      <td>Parse the current command line and create an XMLWriter with the  
    375      *          converted XML representation of the command line data. 
    376      *          Transmit the command line as a TERMINAL_CMD_LINE message to  
    377      *          the CAD Simulator.  Clear the current CAD screen's command line. 
    378      *          If there is an error in parsing, show the corresponding error 
    379      *          message and clear the command line.<br></td> 
    380      *    </tr> 
    381      *    <tr> 
    382      *      <td>NEXT_QUEUE<br></td> 
    383      *      <td>Transmit the NEXT_QUEUE command as a TERMINAL_FUNCTION to the CAD Simulator.<br></td> 
    384      *    </tr> 
    385      *    <tr> 
    386      *      <td>DELETE_QUEUE<br></td> 
    387      *      <td>Transmit the DELETE_QUEUE command as a TERMINAL_FUNCTION to the CAD Simulator.<br></td> 
    388      *    </tr> 
    389      *    <tr> 
    390      *      <td>PREV_QUEUE<br></td> 
    391      *      <td>Transmit the PREV_QUEUE command as a TERMINAL_FUNCTION to the CAD Simulator.<br></td> 
    392      *    </tr> 
    393      *    <tr> 
    394      *      <td>BACKSPACE<br></td> 
    395      *      <td>Notify the command line pane of the received backspace command.<br></td> 
    396      *    </tr> 
    397      *    <tr> 
    398      *      <td>ENTER<br></td> 
    399      *      <td>Currently, do nothing<br></td> 
    400      *    </tr> 
    401      *  </tbody> 
    402      *</table> 
    403      * 
    404      * @param e KeyEvent 
    405      */         
    406     public void keyReleased(KeyEvent evt) { 
    407        //System.out.println("keyReleased" + evt.getKeyCode());        
    408          
    409         switch(CAD_KEYS.fromValue(CAD_KEYS.keyboard_type, evt.getKeyCode())) {   
    410              
    411             case  SHIFT_KEY:  
    412                 shiftKeyPressed = false; 
    413                 break;  
    414  
    415             case REFRESH: 
    416             case CYCLE:  
    417  
    418                 pageLocationSaved = true; 
    419                 pageLocationMap.put(currentScreenNum, CADMainPane.getCurrentPage()); 
    420  
    421                 try { 
    422                     Document cmdDoc = DocumentBuilderFactory.newInstance() 
    423                             .newDocumentBuilder().newDocument(); 
    424                     Element cmdElem = cmdDoc.createElement( 
    425                             CAD_CLIENT_CMD.SAVE_COMMAND_LINE.type);                  
    426                     cmdElem.appendChild(cmdDoc.createTextNode( 
    427                             CADCommandLinePane.getCommandLine())); 
    428                     cmdDoc.appendChild(cmdElem);                                     
    429                     theModel.transmitCommand(cmdDoc); 
    430                                          
    431                     cmdDoc = DocumentBuilderFactory.newInstance() 
    432                             .newDocumentBuilder().newDocument(); 
    433                     cmdElem = cmdDoc.createElement( 
    434                             CAD_CLIENT_CMD.TERMINAL_FUNCTION.type);                  
    435                     cmdElem.appendChild(cmdDoc.createTextNode( 
    436                             CAD_KEYS.keyboard_type + ":" +  
    437                             String.valueOf(evt.getKeyCode())));                  
    438                     cmdDoc.appendChild(cmdElem);             
    439                     theModel.transmitCommand(cmdDoc);            
    440                      
    441                 } catch (Exception e) { 
    442                     cadLogger.logp(Level.SEVERE, "CADClientView",  
    443                             "keyReleased()", 
    444                             "Exception in sending cycle command.", e); 
    445                 } 
    446                 break;                   
    447              
    448             case PGDN: 
    449                 
    450                CADMainPane.pageDown(); 
    451                break; 
    452              
    453             case PGUP:  
    454              
    455                CADMainPane.pageUp(); 
    456                break;   
    457                 
    458             case LEFT_ARROW:  
    459              
    460                CADCommandLinePane.receiveArrow(ARROW.LEFT); 
    461                break;   
    462                 
    463             case UP_ARROW:  
    464              
    465                CADCommandLinePane.receiveArrow(ARROW.UP); 
    466                break;   
    467      
    468             case RIGHT_ARROW:  
    469              
    470                CADCommandLinePane.receiveArrow(ARROW.RIGHT); 
    471                break;   
    472      
    473             case DOWN_ARROW:  
    474              
    475                CADCommandLinePane.receiveArrow(ARROW.DOWN); 
    476                break;                                                   
    477      
    478             case COMMAND_LINE_TX: 
    479                     
    480                 try { 
    481                     Document cmdDoc = DocumentBuilderFactory.newInstance() 
    482                         .newDocumentBuilder().newDocument(); 
    483                     Element cmdElem = cmdDoc.createElement(CAD_CLIENT_CMD.TERMINAL_CMD_LINE.type); 
    484                      
    485                     cmdParser.parseCommand(cmdElem, CADCommandLinePane.getCommandLine()); 
    486                     cmdDoc.appendChild(cmdElem); 
    487                  
    488                     theModel.transmitCommand(cmdDoc); 
    489              
    490                     CADCommandLinePane.clearCommandLine(); 
    491  
    492                     pageLocationSaved = false; 
    493                 } 
    494                 catch (Exception ex) { 
    495                     CADFooterPane.displayInfoMessage(CAD_ERROR.UNAUTH_CMD.message); 
    496                     CADCommandLinePane.clearCommandLine(); 
    497                 } 
    498                 break;   
    499      
    500             case PREV_QUEUE: 
    501             case DELETE_QUEUE: 
    502             case NEXT_QUEUE: 
    503                 try { 
    504                     Document cmdDoc = DocumentBuilderFactory.newInstance() 
    505                             .newDocumentBuilder().newDocument(); 
    506                     Element cmdElem = cmdDoc.createElement( 
    507                             CAD_CLIENT_CMD.TERMINAL_FUNCTION.type); 
    508                                          
    509                     cmdElem.appendChild(cmdDoc.createTextNode( 
    510                             CAD_KEYS.keyboard_type + ":" +  
    511                             String.valueOf(evt.getKeyCode()))); 
    512                     cmdDoc.appendChild(cmdElem);                     
    513                     theModel.transmitCommand(cmdDoc); 
    514      
    515                 } catch (Exception e) { 
    516                     cadLogger.logp(Level.SEVERE, "CADClientView", "keyReleased()", 
    517                             "Exception in sending queue command.", e); 
    518                 } 
    519                 break; 
    520  
    521             case BACKSPACE: 
    522                CADCommandLinePane.backspace(); 
    523                break;        
    524             case ENTER:                    
    525                 break; 
    526             default:   
    527         } 
    528                  
    529     } 
    530  
    531     /** 
    532      * This method implements the necessary KeyListener functionality, and is  
    533      * called whenever a key is typed.  Only letters, numbers, and standard  
    534      * keyboard symbols, whose ascii value is between 32(inclusive) and  
    535      * 127(exclusive).  Lower case character are in the range between 97 and  
    536      * 122, inclusive.  These characters are made uppercase by substracting  
    537      * 32 from their ascii value.  The ascii value for an upper case character  
    538      * is 32 less than its lower case representation.  The valid character  
    539      * is then sent to the CADCommandLinePane. 
    540      * 
    541      * @param e KeyEvent received. 
    542      */ 
    543     public void keyTyped(KeyEvent e) { 
    544         //System.out.println("keyTyped" + e.getKeyCode()); 
    545          
    546         char key = e.getKeyChar(); 
    547         //if valid character 
    548         if(key >= 32 && key < 127) { 
    549             //lower case letter 
    550             if(key >= 97 && key <= 122) 
    551                 key -= 32; //make uppercase 
    552              
    553             CADCommandLinePane.receiveKeyPress(key);                 
    554              
    555         } 
    55675    } 
    55776 
    … …  
    57291     *    </tr> 
    57392     *    <tr> 
    574      *      <td>INCIDENT_INQUIRY<br></td> 
    575      *      <td>IncidentInquiryModel<br></td> 
    576      *      <td>Construct a new II_IncidentInquiry view pane from the model data. 
    577      *          Reset the observer relationship between the footer and main pane. 
    578      *          Update the page location map and update the views with the model data. 
    579      *      </td> 
    580      *    </tr> 
    581      *    <tr> 
    582      *      <td>INCIDENT_SUMMARY<br></td> 
    583      *      <td>IncidentSummaryModel<br></td> 
    584      *      <td>Construct a new SA_IncidentSummary view pane from the model data. 
    585      *          Reset the observer relationship between the footer and main pane. 
    586      *          Update the page location map and update the views with the model data. 
    587      *      </td> 
    588      *    </tr> 
    589      *    <tr> 
    590      *      <td>INCIDENT_BOARD<br></td> 
    591      *      <td>IncidentBoardModel<br></td> 
    592      *      <td>Construct a new IB_IncidentBoard view pane from the model data. 
    593      *          Reset the observer relationship between the footer and main pane. 
    594      *          Update the page location map and update the views with the model data. 
    595      *      </td> 
    596      *    </tr> 
    597      *    <tr> 
    598      *      <td>ROUTED_MESSAGE<br></td> 
    599      *      <td>RoutedMessageModel<br></td> 
    600      *      <td>Construct a new TO_RoutedMessage view pane from the model data. 
    601      *          Reset the observer relationship between the footer and main pane. 
    602      *          Update the page location map and update the views with the model data. 
    603      *      </td> 
    604      *    </tr> 
    605      *    <tr> 
    606      *      <td>BLANK_SCREEN<br></td> 
    607      *      <td>BlankScreenModel<br></td> 
    608      *      <td>Construct a new empty view pane. 
    609      *          Reset the observer relationship between the footer and main pane. 
    610      *          Update the page location map and update the views with the model data. 
    611      *      </td> 
    612      *    </tr> 
    613      *    <tr> 
    614      *      <td>SCREEN_UPDATE<br></td> 
    615      *      <td>TreeMap<CADScreenNum, Boolean><br></td> 
    616      *      <td>Update the footer pane with the new screen updates map.</td> 
    617      *    </tr> 
    618      *    <tr> 
    61993     *      <td>TIME_UPDATE<br></td> 
    62094     *      <td>Time String<br></td> 
    62195     *      <td>Update the footer pane with the new time.</td> 
    622      *    </tr> 
    623      *    <tr> 
    624      *      <td>ROUTED_MESSAGE_COUNT_UPDATE<br></td> 
    625      *      <td># Routed Messages<br></td> 
    626      *      <td>Update the footer pane with the new number of routed messages.</td> 
    627      *    </tr> 
    628      *    <tr> 
    629      *      <td>ROUTED_MESSAGE_UNREAD_UPDATE<br></td> 
    630      *      <td>Unread Routed Messages Boolean<br></td> 
    631      *      <td>Update the footer pane with the unread messages boolean.</td> 
    632      *    </tr> 
    633      *    <tr> 
    634      *      <td>CAD_INFO_MESSAGE<br></td> 
    635      *      <td>Information message<br></td> 
    636      *      <td>Update the footer pane with the new info message.</td> 
    63796     *    </tr> 
    63897     *  </tbody> 
    … …  
    654113     
    655114        switch(oMessage.type) { 
    656             case INCIDENT_INQUIRY: 
    657                 IncidentInquiryModel iiModel = (IncidentInquiryModel)oMessage.value; 
    658                  
    659                 CADMainPane   = new II_IncidentInquiry(iiModel, mainTextPane.getDocument()); 
    660                 CADMainPane.addObserver(CADFooterPane); 
    661                  
    662                 if(!pageLocationSaved) 
    663                     pageLocationMap.put(currentScreenNum, CADMainPane.getCurrentPage()); 
    664                  
    665                 updateViews(iiModel);                
    666                  
    667                 break; 
    668                  
    669             case INCIDENT_SUMMARY: 
    670                 IncidentSummaryModel isModel = (IncidentSummaryModel)oMessage.value; 
    671                  
    672                 CADMainPane   = new SA_IncidentSummary(isModel, mainTextPane.getDocument()); 
    673                 CADMainPane.addObserver(CADFooterPane); 
    674                  
    675                 if(!pageLocationSaved) 
    676                     pageLocationMap.put(currentScreenNum, CADMainPane.getCurrentPage()); 
    677                  
    678                 updateViews(isModel); 
    679                 break; 
    680                  
    681             case INCIDENT_BOARD: 
    682                 IncidentBoardModel ibModel = (IncidentBoardModel)oMessage.value; 
    683              
    684                 CADMainPane   = new IB_IncidentBoard(ibModel, mainTextPane.getDocument()); 
    685                 CADMainPane.addObserver(CADFooterPane);      
    686                  
    687                 if(!pageLocationSaved) 
    688                     pageLocationMap.put(currentScreenNum, CADMainPane.getCurrentPage()); 
    689                  
    690                 updateViews(ibModel); 
    691                 break; 
    692                  
    693             case ROUTED_MESSAGE: 
    694                 RoutedMessageModel rmModel = (RoutedMessageModel)oMessage.value; 
    695              
    696                 CADMainPane = new TO_RoutedMessage(rmModel, mainTextPane.getDocument()); 
    697                 CADMainPane.addObserver(CADFooterPane); 
    698                  
    699                 if(!pageLocationSaved) 
    700                     pageLocationMap.put(currentScreenNum, CADMainPane.getCurrentPage()); 
    701                  
    702                 updateViews(rmModel); 
    703                 break; 
    704                  
    705             case BLANK_SCREEN: 
    706                 BlankScreenModel bsModel = (BlankScreenModel)oMessage.value; 
    707                  
    708                 CADMainPane = new CADMainView(mainTextPane.getDocument()); 
    709                 CADMainPane.addObserver(CADFooterPane);  
    710  
    711                 if(!pageLocationSaved) 
    712                     pageLocationMap.put(currentScreenNum, CADMainPane.getCurrentPage()); 
    713                  
    714                 updateViews(bsModel); 
    715                 break;               
    716                  
    717             case SCREEN_UPDATE: 
    718                 CADFooterPane.updateStatus(CADScreenModel.updateStringToMap( 
    719                         (String)oMessage.value)); 
    720                 break; 
    721                  
    722115            case TIME_UPDATE: 
    723                 CADFooterPane.updateTime((String)oMessage.value);            
    724                 break; 
    725                  
    726             case ROUTED_MESSAGE_COUNT_UPDATE: 
    727                 CADFooterPane.updateRoutedMessageCount((Integer)oMessage.value); 
    728                 break; 
    729                  
    730             case ROUTED_MESSAGE_UNREAD_UPDATE: 
    731                 CADFooterPane.updateUnreadMessages((Boolean)oMessage.value); 
    732                 break; 
    733                  
    734             case CAD_INFO_MESSAGE: 
    735                 CADFooterPane.displayInfoMessage((String)oMessage.value); 
     116                System.out.println("CAD time is now" + (String)oMessage.value);            
    736117                break; 
    737118        }            
    738119    } 
     120 
     121    @Override 
     122    public void keyTyped(KeyEvent e) 
     123    { 
     124        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
     125    } 
     126 
     127    @Override 
     128    public void keyPressed(KeyEvent e) 
     129    { 
     130        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
     131    } 
     132 
     133    @Override 
     134    public void keyReleased(KeyEvent e) 
     135    { 
     136        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
     137    } 
    739138     
    740139    
    741     /** 
    742      * Update the command line and footer pane with model 
    743      * data.  Then refresh all of the views to repaint the screen. 
    744      *  
    745      * @param model CADScreenModel shown in main Pane. 
    746      */ 
    747     private void updateViews(CADScreenModel model) { 
    748                  
    749         currentScreenNum = model.getScreenNum(); 
    750          
    751         CADCommandLinePane.setCommandLine(model.commandLine); 
    752  
    753         CADFooterPane.setCADScreenNum(model.getScreenNum());         
    754         CADFooterPane.updateTime(CADScreenModel.theCADTime); 
    755         CADFooterPane.updateDate(CADScreenModel.theCADDate);         
    756         CADFooterPane.updateStatus(model.screenUpdateMap); 
    757         CADFooterPane.updateRoutedMessageCount(model.numberRoutedMessages);  
    758         CADFooterPane.updateUnreadMessages(model.unreadMessages);        
    759          
    760         CADCommandLinePane.refreshView(); 
    761         CADMainPane.refreshView(pageLocationMap.get(currentScreenNum)); 
    762         CADFooterPane.refreshView(); 
    763          
    764     } 
    765      
    766     /* SWING OBJECTS */        
    767      
    768     private JTextPane cmdLineTextPane = null; 
    769     private JTextPane mainTextPane    = null; 
    770     private JTextPane footerTextPane  = null; 
    771      
    772     private JPanel cmdLinePanel = null; 
    773     private JPanel mainPanel    = null; 
    774     private JPanel footerPanel  = null; 
    775      
    776140     
    777141}     
Note: See TracChangeset for help on using the changeset viewer.