source: tmcsimulator/trunk/src/tmcsim/client/CADClientView.java @ 124

Revision 124, 29.9 KB checked in by jdalbey, 9 years ago (diff)

CADClientVew.java Changed to action when server drops to hard exit because Windows was just hanging the app. More renaming.
Line 
1package tmcsim.client;
2
3import java.awt.Color;
4import java.awt.Dimension;
5import java.awt.event.KeyEvent;
6import java.awt.event.KeyListener;
7import java.util.Observable;
8import java.util.Observer;
9import java.util.TreeMap;
10import java.util.logging.Level;
11import java.util.logging.Logger;
12
13import javax.swing.BorderFactory;
14import javax.swing.Box;
15import javax.swing.BoxLayout;
16import javax.swing.JFrame;
17import javax.swing.JOptionPane;
18import javax.swing.JPanel;
19import javax.swing.JTextPane;
20import javax.xml.parsers.DocumentBuilderFactory;
21
22import org.w3c.dom.Document;
23import org.w3c.dom.Element;
24
25import tmcsim.cadmodels.BlankScreenModel;
26import tmcsim.cadmodels.CADScreenModel;
27import tmcsim.cadmodels.IncidentBoardModel;
28import tmcsim.cadmodels.IncidentInquiryModel;
29import tmcsim.cadmodels.IncidentSummaryModel;
30import tmcsim.cadmodels.RoutedMessageModel;
31import tmcsim.client.cadscreens.IB_IncidentBoard;
32import tmcsim.client.cadscreens.II_IncidentInquiry;
33import tmcsim.client.cadscreens.SA_IncidentSummary;
34import tmcsim.client.cadscreens.TO_RoutedMessage;
35import tmcsim.client.cadscreens.view.CADCommandLineView;
36import tmcsim.client.cadscreens.view.CADFooterView;
37import tmcsim.client.cadscreens.view.CADMainView;
38import tmcsim.common.ObserverMessage;
39import tmcsim.common.CADEnums.ARROW;
40import tmcsim.common.CADEnums.CADScreenNum;
41import tmcsim.common.CADEnums.CAD_ERROR;
42import tmcsim.common.CADEnums.CAD_KEYS;
43import tmcsim.common.CADProtocol.CAD_CLIENT_CMD;
44
45/**
46 * 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 Server.  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 *
54 * 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 */
63@SuppressWarnings("serial")
64public class CADClientView extends JFrame implements KeyListener, Observer {
65   
66    /** Error Logger. */
67    private static Logger cadLogger = Logger.getLogger("tmcsim.client");
68   
69    /** Reference to the CADClient model object. */
70    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         
87    /** Current CAD Screen number. */
88    private CADScreenNum currentScreenNum = null;
89   
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;
95
96    /**
97     * Constructor. Build panes, add key listeners, and set up observer
98     * relationship between the footer and main panes.
99     *
100     * @param position
101     *            The CAD position for this client terminal.
102     */
103    public CADClientView(CADClientModel mod) {
104        super("CAD Client");
105        theModel = mod;
106       
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        }
556    }
557
558    /**
559     * Observable update method.  The CADClientView class is an observer of the
560     * CADClientModel.  If the model sends a null object, it is signifying that
561     * it has shut down.  In this case, an error message should be shown to prompt
562     * the user to restart the CAD Client.  If the update object is an
563     * ObserverMessage object, the following actions are to be taken:
564     *
565     *<table cellpadding="2" cellspacing="2" border="1"
566     * style="text-align: left; width: 250px;">
567     *  <tbody>
568     *    <tr>
569     *      <th>Message Type</th>
570     *      <th>Message Data</th>
571     *      <th>Action Taken</th>
572     *    </tr>
573     *    <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>
619     *      <td>TIME_UPDATE<br></td>
620     *      <td>Time String<br></td>
621     *      <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>
637     *    </tr>
638     *  </tbody>
639     *</table>
640     */
641    public void update(Observable o, Object arg) {
642       
643       
644        if(arg == null) 
645        {
646            JOptionPane.showMessageDialog(this, 
647                    "Connection to the CAD Server has been lost.  " +
648                    "Restart the CAD Client.", "Connection Error", 
649                    JOptionPane.ERROR_MESSAGE); 
650            //return;
651            // Changed to hard exit because Windows was hanging here
652            System.exit(-1);
653        }
654       
655        ObserverMessage oMessage = (ObserverMessage)arg;
656   
657        switch(oMessage.type) {
658            case INCIDENT_INQUIRY:
659                IncidentInquiryModel iiModel = (IncidentInquiryModel)oMessage.value;
660               
661                CADMainPane   = new II_IncidentInquiry(iiModel, mainTextPane.getDocument());
662                CADMainPane.addObserver(CADFooterPane);
663               
664                if(!pageLocationSaved)
665                    pageLocationMap.put(currentScreenNum, CADMainPane.getCurrentPage());
666               
667                updateViews(iiModel);               
668               
669                break;
670               
671            case INCIDENT_SUMMARY:
672                IncidentSummaryModel isModel = (IncidentSummaryModel)oMessage.value;
673               
674                CADMainPane   = new SA_IncidentSummary(isModel, mainTextPane.getDocument());
675                CADMainPane.addObserver(CADFooterPane);
676               
677                if(!pageLocationSaved)
678                    pageLocationMap.put(currentScreenNum, CADMainPane.getCurrentPage());
679               
680                updateViews(isModel);
681                break;
682               
683            case INCIDENT_BOARD:
684                IncidentBoardModel ibModel = (IncidentBoardModel)oMessage.value;
685           
686                CADMainPane   = new IB_IncidentBoard(ibModel, mainTextPane.getDocument());
687                CADMainPane.addObserver(CADFooterPane);     
688               
689                if(!pageLocationSaved)
690                    pageLocationMap.put(currentScreenNum, CADMainPane.getCurrentPage());
691               
692                updateViews(ibModel);
693                break;
694               
695            case ROUTED_MESSAGE:
696                RoutedMessageModel rmModel = (RoutedMessageModel)oMessage.value;
697           
698                CADMainPane = new TO_RoutedMessage(rmModel, mainTextPane.getDocument());
699                CADMainPane.addObserver(CADFooterPane);
700               
701                if(!pageLocationSaved)
702                    pageLocationMap.put(currentScreenNum, CADMainPane.getCurrentPage());
703               
704                updateViews(rmModel);
705                break;
706               
707            case BLANK_SCREEN:
708                BlankScreenModel bsModel = (BlankScreenModel)oMessage.value;
709               
710                CADMainPane = new CADMainView(mainTextPane.getDocument());
711                CADMainPane.addObserver(CADFooterPane); 
712
713                if(!pageLocationSaved)
714                    pageLocationMap.put(currentScreenNum, CADMainPane.getCurrentPage());
715               
716                updateViews(bsModel);
717                break;             
718               
719            case SCREEN_UPDATE:
720                CADFooterPane.updateStatus(CADScreenModel.updateStringToMap(
721                        (String)oMessage.value));
722                break;
723               
724            case TIME_UPDATE:
725                CADFooterPane.updateTime((String)oMessage.value);           
726                break;
727               
728            case ROUTED_MESSAGE_COUNT_UPDATE:
729                CADFooterPane.updateRoutedMessageCount((Integer)oMessage.value);
730                break;
731               
732            case ROUTED_MESSAGE_UNREAD_UPDATE:
733                CADFooterPane.updateUnreadMessages((Boolean)oMessage.value);
734                break;
735               
736            case CAD_INFO_MESSAGE:
737                CADFooterPane.displayInfoMessage((String)oMessage.value);
738                break;
739        }           
740    }
741   
742   
743    /**
744     * Update the command line and footer pane with model
745     * data.  Then refresh all of the views to repaint the screen.
746     *
747     * @param model CADScreenModel shown in main Pane.
748     */
749    private void updateViews(CADScreenModel model) {
750               
751        currentScreenNum = model.getScreenNum();
752       
753        CADCommandLinePane.setCommandLine(model.commandLine);
754
755        CADFooterPane.setCADScreenNum(model.getScreenNum());       
756        CADFooterPane.updateTime(CADScreenModel.theCADTime);
757        CADFooterPane.updateDate(CADScreenModel.theCADDate);       
758        CADFooterPane.updateStatus(model.screenUpdateMap);
759        CADFooterPane.updateRoutedMessageCount(model.numberRoutedMessages); 
760        CADFooterPane.updateUnreadMessages(model.unreadMessages);       
761       
762        CADCommandLinePane.refreshView();
763        CADMainPane.refreshView(pageLocationMap.get(currentScreenNum));
764        CADFooterPane.refreshView();
765       
766    }
767   
768    /* SWING OBJECTS */       
769   
770    private JTextPane cmdLineTextPane = null;
771    private JTextPane mainTextPane    = null;
772    private JTextPane footerTextPane  = null;
773   
774    private JPanel cmdLinePanel = null;
775    private JPanel mainPanel    = null;
776    private JPanel footerPanel  = null;
777   
778   
779}   
Note: See TracBrowser for help on using the repository browser.