next up previous contents
Next: documentDataStructures Package Up: Listings Previous: Listings

WebLSD.java

import PositionLayout;

import documentDataStructures.*;

import java.awt.*;
import java.io.*;


// Dies ist die Hauptklasse
public class WebLSD extends Frame {

   static Setup setup;


   //Klassenvariable, die die offenen Fenster mitzaehlt
   static int anzahlOffeneFenster = 0;


   // Festlegen der min/max Fenstergroesse
   final int maxStartFensterGroesse = 750;
   final int minStartFensterGroesse = 500;
   int startFensterGroesse;


   // Menueleiste instanziieren
   static MenuBar menuBar;
   Menu m_Datei, m_Bearbeiten, m_Hilfe;
   MenuItem m_Datei_Aktualisieren, m_Datei_Schliessen,
      m_Datei_Beenden,m_Datei_NeuesFenster,
      m_Bearbeiten_SetupBearbeiten, m_Bearbeiten_SetupLaden,
      m_Bearbeiten_StrukturTesten,
      m_Hilfe_ueber, m_Hilfe_Info;



   // Hauptpanel, enthaelt alles andere
   Panel topPanel;

   // Panel fuer die untere Leiste
   Panel subPanel;


   //Laufleisten
   Scrollbar V_Scrollbar;
   Scrollbar H_Scrollbar;


   LinkStructure linkStruktur;

   // die Arbeitsflaeche instanziieren
   Arbeitsflaeche arbeitsflaeche;




   // Konstruktor der Klasse
   public WebLSD(LinkStructure linkStruktur) {

      //Aufruf des Superklassenkonstruktors
      super("WebLSD: "+linkStruktur.dokumentListe[linkStruktur.startDokument].name());

      // Klassenweiter zugriff auf die darzustellende Link Struktur
      this.linkStruktur = linkStruktur;

      // jetzt exitstiert ein Fenster mehr
      anzahlOffeneFenster++;
   
      // Layout des Fensters festlegen
      setLayout(new BorderLayout(10,10));



      // Menueleiste  erstellen
      menuBar = new MenuBar();


      // erstes Menu (Datei) mit Items in Menu Bar einfuegen
      m_Datei = new Menu("Datei");
      menuBar.add(m_Datei);

      m_Datei_Aktualisieren = new MenuItem("Aktualisieren");
      m_Datei.add(m_Datei_Aktualisieren);

      m_Datei_NeuesFenster = new MenuItem("Neues Fenster");
      m_Datei.add(m_Datei_NeuesFenster);

      m_Datei.add(new MenuItem("-"));
      m_Datei_Schliessen = new MenuItem("Schliessen");
      m_Datei.add(m_Datei_Schliessen);

      m_Datei_Beenden = new MenuItem("Beenden");
      m_Datei.add(m_Datei_Beenden);


      // zweites Menu (Bearbeiten) mit Items in Menu Bar einfuegen
      m_Bearbeiten = new Menu("Bearbeiten");
      menuBar.add(m_Bearbeiten);

      m_Bearbeiten_SetupLaden = new MenuItem("Setup Laden ...");
      m_Bearbeiten.add(m_Bearbeiten_SetupLaden);

      m_Bearbeiten_SetupBearbeiten = new MenuItem("Setup Bearbeiten ...");
      m_Bearbeiten.add(m_Bearbeiten_SetupBearbeiten);

      m_Bearbeiten.add(new MenuItem("-"));
      m_Bearbeiten_StrukturTesten = new MenuItem("Struktur testen ...");
      m_Bearbeiten.add(m_Bearbeiten_StrukturTesten);


      // Hilfe Menu erstellen
      m_Hilfe = new Menu("Hilfe");
      menuBar.add(m_Hilfe);

      m_Hilfe_ueber = new MenuItem("Ueber ...");
      m_Hilfe.add(m_Hilfe_ueber);

      m_Hilfe.add(new MenuItem("-"));
      m_Hilfe_Info = new MenuItem("Informationen");
      m_Hilfe.add(m_Hilfe_Info);

      // dieses Menu als Hilfemenu definieren
      menuBar.setHelpMenu(m_Hilfe);


      // Menueleiste einfuegen
      this.setMenuBar(menuBar);




      // einstellen der richtigen Bildschirmdimensionen

      //wird das Fenster zu gross
      if (linkStruktur.maxRadius > maxStartFensterGroesse) {

         // dann entsprechend verkleinern
         startFensterGroesse = maxStartFensterGroesse;
      }

      // oder zu klein
      else if (linkStruktur.maxRadius < minStartFensterGroesse) {

         // dann entsprechend vergroessern
         startFensterGroesse = minStartFensterGroesse;
      }

      else {
         // ansonsten bei der optimalen Groesse belassen
         startFensterGroesse = linkStruktur.maxRadius;
      }

      // Laufleisten entsprechend Fenstergroesse und Arbeitsflaeche.infoSize 
      //initialisieren

      // (Richtung,aktuelle Position, Ausschnittgroesse, min,max des Scrollbars)
      V_Scrollbar = new Scrollbar(Scrollbar.VERTICAL,
                                  linkStruktur.maxRadius/2 -Arbeitsflaeche.infoSize,
                                  startFensterGroesse,
                                  1 - Arbeitsflaeche.infoSize,
                                  linkStruktur.maxRadius -Arbeitsflaeche.infoSize);
      H_Scrollbar = new Scrollbar(Scrollbar.HORIZONTAL,
                                  linkStruktur.maxRadius/2,
                                  startFensterGroesse,
                                  1,linkStruktur.maxRadius);

      // initialisieren der Arbeitsflaeche
      arbeitsflaeche = new Arbeitsflaeche(new Dimension(startFensterGroesse,
                                         startFensterGroesse+Arbeitsflaeche.infoSize),
                                       linkStruktur,
                                       new Point(linkStruktur.maxRadius/2,
                                         linkStruktur.maxRadius/2 - 
                                         Arbeitsflaeche.infoSize));



      // topPanel Panel initialisieren
      topPanel = new Panel();
      topPanel.setLayout(new BorderLayout(5,5));


      // SubPanel initialisieren
      subPanel = new Panel();
      subPanel.setLayout(new BorderLayout());

      //Layout des Subpanels erstellen: Label und Laufleiste
      subPanel.add("West",new Label(" WebLSD:  WebLinkStructureDisplay   "));
      subPanel.add("Center",H_Scrollbar);


      //Layout des topPanels erstellen: Laufleisten, Arbeitsflaeche und das Subpanel
      topPanel.add("Center",arbeitsflaeche);
      topPanel.add("East",V_Scrollbar);
      topPanel.add("South",subPanel);



      // fenster am Bildschirm erzeugen
      add("Center",topPanel);
      pack();   
      show();

   }


   public boolean handleEvent(Event evt) {


      //DialogFenster instanziieren
      InfoFenster infoFenster;
      FileDialog setup_LadenFenster;



      switch (evt.id) {
      case Event.SCROLL_LINE_UP:
      case Event.SCROLL_LINE_DOWN:
      case Event.SCROLL_PAGE_UP:
      case Event.SCROLL_PAGE_DOWN:
      case Event.SCROLL_ABSOLUTE:
         if (evt.target == V_Scrollbar) {
            arbeitsflaeche.ty = ((Integer)evt.arg).intValue();
            arbeitsflaeche.repaint();
         }
         if (evt.target == H_Scrollbar) {
            arbeitsflaeche.tx = ((Integer)evt.arg).intValue();
            arbeitsflaeche.repaint();
         }
         break;
      case Event.ACTION_EVENT:
         if (evt.target instanceof MenuItem) {

            // kann direkt auf == abgefragt werden, da identische Variable
            if (evt.target == m_Datei_Aktualisieren) {
               arbeitsflaeche.hide();
               new WebLSD(new LinkStructure(setup.log, setup.logFiles));
               this.hide();
               this.dispose();
               
            }

            if (evt.target == m_Datei_NeuesFenster) {
               new WebLSD(linkStruktur);
               
            }

            if (evt.target == m_Datei_Schliessen) {
               if (anzahlOffeneFenster-- > 1) this.hide();
               else System.exit(0);
            }
            if (evt.target == m_Datei_Beenden) System.exit(0);



            if (evt.target == m_Bearbeiten_SetupLaden) {
               setup_LadenFenster = 
                  new FileDialog (this,
                                  "Setup Laden ...", 
                                  FileDialog.LOAD);
               setup_LadenFenster.show();
               String dateiName =  setup_LadenFenster.getDirectory() 
                                  + setup_LadenFenster.getFile();

               if (!dateiName.equals("nullnull")) {
                  setup.load(dateiName);

                  setup = new Setup(this, "SetupBearbeiten ...", true);
                  setup.pack();
                  setup.show();
               }
               arbeitsflaeche.repaint();
            }

            if (evt.target == m_Bearbeiten_SetupBearbeiten) {
               setup = new Setup(this, "Setup Bearbeiten ...", true);
               setup.pack();
               setup.show();
            }

            if (evt.target == m_Bearbeiten_StrukturTesten) {
 
               (new ExternalProgram(this, setup.progName)).start();
            }



            if (evt.target == m_Hilfe_ueber) {
               String[] anzeige = new String[6];
               anzeige[0] = "Technische Universitaet Muenchen";
               anzeige[1] = " Institut fuer Informatik ";
               anzeige[2] = " ";
               anzeige[3] = "WebLinkStructureDisplay";
               anzeige[4] = "implementiert von Diana Stricker und Albert Euba";
               anzeige[5] = "Fragen an: euba@informatik.tu-muenchen.de";
               infoFenster = new InfoFenster(this, 
                              "Hilfe Ueber ...", 
                              true,
                              anzeige);
            }

            if (evt.target == m_Hilfe_Info) {
               String[] anzeige = new String[1];
               anzeige[0] = "Text folgt nach Erstellung der Ausarbeitung";
               infoFenster = new InfoFenster(this, "Informationen",
                                             true, anzeige);
            }
         }
         break;


      }
      return super.handleEvent(evt);

   }



   public static void main (String args[]) {

      // Standardsetup Laden
      setup = new Setup(new Frame(),"",true);
      setup.load("WebLSD.ini");
      new WebLSD(new LinkStructure(setup.log, setup.logFiles));
   }

}





// Diese Klasse startet einen LinkTest in eigenem Prozess
class ExternalProgram extends Thread {

String befehl;   
WebLSD aufrufer;
String[] anzeige = new String[1];

   public ExternalProgram(WebLSD aufrufer, String befehl) {
      super(befehl);
      this.befehl = befehl;
      this.aufrufer = aufrufer;
   }

   public ExternalProgram(String befehl) {
      super(befehl);
      this.befehl = befehl;
      this.aufrufer = null;
   }

   public void run() {
      try {
         Process prozess = Runtime.getRuntime().exec(befehl);


      //Wenn stdout erfolgen soll, dann auskommentieren
      //   InputStream iss = prozess.getInputStream();
      //   DataInputStream input =new DataInputStream(iss);
      //   String instring;
      //        
      //   while ((instring = input.readLine()) != null) {
      //      System.out.println(instring);
      //   }

         try { prozess.waitFor();}
         catch(InterruptedException e) { System.out.println("InterruptedException");}

         if (prozess.exitValue() == 0)
            anzeige[0] = " Ausfuehrung von " +befehl+ " beendet";
         else 
            anzeige[0] = " Fehler bei Ausfuehrung von " + befehl;
      }
      catch (IOException e) {
         System.out.println("IOException bei aufuehrung von "+ befehl);
      }

      
      if (aufrufer != null) {
         new InfoFenster(aufrufer,"Externer Prozess beendet", true, anzeige);
      }
   }



}










// Auf der Arbeitsflaeche werden die Icons und deren Verbindungen dargestellt
class Arbeitsflaeche extends Panel {


   // Variablen zum Scrollen
   int tx;
   int ty;

   // Hoehe des infoPanels
   final static int infoSize = 40;


   // Panel und Label fuer die Statusinfo
   Panel infoPanel;
   Label dateiLabel;
   Label pfadLabel;
   Label serverLabel;
   int lastTouchedDokument = -1;


   // Popup Fenster bei Mausklick auf ein Icon
   Panel Mousefield;
   PopUp Auswahlpunkte;
   String popUpItems[];


   // Gesamtliste der darzustellenden Dokumente
   LinkStructure struktur;

   //Hoehe und Breite des Kaestchens zur Darstellung der Dokumente
   int dokumentWidth = 70;
   int dokumentHeight = 14;



   // Konstruktor
   Arbeitsflaeche(Dimension size, LinkStructure struktur, Point mittelpunkt) {

      // Aufruf des Superklassenkonstruktors
      super();


      // Zugriff auf Liste aller Dokumente
      this.struktur = struktur;


      // Layout der Arbeitsflaeche als PositionLayout festlegen
      setLayout(new PositionLayout(size.width,size.height));

      // Hintergrundfarbe festlegen
      setBackground(Color.white);

      // Font festlegen
      setFont(new Font("Courier", Font.PLAIN, 12));


      // Arbeitsflaeche auf Mitte scrollen
      tx = mittelpunkt.x;
      ty = mittelpunkt.y;


      // Popup Panel definieren
      Mousefield = new Panel();
      Mousefield.setLayout(new FlowLayout());
      String[] popUpItems = new String[1];
      popUpItems[0] = "Name der Seite";
      Auswahlpunkte = new PopUp();
      Mousefield.add(Auswahlpunkte);
      add("0 0",Mousefield);
      Mousefield.hide();


      // Info Label
      //initialisieren
      infoPanel = new Panel();
      infoPanel.setLayout(new GridLayout(2,3,0,0));
      infoPanel.setBackground(Color.lightGray);

      //belegen
      infoPanel.add(new Label("WWW-Server:           "));
      infoPanel.add(new Label("  Pfad:"));
      infoPanel.add(new Label("  Dateiname:"));

      dateiLabel = new Label("");
      pfadLabel  = new Label("");
      serverLabel = new Label("");
      infoPanel.add(serverLabel);
      infoPanel.add(pfadLabel);
      infoPanel.add(dateiLabel);

      //einfuegen
      add("0 0",infoPanel);

   }



   public boolean handleEvent(Event evt) {

      Point dokumentKoordinaten;

      // Laufvariable
      int dokument;

      // Ereignis auf der Arbeitsflaeche?
      if (evt.target == this) {

         // Was macht der Benutzer
         switch (evt.id) {

         // einfache Bewegung der Maus
         case Event.MOUSE_MOVE:
            // Im InfoPanel anzeigen, ueber welchem Dokument sich die Maus befindet
   
            // durchsuche dokumentListe, ob Mauskoordinaten passen
            for(dokument = struktur.dokumentListe.length -1;
                dokument >= 0 ;
                dokument--)   {

               dokumentKoordinaten=struktur.dokumentListe[dokument].liesKoordinaten();
               if (   // x - Bereich abpruefen
                  //                  Umfeld: halbes Kaestchen und Scrollbarstaende
                   ((dokumentKoordinaten.x < evt.x + dokumentWidth/2 + tx)  &&
                   (dokumentKoordinaten.x  > evt.x - dokumentWidth/2 + tx)) &&
                  // y - Bereich abpruefen
                   ((dokumentKoordinaten.y < evt.y + dokumentHeight/2 + ty) &&
                   (dokumentKoordinaten.y  > evt.y - dokumentHeight/2 + ty))) {

                  // entsprechendes Dokument gefunden
                  if (dokument != lastTouchedDokument) {

                     // Nur wenn Maus ueber neuem Dokument, Labels updaten
                     dateiLabel.
                        setText("  "+struktur.dokumentListe[dokument].dateiName);
                     pfadLabel.
                        setText("  "+struktur.dokumentListe[dokument].pfadName);
                     serverLabel.
                        setText(struktur.dokumentListe[dokument].serverName);

                     // und am Bildschirm darstellen
                     infoPanel.layout();

                     // dann aktuelles Dokument merken
                     lastTouchedDokument = dokument;
                  }
                  // Dokument gefunden, Laufschleife verlassen
                  break;
               }
            }
            // Wenn aber die Maus gerade ein Dokument verlassen hat
            if ((dokument <= 0) && (lastTouchedDokument != -1)) {

               // dann Labels loeschen
               dateiLabel.setText("");
               pfadLabel.setText("");
               serverLabel.setText("");

               // und am Bildschirm darstellen
               infoPanel.layout();

               // kennzeichnen, dass kein Dokument ausgewaehlt 
               lastTouchedDokument = -1;
            }
            // Handlung erledigt, switch verlassen
            break;


         // Mausklick
         case Event.MOUSE_DOWN:
            // PopUp ueber aktuellem Dokument oeffnen
   
            // durchsuche dokumentListe, ob Mauskoordinaten passen
            for(dokument = struktur.dokumentListe.length -1; 
                dokument >= 0 ; 
                dokument--)  {

               dokumentKoordinaten=struktur.dokumentListe[dokument].liesKoordinaten();
               if (   // x - Bereich abpruefen
                   //                  Umfeld: halbes Kaestchen und Scrollbarstaende
                   ((dokumentKoordinaten.x < evt.x + dokumentWidth/2 + tx)  &&
                   (dokumentKoordinaten.x  > evt.x - dokumentWidth/2 + tx)) &&
                   // y - Bereich abpruefen
                   ((dokumentKoordinaten.y < evt.y + dokumentHeight/2 + ty) &&
                   (dokumentKoordinaten.y  > evt.y - dokumentHeight/2 + ty))) {

                  // entsprechendes Dokument gefunden, dann


                  // erzeugen des passenden PopUps

                  // loeschen des alten PopUps
                  Mousefield.remove(Auswahlpunkte);

                  // initialisieren der PopUps Items
                  int laenge = 0;
                  popUpItems = new 
                     String[12 + struktur.dokumentListe[dokument].vater.length];

                  // Name an oberster Stelle
                  popUpItems[laenge++] = struktur.dokumentListe[dokument].name();
                  popUpItems[laenge++] = "";

                  // Vermerk, falls Dokument fehlerhaft
                  if (struktur.dokumentListe[dokument].fehlernummer != 0) {
                    popUpItems[laenge++] = 
                       "Fehler: ";
                    popUpItems[laenge++] = 
                       struktur.dokumentListe[dokument].fehlerText();
                    popUpItems[laenge++] = "";
                  }


                  // Zoom anbieten, wenn Soehne vorhanden
                  if (struktur.dokumentListe[dokument].sohn.length > 0) {
                     popUpItems[laenge++] = "Zoom auf Unterstruktur";
                     popUpItems[laenge++] = "";
                  }

                  // Anzeige der Vorfahren
                  if (struktur.dokumentListe[dokument].vater.length != 0) {
                     popUpItems[laenge++] = "Verweise auf das Dokument in:";
                     for (int i = 0; 
                          i < struktur.dokumentListe[dokument].vater.length; 
                          i++) {
                        if (struktur.dokumentListe[dokument].vater[i] != -1)
                           popUpItems[laenge++] = struktur.dokumentListe[
                             struktur.dokumentListe[dokument].vater[i]].name();
                     }
                     popUpItems[laenge++] = "";
                  }

                  // Darstellung anbieten, wenn fehlerfrei
                  if (struktur.dokumentListe[dokument].fehlernummer == 0) {
                     popUpItems[laenge++] = "Dokument anzeigen";
                     popUpItems[laenge++] = "";
                  }

                  // Ende Option an letzter Stelle
                  popUpItems[laenge++] = "Popup schliessen";
                  Auswahlpunkte=new PopUp(Mousefield, struktur, popUpItems, dokument);


                  // einfuegen des PopUps
                  Mousefield.add(Auswahlpunkte);
                  add((evt.x-30) + " " + (evt.y-10), Mousefield);


                  // Darstellung des aktuellen Layouts
                  // labels loeschen
                  dateiLabel.setText("");
                  pfadLabel.setText("");
                  serverLabel.setText("");
                  layout();
                  Mousefield.show();

                  break;
               }

               // Wenn kein Dokument ausgewaehlt, kein PopUp
               else Mousefield.hide();
            }

            // Handlung erledigt, switch verlassen
            break;

         }
      }

      // aufruf der Superklassen-handleEvent Methode
      return super.handleEvent(evt);
   }



   //Zeichnen der Verbindungslinien zu allen Soehnen
   void Edges(Graphics g, Dokument dokument) {

      //Punkte fuer Anfang und Ende der Verbindungslinien
      Point point1, point2;

      //Anfangskoordinaten der Linie (Vater) ermitteln
      point1 = new Point(0,0);
      point1 = dokument.liesKoordinaten();

      // Linien zu allen Soehnen ziehen
      point2 = new Point(0,0);
      for (int i = 0; i < dokument.sohn.length; i++) {

         // neue Endkoordinaten ermitteln
         point2 = struktur.dokumentListe[dokument.sohn[i]].liesKoordinaten();

         if (struktur.dokumentListe[dokument.sohn[i]].fehlernummer != 0)  {
            // i-ter Sohn fehlerhaft, Linie rot
            g.setColor(Color.red);
         }
         else {
            // Sonst linie schwarz
            g.setColor(Color.black);
         }
         g.drawLine(point1.x, point1.y, point2.x, point2.y);
      }
   }


   //Zeichnen aller Verbindungslinien durch Edges()
   public void paintEdges(Graphics g) {

      //Darstellen der Verbindungen aller Dokumente
      for (int i = 0; i < struktur.dokumentListe.length; i++) {
            Edges(g, struktur.dokumentListe[i]);
      }
   }

   public void paintNodes(Graphics g) {
      
      Point koordinatenRect;
      Point koordinatenString;
      int xRect, yRect, xString, yString;

      // Variablen zur Darstellung der Dokumentbezeichnung
      String darzustellenderText;
      int maxDarstellbarerString = 9;


      for (int i = 0; i < struktur.dokumentListe.length; i++) {
         //Koordinaten des Kaestchens
         koordinatenRect = struktur.dokumentListe[i].liesKoordinaten();
         xRect = koordinatenRect.x - (dokumentWidth/2);
         yRect = koordinatenRect.y - (dokumentHeight/2);

         //Darstellen der Kaestchen

         //Farbe der Kaestchen festlegen
         if (struktur.dokumentListe[i].fehlernummer != 0) {
            // Fehlerhaftes Dokument, dann rot
            g.setColor(Color.red);
         }
         else if (! struktur.dokumentListe[i].serverName.equals(
                    struktur.dokumentListe[struktur.startDokument].serverName)) {
            // Fremder Server, dann gelb
            g.setColor(Color.yellow);
         }
         //sonst gruen
         else g.setColor(Color.green);

         // Kaestchen ausfuellen
         g.fillRect(xRect, yRect, dokumentWidth, dokumentHeight);

         // schwarzen Rahmen zeichnen
         g.setColor(Color.black);
         g.drawRect(xRect, yRect, dokumentWidth, dokumentHeight);


         //Darzustellenden Namen des Dokuments ermitteln

         // Namen erfragen
         darzustellenderText = struktur.dokumentListe[i].name();

         // passt der ganze Name in nicht das Feld
         if (!(darzustellenderText.length() <= maxDarstellbarerString)) {
            // dann Namen entsprechend verkuerzen
            darzustellenderText = 
               darzustellenderText.substring(0,maxDarstellbarerString);
         }

         //Koordinaten, an denen der Text geschrieben wird
         koordinatenString = struktur.dokumentListe[i].liesKoordinaten();

         // Mittelpunkt verschieben, damit Text in die Box passt
         xString = koordinatenString.x - 31;
         yString = koordinatenString.y + 5;
         // Text schreiben
         g.drawString(darzustellenderText, xString, yString);
      }
   }


   // hier erfolgt die Darstellung
   public void paint(Graphics g) {

      // ausrichtung nach Scrollbars
      g.translate(-tx, -ty);

      // Darstellung der Struktur
      paintEdges(g);
      paintNodes(g);
   }
}





// Popup fuer die Arbeitsflaeche
class PopUp extends Choice {

   // Instanz der obigen Arbeitsflaeche
   LinkStructure struktur;
   Panel panel;

   // index des aktuellen Dokuments
   int dokument;




   // Konstruktor fuer leeres PopUp
   PopUp() {
      super();

      // ein Item muss vorhanden sein, sonst Fehler
      addItem(" ");

   }



   // eigentlich verwendeter Konstruktor der Klasse
   PopUp(Panel panel, LinkStructure struktur, String[] item, int dokument) {

      // Aufruf des Superklassenkonstruktors
      super();

      // Verwendung der jeweiligen Variablen
      this.struktur = struktur;
      this.panel = panel;
      this.dokument = dokument;

      // initialisiere Itemliste
      for(int i = 0; i < item.length; i++) {

         if (item[i] != null) addItem(item[i]);
      }   
   }



   public boolean handleEvent(Event evt) {

      if (evt.target == this) {

         if (getSelectedItem().equals("Zoom auf Unterstruktur")) {

            //System.out.println("Zoom ...");
            new WebLSD( new LinkStructure(struktur, dokument));
         }

         if (getSelectedItem().equals("Dokument anzeigen")) {

            if (Setup.browser != "") {
               (new ExternalProgram(Setup.browser + " " +
                                    struktur.dokumentListe[dokument].url())).start();
            }
         }

         // nach Auswahl PopUp loeschen
         panel.hide();
      }


   // aufruf der Superklassen-handleEvent Methode
   return super.handleEvent(evt);

   }

}





// Setup Konfigurationen
class Setup  extends Dialog {

   //Variablen fuer das Layout
   Button ok;
   Button save;
   Button cancel;

   Panel topPanel;
   Panel subPanel;


   // Auswahl der auszuwertenden LOG Files
   Choice logMenu;

   final int all = 0;
   final int tested = 1;
   final int own = 2;

   static int logFiles = -1;


   // gemeinsamer Name der Files
   TextField logField;
   static String log;

   // Name des Programms
   TextField progNameField;
   static String progName;


   // absoluter Name des zu verwendenden Webbrowsers
   TextField browserField;
   static String browser;


   // Name des ini Files
   TextField iniNameField;
   static String iniName;


   // Setup laden
   public void load(String setupName) {

      // Name der Setup Datei abspeichern
      iniName = setupName;

      try {
         try {
            DataInputStream setupDatei = new
               DataInputStream(new FileInputStream(setupName));

            // fuer alle Datensaetze: einlesen
            logFiles = Integer.parseInt(setupDatei.readLine());
            log      = setupDatei.readLine();
            progName = setupDatei.readLine();
            browser  = setupDatei.readLine();

            // .ini schliesen, wenn erledigt
            setupDatei.close();
         } 
         catch (FileNotFoundException e) {
            // .ini Datei nicht gefunden, Standard Werte setzen
            System.out.println("Datei "+ setupName +" nicht gefunden");
            logFiles = all;
            log      = "LinkTest";
            progName = "LinkTest";
            browser  = "";
         }
      }
      catch (IOException e) {
         System.out.println("Fehler beim lesen der Datei "
                             + setupName 
                             +" aufgetreten");
         // Exception vor oder nach dem Einlesen der Werte
         if (logFiles == -1)   logFiles = all;
         if (log == null)      log      = "LinkTest";
         if (progName == null) progName = "LinkTest";
         if (browser == null)  browser  = "";
      }

   }

   //Konstruktor fuer Setup bearbeiten
   Setup(Frame fr, String strg, boolean bool) {

      //Aufruf des Superklassenkonstruktors
      super(fr, strg, bool);

      //Dialogbox fuer Setup Bearbeiten... gestalten
      setLayout(new BorderLayout());

      //Hauptfenster fuer Information gestalten
      topPanel = new Panel();
      topPanel.setLayout(new GridLayout(6,2));

      topPanel.add(new Label("Name des Link Test Programms: "));
      topPanel.add(progNameField = new TextField(progName,25));

      topPanel.add(new Label("Name der LOG - Dateien:"));
      topPanel.add(logField = new TextField(log, 25));

      topPanel.add(new Label("Dokumentauswahl:"));
      logMenu = new Choice();
      logMenu.addItem("alle Dokumente");
      logMenu.addItem("fehlerfreie Dokumente");
      logMenu.addItem("getestete Dokumente");
      logMenu.select(logFiles);
      topPanel.add(logMenu);

      topPanel.add(new Label("WWW-Browser: "));
      topPanel.add(browserField = new TextField(browser,25));

      topPanel.add(new Label(""));
      topPanel.add(new Label(""));

      topPanel.add(new Label("Setup speichern als: "));
      topPanel.add(iniNameField = new TextField(iniName,25));



      //Unterfenster fuer Button erzeugen
      subPanel = new Panel();
      subPanel.setLayout(new FlowLayout(FlowLayout.CENTER,50,50));
      subPanel.add(ok = new Button ("OK"));
      subPanel.add(cancel = new Button("Cancel"));
      subPanel.add(new Label(" "));
      subPanel.add(save = new Button("Save"));

      //das gesamte Layout in DialogBox einfuegen
      add("Center",topPanel);
      add("South",subPanel);

      //Anzeigen der Dialog-Box muss ausserhalb erfolgen

   }


   public void save() {

      try {

         DataOutputStream setupDatei = new
            DataOutputStream(new FileOutputStream(iniName));
         //System.out.println("Schreiben des Files: "+ iniName);

         // fuer alle Datensaetze: abspeichern
         setupDatei.writeBytes(String.valueOf(logFiles)+"\n");
         setupDatei.writeBytes(log+"\n");
         setupDatei.writeBytes(progName+"\n");
         setupDatei.writeBytes(browser+ "\n");

         // .ini schliesen, wenn erledigt
         setupDatei.close();      
      }
      catch (IOException e) {
         System.out.println(iniName +" konnte nicht korrekt gespeichert werden");
      }

   }


   public boolean handleEvent (Event evt) {
      switch (evt.id) {
      case Event.ACTION_EVENT:

         //cancel, dann verwerfen
         if (evt.target == cancel) {
            this.hide();
         }

         // ansonsten uebernehmen
         else {
            progName = progNameField.getText();
            log      = logField.getText();
            logFiles = logMenu.getSelectedIndex();
            browser  = browserField.getText();
            iniName  = iniNameField.getText();

            this.hide();

            // bei save noch abspeichern
            if (evt.target == save) this.save();

         }


         break;
      }
      return super.handleEvent(evt);
   }

}






// Fenster fuer kurze Informationen
class InfoFenster extends Dialog {

   Button ok;
   Panel topPanel;
   Panel subPanel;

   //Konstruktor fuer InfoFenster
   InfoFenster(Frame fr, String name, boolean bool, String[] inhalte) {

      //Aufruf des Superklassenkonstruktors
      super(fr, name, bool);

      //Dialogbox fuer Hilfe Ueber... gestalten
      setLayout(new BorderLayout());

      //Hauptfenster fuer Information gestalten
      topPanel = new Panel();
      topPanel.setLayout(new GridLayout(inhalte.length + 2, 1));
      topPanel.add(new Label(""));
      for (int i = 0; i< inhalte.length; i++) {
         topPanel.add(new Label(inhalte[i],Label.CENTER));
      }

      //Unterfenster fuer Button erzeugen
      subPanel = new Panel();
      subPanel.setLayout(new FlowLayout());
      subPanel.add(ok = new Button ("OK"));
   
      //das gesamte Layout in DialogBox einfuegen
      add("Center",topPanel);
      add("South",subPanel);

      //Anzeigen der DialogBox
      this.pack();
      this.show();

   }


   public boolean handleEvent (Event evt) {
      switch (evt.id) {
      case Event.ACTION_EVENT:
         if (evt.target instanceof Button) {
            if (evt.target == ok) this.hide();
         }
         break;
      }
      return super.handleEvent(evt);
   }

}



Copyright Munich Network Management Team