source: trunk/packages/invirt-vnc-client/VncViewer.java @ 2383

Last change on this file since 2383 was 1334, checked in by broder, 16 years ago

sipb-xen-vnc-client -> invirt-vnc-client

File size: 25.6 KB
Line 
1//
2//  Copyright (C) 2001-2004 HorizonLive.com, Inc.  All Rights Reserved.
3//  Copyright (C) 2002 Constantin Kaplinsky.  All Rights Reserved.
4//  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
5//
6//  This is free software; you can redistribute it and/or modify
7//  it under the terms of the GNU General Public License as published by
8//  the Free Software Foundation; either version 2 of the License, or
9//  (at your option) any later version.
10//
11//  This software is distributed in the hope that it will be useful,
12//  but WITHOUT ANY WARRANTY; without even the implied warranty of
13//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14//  GNU General Public License for more details.
15//
16//  You should have received a copy of the GNU General Public License
17//  along with this software; if not, write to the Free Software
18//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
19//  USA.
20//
21
22//
23// VncViewer.java - the VNC viewer applet.  This class mainly just sets up the
24// user interface, leaving it to the VncCanvas to do the actual rendering of
25// a VNC desktop.
26//
27
28import java.awt.*;
29import java.awt.event.*;
30import java.io.*;
31import java.net.*;
32
33public class VncViewer extends java.applet.Applet
34  implements java.lang.Runnable, WindowListener {
35
36  boolean inAnApplet = true;
37  boolean inSeparateFrame = false;
38
39  //
40  // main() is called when run as a java program from the command line.
41  // It simply runs the applet inside a newly-created frame.
42  //
43
44  public static void main(String[] argv) {
45    VncViewer v = new VncViewer();
46    v.mainArgs = argv;
47    v.inAnApplet = false;
48    v.inSeparateFrame = true;
49
50    v.init();
51    v.start();
52  }
53
54  String[] mainArgs;
55
56  RfbProto rfb;
57  Thread rfbThread;
58
59  Frame vncFrame;
60  Container vncContainer;
61  ScrollPane desktopScrollPane;
62  GridBagLayout gridbag;
63  ButtonPanel buttonPanel;
64  Label connStatusLabel;
65  VncCanvas vc;
66  OptionsFrame options;
67  ClipboardFrame clipboard;
68  RecordingFrame rec;
69
70  // Control session recording.
71  Object recordingSync;
72  String sessionFileName;
73  boolean recordingActive;
74  boolean recordingStatusChanged;
75  String cursorUpdatesDef;
76  String eightBitColorsDef;
77
78  // Variables read from parameter values.
79  String socketFactory;
80  String host;
81  int port;
82  String passwordParam;
83  boolean showControls;
84  boolean offerRelogin;
85  boolean showOfflineDesktop;
86  int deferScreenUpdates;
87  int deferCursorUpdates;
88  int deferUpdateRequests;
89
90  // Reference to this applet for inter-applet communication.
91  public static java.applet.Applet refApplet;
92
93  //
94  // init()
95  //
96
97  public void init() {
98
99    readParameters();
100
101    refApplet = this;
102
103    if (inSeparateFrame) {
104      vncFrame = new Frame("TightVNC");
105      if (!inAnApplet) {
106        vncFrame.add("Center", this);
107      }
108      vncContainer = vncFrame;
109    } else {
110      vncContainer = this;
111    }
112
113    recordingSync = new Object();
114
115    options = new OptionsFrame(this);
116    clipboard = new ClipboardFrame(this);
117    if (RecordingFrame.checkSecurity())
118      rec = new RecordingFrame(this);
119
120    sessionFileName = null;
121    recordingActive = false;
122    recordingStatusChanged = false;
123    cursorUpdatesDef = null;
124    eightBitColorsDef = null;
125
126    if (inSeparateFrame)
127      vncFrame.addWindowListener(this);
128
129    rfbThread = new Thread(this);
130    rfbThread.start();
131  }
132
133  public void update(Graphics g) {
134  }
135
136  //
137  // run() - executed by the rfbThread to deal with the RFB socket.
138  //
139
140  public void run() {
141
142    gridbag = new GridBagLayout();
143    vncContainer.setLayout(gridbag);
144
145    GridBagConstraints gbc = new GridBagConstraints();
146    gbc.gridwidth = GridBagConstraints.REMAINDER;
147    gbc.anchor = GridBagConstraints.NORTHWEST;
148
149    if (showControls) {
150      buttonPanel = new ButtonPanel(this);
151      gridbag.setConstraints(buttonPanel, gbc);
152      vncContainer.add(buttonPanel);
153    }
154
155    try {
156      connectAndAuthenticate();
157      doProtocolInitialisation();
158
159      // FIXME: Use auto-scaling not only in a separate frame.
160      if (options.autoScale && inSeparateFrame) {
161        Dimension screenSize;
162        try {
163          screenSize = vncContainer.getToolkit().getScreenSize();
164        } catch (Exception e) {
165          screenSize = new Dimension(0, 0);
166        }
167        createCanvas(screenSize.width - 32, screenSize.height - 32);
168      } else {
169        createCanvas(0, 0);
170      }
171
172      gbc.weightx = 1.0;
173      gbc.weighty = 1.0;
174
175      if (inSeparateFrame) {
176
177        // Create a panel which itself is resizeable and can hold
178        // non-resizeable VncCanvas component at the top left corner.
179        Panel canvasPanel = new Panel();
180        canvasPanel.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));
181        canvasPanel.add(vc);
182
183        // Create a ScrollPane which will hold a panel with VncCanvas
184        // inside.
185        desktopScrollPane = new ScrollPane(ScrollPane.SCROLLBARS_AS_NEEDED);
186        gbc.fill = GridBagConstraints.BOTH;
187        gridbag.setConstraints(desktopScrollPane, gbc);
188        desktopScrollPane.add(canvasPanel);
189
190        // Finally, add our ScrollPane to the Frame window.
191        vncFrame.add(desktopScrollPane);
192        vncFrame.setTitle(rfb.desktopName);
193        vncFrame.pack();
194        vc.resizeDesktopFrame();
195
196      } else {
197
198        // Just add the VncCanvas component to the Applet.
199        gridbag.setConstraints(vc, gbc);
200        add(vc);
201        validate();
202
203      }
204
205      if (showControls)
206        buttonPanel.enableButtons();
207
208      moveFocusToDesktop();
209      processNormalProtocol();
210
211    } catch (NoRouteToHostException e) {
212      fatalError("Network error: no route to server: " + host, e);
213    } catch (UnknownHostException e) {
214      fatalError("Network error: server name unknown: " + host, e);
215    } catch (ConnectException e) {
216      fatalError("Network error: could not connect to server: " +
217                 host + ":" + port, e);
218    } catch (EOFException e) {
219      if (showOfflineDesktop) {
220        e.printStackTrace();
221        System.out.println("Network error: remote side closed connection");
222        if (vc != null) {
223          vc.enableInput(false);
224        }
225        if (inSeparateFrame) {
226          vncFrame.setTitle(rfb.desktopName + " [disconnected]");
227        }
228        if (rfb != null && !rfb.closed())
229          rfb.close();
230        if (showControls && buttonPanel != null) {
231          buttonPanel.disableButtonsOnDisconnect();
232          if (inSeparateFrame) {
233            vncFrame.pack();
234          } else {
235            validate();
236          }
237        }
238      } else {
239        fatalError("Network error: remote side closed connection", e);
240      }
241    } catch (IOException e) {
242      String str = e.getMessage();
243      if (str != null && str.length() != 0) {
244        fatalError("Network Error: " + str, e);
245      } else {
246        fatalError(e.toString(), e);
247      }
248    } catch (Exception e) {
249      String str = e.getMessage();
250      if (str != null && str.length() != 0) {
251        fatalError("Error: " + str, e);
252      } else {
253        fatalError(e.toString(), e);
254      }
255    }
256   
257  }
258
259  //
260  // Create a VncCanvas instance.
261  //
262
263  void createCanvas(int maxWidth, int maxHeight) throws IOException {
264    // Determine if Java 2D API is available and use a special
265    // version of VncCanvas if it is present.
266    vc = null;
267    try {
268      // This throws ClassNotFoundException if there is no Java 2D API.
269      Class cl = Class.forName("java.awt.Graphics2D");
270      // If we could load Graphics2D class, then we can use VncCanvas2D.
271      cl = Class.forName("VncCanvas2");
272      Class[] argClasses = { this.getClass(), Integer.TYPE, Integer.TYPE };
273      java.lang.reflect.Constructor cstr = cl.getConstructor(argClasses);
274      Object[] argObjects =
275        { this, new Integer(maxWidth), new Integer(maxHeight) };
276      vc = (VncCanvas)cstr.newInstance(argObjects);
277    } catch (Exception e) {
278      System.out.println("Warning: Java 2D API is not available");
279    }
280
281    // If we failed to create VncCanvas2D, use old VncCanvas.
282    if (vc == null)
283      vc = new VncCanvas(this, maxWidth, maxHeight);
284  }
285
286
287  //
288  // Process RFB socket messages.
289  // If the rfbThread is being stopped, ignore any exceptions,
290  // otherwise rethrow the exception so it can be handled.
291  //
292 
293  void processNormalProtocol() throws Exception {
294    try {
295      vc.processNormalProtocol();
296    } catch (Exception e) {
297      if (rfbThread == null) {
298        System.out.println("Ignoring RFB socket exceptions" +
299                           " because applet is stopping");
300      } else {
301        throw e;
302      }
303    }
304  }
305
306
307  //
308  // Connect to the RFB server and authenticate the user.
309  //
310
311  void connectAndAuthenticate() throws Exception
312  {
313    showConnectionStatus("Initializing...");
314    if (inSeparateFrame) {
315      vncFrame.pack();
316      vncFrame.show();
317    } else {
318      validate();
319    }
320
321    showConnectionStatus("Connecting to " + host + ", port " + port + "...");
322
323    rfb = new RfbProto(host, port, this);
324    showConnectionStatus("Connected to server");
325
326    rfb.readVersionMsg();
327    showConnectionStatus("RFB server supports protocol version " +
328                         rfb.serverMajor + "." + rfb.serverMinor);
329
330    rfb.writeVersionMsg();
331    showConnectionStatus("Using RFB protocol version " +
332                         rfb.clientMajor + "." + rfb.clientMinor);
333
334    int secType = rfb.negotiateSecurity();
335    int authType;
336    if (secType == RfbProto.SecTypeTight) {
337      showConnectionStatus("Enabling TightVNC protocol extensions");
338      rfb.initCapabilities();
339      rfb.setupTunneling();
340      authType = rfb.negotiateAuthenticationTight();
341    } else {
342      authType = secType;
343    }
344
345    switch (authType) {
346    case RfbProto.AuthNone:
347      showConnectionStatus("No authentication needed");
348      rfb.authenticateNone();
349      break;
350    case RfbProto.AuthVNC:
351      showConnectionStatus("Performing standard VNC authentication");
352      if (passwordParam != null) {
353        rfb.authenticateVNC(passwordParam);
354      } else {
355        String pw = askPassword();
356        rfb.authenticateVNC(pw);
357      }
358      break;
359    default:
360      throw new Exception("Unknown authentication scheme " + authType);
361    }
362  }
363
364
365  //
366  // Show a message describing the connection status.
367  // To hide the connection status label, use (msg == null).
368  //
369
370  void showConnectionStatus(String msg)
371  {
372    if (msg == null) {
373      if (vncContainer.isAncestorOf(connStatusLabel)) {
374        vncContainer.remove(connStatusLabel);
375      }
376      return;
377    }
378
379    System.out.println(msg);
380
381    if (connStatusLabel == null) {
382      connStatusLabel = new Label("Status: " + msg);
383      connStatusLabel.setFont(new Font("Helvetica", Font.PLAIN, 12));
384    } else {
385      connStatusLabel.setText("Status: " + msg);
386    }
387
388    if (!vncContainer.isAncestorOf(connStatusLabel)) {
389      GridBagConstraints gbc = new GridBagConstraints();
390      gbc.gridwidth = GridBagConstraints.REMAINDER;
391      gbc.fill = GridBagConstraints.HORIZONTAL;
392      gbc.anchor = GridBagConstraints.NORTHWEST;
393      gbc.weightx = 1.0;
394      gbc.weighty = 1.0;
395      gbc.insets = new Insets(20, 30, 20, 30);
396      gridbag.setConstraints(connStatusLabel, gbc);
397      vncContainer.add(connStatusLabel);
398    }
399
400    if (inSeparateFrame) {
401      vncFrame.pack();
402    } else {
403      validate();
404    }
405  }
406
407
408  //
409  // Show an authentication panel.
410  //
411
412  String askPassword() throws Exception
413  {
414    showConnectionStatus(null);
415
416    AuthPanel authPanel = new AuthPanel(this);
417
418    GridBagConstraints gbc = new GridBagConstraints();
419    gbc.gridwidth = GridBagConstraints.REMAINDER;
420    gbc.anchor = GridBagConstraints.NORTHWEST;
421    gbc.weightx = 1.0;
422    gbc.weighty = 1.0;
423    gbc.ipadx = 100;
424    gbc.ipady = 50;
425    gridbag.setConstraints(authPanel, gbc);
426    vncContainer.add(authPanel);
427
428    if (inSeparateFrame) {
429      vncFrame.pack();
430    } else {
431      validate();
432    }
433
434    authPanel.moveFocusToDefaultField();
435    String pw = authPanel.getPassword();
436    vncContainer.remove(authPanel);
437
438    return pw;
439  }
440
441
442  //
443  // Do the rest of the protocol initialisation.
444  //
445
446  void doProtocolInitialisation() throws IOException
447  {
448    rfb.writeClientInit();
449    rfb.readServerInit();
450
451    System.out.println("Desktop name is " + rfb.desktopName);
452    System.out.println("Desktop size is " + rfb.framebufferWidth + " x " +
453                       rfb.framebufferHeight);
454
455    setEncodings();
456
457    showConnectionStatus(null);
458  }
459
460
461  //
462  // Send current encoding list to the RFB server.
463  //
464
465  int[] encodingsSaved;
466  int nEncodingsSaved;
467
468  void setEncodings()        { setEncodings(false); }
469  void autoSelectEncodings() { setEncodings(true); }
470
471  void setEncodings(boolean autoSelectOnly) {
472    if (options == null || rfb == null || !rfb.inNormalProtocol)
473      return;
474
475    int preferredEncoding = options.preferredEncoding;
476    if (preferredEncoding == -1) {
477      long kbitsPerSecond = rfb.kbitsPerSecond();
478      if (nEncodingsSaved < 1) {
479        // Choose Tight or ZRLE encoding for the very first update.
480        System.out.println("Using Tight/ZRLE encodings");
481        preferredEncoding = RfbProto.EncodingTight;
482      } else if (kbitsPerSecond > 2000 &&
483                 encodingsSaved[0] != RfbProto.EncodingHextile) {
484        // Switch to Hextile if the connection speed is above 2Mbps.
485        System.out.println("Throughput " + kbitsPerSecond +
486                           " kbit/s - changing to Hextile encoding");
487        preferredEncoding = RfbProto.EncodingHextile;
488      } else if (kbitsPerSecond < 1000 &&
489                 encodingsSaved[0] != RfbProto.EncodingTight) {
490        // Switch to Tight/ZRLE if the connection speed is below 1Mbps.
491        System.out.println("Throughput " + kbitsPerSecond +
492                           " kbit/s - changing to Tight/ZRLE encodings");
493        preferredEncoding = RfbProto.EncodingTight;
494      } else {
495        // Don't change the encoder.
496        if (autoSelectOnly)
497          return;
498        preferredEncoding = encodingsSaved[0];
499      }
500    } else {
501      // Auto encoder selection is not enabled.
502      if (autoSelectOnly)
503        return;
504    }
505
506    int[] encodings = new int[20];
507    int nEncodings = 0;
508
509    encodings[nEncodings++] = preferredEncoding;
510    if (options.useCopyRect) {
511      encodings[nEncodings++] = RfbProto.EncodingCopyRect;
512    }
513
514    if (preferredEncoding != RfbProto.EncodingTight) {
515      encodings[nEncodings++] = RfbProto.EncodingTight;
516    }
517    if (preferredEncoding != RfbProto.EncodingZRLE) {
518      encodings[nEncodings++] = RfbProto.EncodingZRLE;
519    }
520    if (preferredEncoding != RfbProto.EncodingHextile) {
521      encodings[nEncodings++] = RfbProto.EncodingHextile;
522    }
523    if (preferredEncoding != RfbProto.EncodingZlib) {
524      encodings[nEncodings++] = RfbProto.EncodingZlib;
525    }
526    if (preferredEncoding != RfbProto.EncodingCoRRE) {
527      encodings[nEncodings++] = RfbProto.EncodingCoRRE;
528    }
529    if (preferredEncoding != RfbProto.EncodingRRE) {
530      encodings[nEncodings++] = RfbProto.EncodingRRE;
531    }
532
533    if (options.compressLevel >= 0 && options.compressLevel <= 9) {
534      encodings[nEncodings++] =
535        RfbProto.EncodingCompressLevel0 + options.compressLevel;
536    }
537    if (options.jpegQuality >= 0 && options.jpegQuality <= 9) {
538      encodings[nEncodings++] =
539        RfbProto.EncodingQualityLevel0 + options.jpegQuality;
540    }
541
542    if (options.requestCursorUpdates) {
543      encodings[nEncodings++] = RfbProto.EncodingXCursor;
544      encodings[nEncodings++] = RfbProto.EncodingRichCursor;
545      if (!options.ignoreCursorUpdates)
546        encodings[nEncodings++] = RfbProto.EncodingPointerPos;
547    }
548
549    encodings[nEncodings++] = RfbProto.EncodingLastRect;
550    encodings[nEncodings++] = RfbProto.EncodingNewFBSize;
551
552    boolean encodingsWereChanged = false;
553    if (nEncodings != nEncodingsSaved) {
554      encodingsWereChanged = true;
555    } else {
556      for (int i = 0; i < nEncodings; i++) {
557        if (encodings[i] != encodingsSaved[i]) {
558          encodingsWereChanged = true;
559          break;
560        }
561      }
562    }
563
564    if (encodingsWereChanged) {
565      try {
566        rfb.writeSetEncodings(encodings, nEncodings);
567        if (vc != null) {
568          vc.softCursorFree();
569        }
570      } catch (Exception e) {
571        e.printStackTrace();
572      }
573      encodingsSaved = encodings;
574      nEncodingsSaved = nEncodings;
575    }
576  }
577
578
579  //
580  // setCutText() - send the given cut text to the RFB server.
581  //
582
583  void setCutText(String text) {
584    try {
585      if (rfb != null && rfb.inNormalProtocol) {
586        rfb.writeClientCutText(text);
587      }
588    } catch (Exception e) {
589      e.printStackTrace();
590    }
591  }
592
593
594  //
595  // Order change in session recording status. To stop recording, pass
596  // null in place of the fname argument.
597  //
598
599  void setRecordingStatus(String fname) {
600    synchronized(recordingSync) {
601      sessionFileName = fname;
602      recordingStatusChanged = true;
603    }
604  }
605
606  //
607  // Start or stop session recording. Returns true if this method call
608  // causes recording of a new session.
609  //
610
611  boolean checkRecordingStatus() throws IOException {
612    synchronized(recordingSync) {
613      if (recordingStatusChanged) {
614        recordingStatusChanged = false;
615        if (sessionFileName != null) {
616          startRecording();
617          return true;
618        } else {
619          stopRecording();
620        }
621      }
622    }
623    return false;
624  }
625
626  //
627  // Start session recording.
628  //
629
630  protected void startRecording() throws IOException {
631    synchronized(recordingSync) {
632      if (!recordingActive) {
633        // Save settings to restore them after recording the session.
634        cursorUpdatesDef =
635          options.choices[options.cursorUpdatesIndex].getSelectedItem();
636        eightBitColorsDef =
637          options.choices[options.eightBitColorsIndex].getSelectedItem();
638        // Set options to values suitable for recording.
639        options.choices[options.cursorUpdatesIndex].select("Disable");
640        options.choices[options.cursorUpdatesIndex].setEnabled(false);
641        options.setEncodings();
642        options.choices[options.eightBitColorsIndex].select("No");
643        options.choices[options.eightBitColorsIndex].setEnabled(false);
644        options.setColorFormat();
645      } else {
646        rfb.closeSession();
647      }
648
649      System.out.println("Recording the session in " + sessionFileName);
650      rfb.startSession(sessionFileName);
651      recordingActive = true;
652    }
653  }
654
655  //
656  // Stop session recording.
657  //
658
659  protected void stopRecording() throws IOException {
660    synchronized(recordingSync) {
661      if (recordingActive) {
662        // Restore options.
663        options.choices[options.cursorUpdatesIndex].select(cursorUpdatesDef);
664        options.choices[options.cursorUpdatesIndex].setEnabled(true);
665        options.setEncodings();
666        options.choices[options.eightBitColorsIndex].select(eightBitColorsDef);
667        options.choices[options.eightBitColorsIndex].setEnabled(true);
668        options.setColorFormat();
669
670        rfb.closeSession();
671        System.out.println("Session recording stopped.");
672      }
673      sessionFileName = null;
674      recordingActive = false;
675    }
676  }
677
678
679  //
680  // readParameters() - read parameters from the html source or from the
681  // command line.  On the command line, the arguments are just a sequence of
682  // param_name/param_value pairs where the names and values correspond to
683  // those expected in the html applet tag source.
684  //
685
686  void readParameters() {
687    host = readParameter("HOST", !inAnApplet);
688    if (host == null) {
689      host = getCodeBase().getHost();
690      if (host.equals("")) {
691        fatalError("HOST parameter not specified");
692      }
693    }
694
695    String str = readParameter("PORT", true);
696    port = Integer.parseInt(str);
697
698    // Read "ENCPASSWORD" or "PASSWORD" parameter if specified.
699    readPasswordParameters();
700
701    if (inAnApplet) {
702      str = readParameter("Open New Window", false);
703      if (str != null && str.equalsIgnoreCase("Yes"))
704        inSeparateFrame = true;
705    }
706
707    // "Show Controls" set to "No" disables button panel.
708    showControls = true;
709    str = readParameter("Show Controls", false);
710    if (str != null && str.equalsIgnoreCase("No"))
711      showControls = false;
712
713    // "Offer Relogin" set to "No" disables "Login again" and "Close
714    // window" buttons under error messages in applet mode.
715    offerRelogin = true;
716    str = readParameter("Offer Relogin", false);
717    if (str != null && str.equalsIgnoreCase("No"))
718      offerRelogin = false;
719
720    // Do we continue showing desktop on remote disconnect?
721    showOfflineDesktop = false;
722    str = readParameter("Show Offline Desktop", false);
723    if (str != null && str.equalsIgnoreCase("Yes"))
724      showOfflineDesktop = true;
725
726    // Fine tuning options.
727    deferScreenUpdates = readIntParameter("Defer screen updates", 20);
728    deferCursorUpdates = readIntParameter("Defer cursor updates", 10);
729    deferUpdateRequests = readIntParameter("Defer update requests", 50);
730
731    // SocketFactory.
732    socketFactory = readParameter("SocketFactory", false);
733  }
734
735  //
736  // Read password parameters. If an "ENCPASSWORD" parameter is set,
737  // then decrypt the password into the passwordParam string. Otherwise,
738  // try to read the "PASSWORD" parameter directly to passwordParam.
739  //
740
741  private void readPasswordParameters() {
742    String encPasswordParam = readParameter("ENCPASSWORD", false);
743    if (encPasswordParam == null) {
744      passwordParam = readParameter("PASSWORD", false);
745    } else {
746      // ENCPASSWORD is hexascii-encoded. Decode.
747      byte[] pw = {0, 0, 0, 0, 0, 0, 0, 0};
748      int len = encPasswordParam.length() / 2;
749      if (len > 8)
750        len = 8;
751      for (int i = 0; i < len; i++) {
752        String hex = encPasswordParam.substring(i*2, i*2+2);
753        Integer x = new Integer(Integer.parseInt(hex, 16));
754        pw[i] = x.byteValue();
755      }
756      // Decrypt the password.
757      byte[] key = {23, 82, 107, 6, 35, 78, 88, 7};
758      DesCipher des = new DesCipher(key);
759      des.decrypt(pw, 0, pw, 0);
760      passwordParam = new String(pw);
761    }
762  }
763
764  public String readParameter(String name, boolean required) {
765    if (inAnApplet) {
766      String s = getParameter(name);
767      if ((s == null) && required) {
768        fatalError(name + " parameter not specified");
769      }
770      return s;
771    }
772
773    for (int i = 0; i < mainArgs.length; i += 2) {
774      if (mainArgs[i].equalsIgnoreCase(name)) {
775        try {
776          return mainArgs[i+1];
777        } catch (Exception e) {
778          if (required) {
779            fatalError(name + " parameter not specified");
780          }
781          return null;
782        }
783      }
784    }
785    if (required) {
786      fatalError(name + " parameter not specified");
787    }
788    return null;
789  }
790
791  int readIntParameter(String name, int defaultValue) {
792    String str = readParameter(name, false);
793    int result = defaultValue;
794    if (str != null) {
795      try {
796        result = Integer.parseInt(str);
797      } catch (NumberFormatException e) { }
798    }
799    return result;
800  }
801
802  //
803  // moveFocusToDesktop() - move keyboard focus either to VncCanvas.
804  //
805
806  void moveFocusToDesktop() {
807    if (vncContainer != null) {
808      if (vc != null && vncContainer.isAncestorOf(vc))
809        vc.requestFocus();
810    }
811  }
812
813  //
814  // disconnect() - close connection to server.
815  //
816
817  synchronized public void disconnect() {
818    System.out.println("Disconnect");
819
820    if (rfb != null && !rfb.closed())
821      rfb.close();
822    options.dispose();
823    clipboard.dispose();
824    if (rec != null)
825      rec.dispose();
826
827    if (inAnApplet) {
828      showMessage("Disconnected");
829    } else {
830      System.exit(0);
831    }
832  }
833
834  //
835  // fatalError() - print out a fatal error message.
836  // FIXME: Do we really need two versions of the fatalError() method?
837  //
838
839  synchronized public void fatalError(String str) {
840    System.out.println(str);
841
842    if (inAnApplet) {
843      // vncContainer null, applet not inited,
844      // can not present the error to the user.
845      Thread.currentThread().stop();
846    } else {
847      System.exit(1);
848    }
849  }
850
851  synchronized public void fatalError(String str, Exception e) {
852 
853    if (rfb != null && rfb.closed()) {
854      // Not necessary to show error message if the error was caused
855      // by I/O problems after the rfb.close() method call.
856      System.out.println("RFB thread finished");
857      return;
858    }
859
860    System.out.println(str);
861    e.printStackTrace();
862
863    if (rfb != null)
864      rfb.close();
865
866    if (inAnApplet) {
867      showMessage(str);
868    } else {
869      System.exit(1);
870    }
871  }
872
873  //
874  // Show message text and optionally "Relogin" and "Close" buttons.
875  //
876
877  void showMessage(String msg) {
878    vncContainer.removeAll();
879
880    Label errLabel = new Label(msg, Label.CENTER);
881    errLabel.setFont(new Font("Helvetica", Font.PLAIN, 12));
882
883    if (offerRelogin) {
884
885      Panel gridPanel = new Panel(new GridLayout(0, 1));
886      Panel outerPanel = new Panel(new FlowLayout(FlowLayout.LEFT));
887      outerPanel.add(gridPanel);
888      vncContainer.setLayout(new FlowLayout(FlowLayout.LEFT, 30, 16));
889      vncContainer.add(outerPanel);
890      Panel textPanel = new Panel(new FlowLayout(FlowLayout.CENTER));
891      textPanel.add(errLabel);
892      gridPanel.add(textPanel);
893      gridPanel.add(new ReloginPanel(this));
894
895    } else {
896
897      vncContainer.setLayout(new FlowLayout(FlowLayout.LEFT, 30, 30));
898      vncContainer.add(errLabel);
899
900    }
901
902    if (inSeparateFrame) {
903      vncFrame.pack();
904    } else {
905      validate();
906    }
907  }
908
909  //
910  // Stop the applet.
911  // Main applet thread will terminate on first exception
912  // after seeing that rfbThread has been set to null.
913  //
914
915  public void stop() {
916    System.out.println("Stopping applet");
917    rfbThread = null;
918  }
919
920  //
921  // This method is called before the applet is destroyed.
922  //
923
924  public void destroy() {
925    System.out.println("Destroying applet");
926
927    vncContainer.removeAll();
928    options.dispose();
929    clipboard.dispose();
930    if (rec != null)
931      rec.dispose();
932    if (rfb != null && !rfb.closed())
933      rfb.close();
934    if (inSeparateFrame)
935      vncFrame.dispose();
936  }
937
938  //
939  // Start/stop receiving mouse events.
940  //
941
942  public void enableInput(boolean enable) {
943    vc.enableInput(enable);
944  }
945
946  //
947  // Close application properly on window close event.
948  //
949
950  public void windowClosing(WindowEvent evt) {
951    System.out.println("Closing window");
952    if (rfb != null)
953      disconnect();
954
955    vncContainer.hide();
956
957    if (!inAnApplet) {
958      System.exit(0);
959    }
960  }
961
962  //
963  // Ignore window events we're not interested in.
964  //
965
966  public void windowActivated(WindowEvent evt) {}
967  public void windowDeactivated (WindowEvent evt) {}
968  public void windowOpened(WindowEvent evt) {}
969  public void windowClosed(WindowEvent evt) {}
970  public void windowIconified(WindowEvent evt) {}
971  public void windowDeiconified(WindowEvent evt) {}
972}
Note: See TracBrowser for help on using the repository browser.