
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;


// Komplettes Dialogfenster mit allen Testbeispielen der Basis-Klasse

public class BspBasis extends JFrame {

//  JToolBar toolBar;
  JButton BnMessage1 = new JButton();  // Message
  JButton BnError2 = new JButton(); // Error
  JButton BnYesNo3 = new JButton(); // YesNo
  JButton BnYesNoEsc4 = new JButton(); // YesNoESC
  JButton BnOkEsc5 = new JButton(); // OK ESC

  JButton BnInput = new JButton(); // Input

  JButton BnIVAL6 = new JButton();  // IVAL
  JButton BnIVAL7 = new JButton();  // IVAL

  JButton BnLVAL8 = new JButton();  // LVAL
  JButton BnLVAL9 = new JButton();  // LVAL

  JButton BnDVAL10 = new JButton();  // DVAL
  JButton BnDVAL11 = new JButton(); // DVAL

  JButton BnDStr12 = new JButton(); // DStr
  JButton BnIStr2 = new JButton(); // IStr2
  JButton BnLStr2 = new JButton(); // LStr2
  JButton BnKomma2Point15 = new JButton(); // Komma2Point
  JButton BnPoint2Komma16 = new JButton(); // Point2Komma

  JButton BnLog10_17 = new JButton(); // Log10

// DATEI FUNKTIONEN
  JButton BnchangeFileExt18 = new JButton(); // changeFileExt   .TXT

  JButton BngetFileExt19 = new JButton(); // getFileExt
  JButton BngetFileNameExt20 = new JButton(); // getFileNameExt
  JButton BngetFileName21 = new JButton(); // getFileName

  JButton BnFileExists22 = new JButton(); // FileExists
  JButton BnCheckFileName23 = new JButton(); // CheckFileName


  //Frame konstruieren
  public BspBasis() {
    Container cp = this.getContentPane();
    this.getContentPane().setLayout( new FlowLayout() );

    this.setSize(new Dimension(500, 250));
    this.setTitle("Beispielprogramm für die Basis-Klasse");


    BnMessage1.setText("Message");
    BnMessage1.setToolTipText("Anzeige einer Messagebox");
    BnMessage1.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnMessage_actionPerformed(e);
      }
    });
    cp.add(BnMessage1);
    // ----------------------------------------

    BnError2.setText("Error");
    BnError2.setToolTipText("Anzeige einer Errorbox (Stop-Schild)");
    BnError2.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnError_actionPerformed(e);
      }
    });
    cp.add(BnError2);

    // ----------------------------------------
    BnYesNo3.setText("YesNo");
    BnYesNo3.setToolTipText("Abfrage YesNo");
    BnYesNo3.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnYesNo_Click();
      }
    });
    cp.add(BnYesNo3);
    // ----------------------------------------

    // ----------------------------------------
    BnYesNoEsc4.setText("YesNoEsc");
    BnYesNoEsc4.setToolTipText("Abfrage Ja / Nein / Abbruch");
    BnYesNoEsc4.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnYesNoEsc_Click();
      }
    });
    cp.add(BnYesNoEsc4);



    // ----------------------------------------
    BnOkEsc5.setText("Okay ESC");
    BnOkEsc5.setToolTipText("Abfrage Ok und Abbruch");
    BnOkEsc5.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnOkEsc_Click();
      }
    });
    cp.add(BnOkEsc5);



    BnInput.setText("Input");
    BnInput.setToolTipText("Eingabe eines Textes");
    BnInput.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnInput_Click();
      }
    });
    cp.add(BnInput);



    // ----------------------------------------
    BnIVAL6.setText("IVal");
    BnIVAL6.setToolTipText("Umwandlung und Test auf Integer");
    BnIVAL6.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnIVAL1_Click();
      }
    });
    cp.add(BnIVAL6);


    // ----------------------------------------
    BnIVAL7.setText("IVal");
    BnIVAL7.setToolTipText("Umwandlung und Test auf Integer");
    BnIVAL7.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnIVAL2_Click();// Fehlerhaft
      }
    });
    cp.add(BnIVAL7);



    // ----------------------------------------
    BnLVAL8.setText("LVal");
    BnLVAL8.setToolTipText("Umwandlung und Test auf Long");
    BnLVAL8.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnLVAL1_Click();
      }
    });
    cp.add(BnLVAL8);


    BnLVAL9.setText("LVal");
    BnLVAL9.setToolTipText("Umwandlung und Test auf Long");
    BnLVAL9.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnLVAL2_Click();  // Fehlerhaft
      }
    });
    cp.add(BnLVAL9);



    // ----------------------------------------
    BnDVAL10.setText("DVal");
    BnDVAL10.setToolTipText("Umwandlung und Test auf Double");
    BnDVAL10.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnDVAL1_Click();
      }
    });
    cp.add(BnDVAL10);


    BnDVAL11.setText("DVal");
    BnDVAL11.setToolTipText("Umwandlung und Test auf Double");
    BnDVAL11.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnDVAL2_Click();  // Fehlerhaft
      }
    });
    cp.add(BnDVAL11);

    // --------------------------

    BnDVAL11.setText("DVal");
    BnDVAL11.setToolTipText("Umwandlung und Test auf Double");
    BnDVAL11.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnDVAL2_Click();  // Fehlerhaft
      }
    });
    cp.add(BnDVAL11);



    // --------------------------
    // --------------------------
    BnDStr12.setText("DStr");
    BnDStr12.setToolTipText("Anzeige double mit Format");
    BnDStr12.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnDStr_Click();
      }
    });
    cp.add(BnDStr12);


    BnIStr2.setText("IStr2");
    BnIStr2.setToolTipText("Anzeige Int mit 2 Stellen");
    BnIStr2.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnIStr2_Click();
      }
    });
    cp.add(BnIStr2);


    BnLStr2.setText("LStr2");
    BnLStr2.setToolTipText("Anzeige Int mit 2 Stellen");
    BnLStr2.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnLStr2_Click();
      }
    });
    cp.add(BnLStr2);


    BnKomma2Point15.setText("Komma2Point");
    BnKomma2Point15.setToolTipText("Umwandlung Komma to Punkt");
    BnKomma2Point15.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnKomma2Point_Click();
      }
    });
    cp.add(BnKomma2Point15);


    BnPoint2Komma16.setText("Point2Komma");
    BnPoint2Komma16.setToolTipText("Umwandlung Punkt to Komma");
    BnPoint2Komma16.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnPoint2Komma_Click();
      }
    });
    cp.add(BnPoint2Komma16);



    BnLog10_17.setText("Log10");
    BnLog10_17.setToolTipText("Logarithmus zur Basis 10");
    BnLog10_17.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnPoint2Komma_Click();
      }
    });
    cp.add(BnLog10_17);


    // ------------------------------
    // Datei Operationen
    // changeFileExt  Austausch der Extension
    BnchangeFileExt18.setText("changeFileExt");
    BnchangeFileExt18.setToolTipText("changeFileExt");
    BnchangeFileExt18.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnchangeFileExt_Click();
      }
    });
    cp.add(BnchangeFileExt18);


    // getFileExt
    BngetFileExt19.setText("getFileExt");
    BngetFileExt19.setToolTipText("Nur die Dateierweiterung");
    BngetFileExt19.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BngetFileExt_Click();
      }
    });
    cp.add(BngetFileExt19);


    
    BngetFileNameExt20.setText("getFileNameExt");
    BngetFileNameExt20.setToolTipText("Dateinamen ohne Pfad");
    BngetFileNameExt20.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BngetFileNameExt_Click();
      }
    });
    cp.add(BngetFileNameExt20);


    BngetFileName21.setText("getFileName");
    BngetFileName21.setToolTipText("getFileName");
    BngetFileName21.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BngetFileName_Click();
      }
    });
    cp.add(BngetFileName21);


    BnFileExists22.setText("FileExists");
    BnFileExists22.setToolTipText("Prüfen, ob die Datei existiert");
    BnFileExists22.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnFileExists_Click();
      }
    });
    cp.add(BnFileExists22);


    BnCheckFileName23.setText("CheckFileName");
    BnCheckFileName23.setToolTipText("Prüft, ob die Datei korrekt eingeben wurde");
    BnCheckFileName23.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        BnCheckFileName_Click();
      }
    });
    cp.add(BnCheckFileName23);


    // ------------------------------------



    //    this.getContentPane().add(toolBar, BorderLayout.NORTH);
  }  // jbInit()




  public static void main(String[] args) {
    BspBasis frame = new BspBasis();
    //Frames validieren, die eine voreingestellte Größe besitzen
    //Frames packen, die nützliche bevorzugte Infos über die Größe besitzen, z.B. aus ihrem Layout
    // frame.validate();
    //Fenster zentrieren
    Dimension frameSize = frame.getSize();
    // frameSize.height = screenSize.height;
    // frameSize.width = screenSize.width;
    frame.setVisible(true);  // show()
  }


  //Überschreiben, damit das Programm bei Herunterfahren des Systems beendet werden kann
  protected void processWindowEvent(WindowEvent e) {
    super.processWindowEvent(e);
    if(e.getID() == WindowEvent.WINDOW_CLOSING) {
      System.exit(0);
    }
  }


 void BnMessage_actionPerformed(ActionEvent e) {
    basis.Message("Hinweis","Ihre Festplatte wird formatiert");
  }  // Message



 void BnError_actionPerformed(ActionEvent e) {
    basis.Error("Fehler","Sie haben den Virus 'Yankee-Doodle'");
  }  // Error


  // Liefert eine MassageBox,mit einem Ja- und Nein-Schalter
 void BnYesNo_Click() {
    boolean b;
    b = basis.YesNo("Abfrage","Sind Sie Student?");
    if (b)
      basis.Message("Meldung","Welchen Studiengang?");
    else
      basis.Message("Meldung","Sehr gut, Sie haben also einen ordentlichen Beruf!");
  }  // Bn YesNo



  // Liefert eine MassageBox,mit Ja-,  Nein- und einem Abbruch-Schalter
 void BnYesNoEsc_Click() {
    int rectode;
    rectode = basis.YesNoEsc("Beenden des Dialogfensters","Wollen Sie die Datei speichern?");
    switch (rectode) {
     case basis.YES: basis.Message("Meldung","Datei gespeichert, jetzt Ende");
                     // saveFile();
                     break;
     case basis.NO: basis.Message("Meldung","Datei nicht gespeichert, jetzt Ende");
                     break;
     case basis.ESC: basis.Message("Meldung","Abbruch!");
                     break;
    }
  }  // Bn YesNo ESC


  // Liefert eine MassageBox,mit einem Ok- und Abbruch-Schalter
 void BnOkEsc_Click() {
    boolean b;
    b = basis.OkEsc("Abfrage","Sind Sie Student?");
    if (b)
      basis.Message("Meldung","Welchen Studiengang?");
    else
      basis.Message("Meldung","Sehr gut, Sie haben also einen ordentlichen Beruf!");
  }  // Bn Okay  und Esc



 void BnInput_Click() {
    String erg;
    erg = basis.getInput("Name","Eingabe des Studentennamens");
    basis.Message("Meldung","Name"+'\n' + erg);
  }  // Bn Okay  und Esc





    // Numerik

 void BnIVAL1_Click() {
   int erg;
   String s;
   s = "45451234";
    // Abfrage
   if ( basis.IVal(s) ) {
     erg = basis.getIValResult();   // Ergebnis holen
     basis.Message("Konvertierung okay","Ergebnis: "+Integer.toString(erg) );
   }
   else {
     basis.Message("Konvertierung fehlerhaft","Text: "+basis.getErrorCode()+'\n'+s );
   }
 }  //  Bn IVal


 void BnIVAL2_Click() {
   int erg;
   String s;
   s = "454545451234";
    // Abfrage
   if ( basis.IVal(s) ) {
     erg = basis.getIValResult();   // Ergebnis holen
     basis.Message("Konvertierung okay","Ergebnis: "+Integer.toString(erg) );
   }
   else {
     basis.Message("Konvertierung fehlerhaft","Text: "+basis.getErrorCode()+'\n'+s );
   }
 }  //  Bn IVal


 void BnLVAL1_Click() {
   long erg;
   String s;
   s = "454545451234";
    // Abfrage
   if ( basis.LVal(s) ) {
     erg = basis.getLValResult();   // Ergebnis holen
     basis.Message("Konvertierung okay","Ergebnis: "+Long.toString(erg) );
   }
   else {
     basis.Message("Konvertierung fehlerhaft","Text: "+basis.getErrorCode()+'\n'+s );
   }
 }  //  Bn LVal1


 void BnLVAL2_Click() {
   long erg;
   String s;
   s = "54545454554545451234";
    // Abfrage
   if ( basis.LVal(s) ) {
     erg = basis.getLValResult();   // Ergebnis holen
     basis.Message("Konvertierung okay","Ergebnis: "+Long.toString(erg) );
   }
   else {
     basis.Message("Konvertierung fehlerhaft","Text: "+basis.getErrorCode()+'\n'+s );
   }
 }  //  Bn LVal2


 void BnDVAL1_Click() {
   double erg;
   String s;
   s = "1234.444";
    // Abfrage
   if ( basis.DVal(s) ) {
     erg = basis.getDValResult();   // Ergebnis holen
     basis.Message("Konvertierung okay","Ergebnis: "+Double.toString(erg) );
   }
   else {
     basis.Message("Konvertierung fehlerhaft","Text: "+basis.getErrorCode() );
   }
 }  //  Bn DVal1


 void BnDVAL2_Click() {
   double erg;
   String s;
   s = "g55554";
    // Abfrage
   if ( basis.DVal(s) ) {
     erg = basis.getDValResult();   // Ergebnis holen
     basis.Message("Konvertierung okay","Ergebnis: "+Double.toString(erg) );
   }
   else {
     basis.Message("Konvertierung fehlerhaft","Text: "+basis.getErrorCode() );
   }
 }  //  Bn DVal2


   // ---------------------------------
  void BnDStr_Click() {
    double d = 12.3456789;
    basis.Message("Anzeige DStr","Ergebnis: "+basis.DStr(d,3) );
  }

  void BnIStr2_Click() {
    int d = 9;
    basis.Message("Anzeige IStr2","Ergebnis: "+basis.IStr2(d) );
  }

  void BnLStr2_Click() {
    long d = 9;
    basis.Message("Anzeige LStr2","Ergebnis: "+basis.LStr2(d) );
  }

  void BnKomma2Point_Click() {
    String s = "4512,34789";
    basis.Message("Anzeige Komma2Point","Ergebnis: "+basis.Komma2Point(s) );
  }

  void BnPoint2Komma_Click() {
    String s = "4512.34789";
    basis.Message("Anzeige Point2Komma","Ergebnis: "+basis.Point2Komma(s) );
  }


  // -----------------------------------------------

   void  BnchangeFileExt_Click() {
     String s1 = "c:\\java\\labor1\\test.java";
     String s2 = "";
     s2 = basis.changeFileExt(s1,".class");
     basis.Message("changeFileExt","Ergebnis: "+'\n'+s1+'\n'+s2 );
   }

   void  BngetFileExt_Click() {
     String s1 = "c:\\java\\labor1\\test.java";
     String s2 = "";
     s2 = basis.getFileExt(s1);
     basis.Message("getFileExt","Ergebnis: "+'\n'+s1+'\n'+s2 );
   }


   void BngetFileNameExt_Click() {
     String s1 = "c:\\java\\labor1\\test.java";
     String s2 = "";
     s2 = basis.getFileNameExt(s1);
     basis.Message("changeFileExt","Ergebnis: "+'\n'+s1+'\n'+s2 );
   }

     // Schneidet die Extension ab
     // liefert Pfad+Name
   void  BngetFileName_Click() {
     String s1 = "c:\\java\\labor1\\test.java";
     String s2 = "";
     s2 = basis.getFileName(s1);
     basis.Message("getFileName","Ergebnis: "+'\n'+s1+'\n'+s2 );
   }



   void  BnFileExists_Click() {
     String s1 = "c:\\java\\labor1\\test.java";
     //String s = "D:\\java\\hs-md\\src\\org\\app\\basis\\BasisIO.java";
     String s = "c:\\test.java";
     if ( basis.FileExists(s) )
       basis.Message("FileExists","Die Datei existiert "+'\n'+s );
     else
       basis.Message("FileExists","Die Datei existiert nicht"+'\n'+s );
   }


   void BnCheckFileName_Click() {
     String s1 = "test.java";
     String s2 = "D:\\java\\hs-md\\src\\org\\app\\basis\\BasisIO.java";
     String s;
     s = s2;
     if ( basis.CheckFileName(s) )
       basis.Message("CheckFileName","Die Datei ist okay "+'\n'+s );
     else
       basis.Message("CheckFileName","Die Datei ist nicht okay "+'\n'+s );
   }



    void BnOpenDialog_Click() {
    }

    void BnSaveDialog_Click() {
    }

}  // BspBasis





  // --------------------------------------------------------------
  // --------------------------------------------------------------
  // --------------------------------------------------------------
  // --------------------------------------------------------------


// Die folgende Klasse dient zur Konvertierung von String in Zahlen
// Sie kapselt die Konvertierung
// Beispiel für int
/*
  String s;
  int erg;
  s = "1234";
    // Abfrage
  if ( basis.IVal(s) ) {
     erg = basis.getIValResult();   // Ergebnis holen
  }
*/

/*  METHODEN:
/*  METHODEN:
/*  METHODEN:

// DIALOGFENSTER
    public static void Error( String sTitle, String sMessage) {
    public static void Message( String sTitle, String sMessage) {
    public static boolean YesNo( String sTitle, String sMessage) {
    public static int YesNoEsc( String sTitle, String sMessage) {
    public static boolean OkEsc( String sTitle, String sMessage) {
        // gibt einen Klartext für die Konvertierung aus
    public static String getErrorCode() {
    public static String getInput( String sTitle, String sMessage) {


// UMWANDLUNG STRING ->  int, long, double
    public static boolean IVal(String szText) {
    public static int getIValResult() {
    public static boolean LVal(String szText) {
    public static long getLValResult() {
    public static boolean DVal(String szText) {
    public static double getDValResult() {


// AUSGABE EINER FORMATIERTEN ZAHL
      Parameter nk beschreibt die Nachkommastelle
    public static String DStr(double d, int nk) {
    public static String IStr2(int iZahl) {
    public static String LStr2(long lZahl) {
    public static String Komma2Point(String szZ) {
    public static String Point2Komma(String szZ) {

// MATHEMATIK
    public static double log10(double x) {

// DATEI FUNKTIONEN
    public static String changeFileExt(String szDateiname, String szExt) {
    public static String getFileExt(String szDateiname) {
    public static String getFileNameExt(String szDateiname) {

     // Schneidet die Extension ab
    public static String getFileName(String szDateiname) {
    public static boolean FileExists(String szDateiname) {

    public static void centerScreen(java.awt.Window frame, java.awt.Dimension preset) {

*/
class basis {

    public static final int C_LEER = 1;
    public static final int C_KEINEZAHL = 2;
    public static final int C_ZUKLEIN = 3;
    public static final int C_ZUGROSS = 4;

      // Konstanten für den Error Code als String
    public static final String SZ_LEER = "Leerer Text";
    public static final String SZ_KEINEZAHL = "Konvertierung schlug fehl";
    public static final String SZ_ZUKLEIN = "Für den Bereich zu klein";
    public static final String SZ_ZUGROSS = "Für den Bereich zu groß";



    // Damit braucht man nicht die Konstanten aus JOptionPane referenzieren
    public static final int YES = 1;
    public static final int NO = 2;
    public static final int ESC = 3;

    private static int intVal;          // speichert das Ergebnis
    private static long longVal;        // speichert das Ergebnis
    private static double dblVal;       // speichert das Ergebnis

    private static int ValError = 0;   // speichert den Konvertierungfehler





    // Zeigt eine Fehlermeldung an
  public static void Error( String sTitle, String sMessage) {
    JOptionPane.showConfirmDialog(null,sMessage,sTitle,
      JOptionPane.DEFAULT_OPTION,
      JOptionPane.ERROR_MESSAGE);  // Symbol
    /*  Optionen der Schalter:
         DEFAULT_OPTION    Ok
         YES_NO_OPTION
         YES_NO_CANCEL_OPTION
         OK_CANCEL_OPTION
     */
     /*  Symbole:
      ERROR_MESSAGE
      INFORMATION_MESSAGE
      WARNING_MESSAGE
      QUESTION_MESSAGE
      PLAIN_MESSAGE
     */

  } // Fehler

    // Zeigt eine Fehlermeldung an
  public static void Message( String sTitle, String sMessage) {
    JOptionPane.showConfirmDialog(null,sMessage,sTitle,
      JOptionPane.DEFAULT_OPTION,
      JOptionPane.INFORMATION_MESSAGE);  // Symbol
    /*  Optionen der Schalter:
         DEFAULT_OPTION    Ok
         YES_NO_OPTION
         YES_NO_CANCEL_OPTION
         OK_CANCEL_OPTION
     */
     /*  Symbole:
      ERROR_MESSAGE
      INFORMATION_MESSAGE
      WARNING_MESSAGE
      QUESTION_MESSAGE
      PLAIN_MESSAGE
     */

  } // Fehler

    // Zeigt eine Fehlermeldung an
  public static boolean YesNo( String sTitle, String sMessage) {
    int retcode;
    retcode = JOptionPane.showConfirmDialog(null,sMessage,sTitle,
      JOptionPane.YES_NO_OPTION,
      JOptionPane.QUESTION_MESSAGE);  // Symbol

    switch (retcode) {
       case JOptionPane.YES_OPTION:
         // ja, Änderungen speichern
         return true;
       case JOptionPane.NO_OPTION:
         return false;
       case JOptionPane.CANCEL_OPTION:
       default:
         // abbrechen
         return false;
    }
  } // Fehler


    // Zeigt eine Fehlermeldung an
  public static int YesNoEsc( String sTitle, String sMessage) {
    int retcode;
    retcode = JOptionPane.showConfirmDialog(null,sMessage,sTitle,
      JOptionPane.YES_NO_CANCEL_OPTION,
      JOptionPane.QUESTION_MESSAGE);  // Symbol

    switch (retcode) {
       case JOptionPane.YES_OPTION:
         // ja, Änderungen speichern
         return YES;
       case JOptionPane.NO_OPTION:
         return NO;
       case JOptionPane.CANCEL_OPTION:
       default:
         return ESC;
    }
  } // YES NO ESC


    // Zeigt eine Fehlermeldung an
  public static boolean OkEsc( String sTitle, String sMessage) {
    int retcode;
    retcode = JOptionPane.showConfirmDialog(null,sMessage,sTitle,
      JOptionPane.OK_CANCEL_OPTION,
      JOptionPane.INFORMATION_MESSAGE);  // Symbol

    switch (retcode) {
       case JOptionPane.OK_OPTION:
         // ja, Änderungen speichern
         return true;
       case JOptionPane.CANCEL_OPTION:
       default:
         // abbrechen
         return false;
    }
  } // Ok ESC


    // Eingabe eines String
  public static String getInput( String sTitle, String sMessage) {
    return JOptionPane.showInputDialog(null, sTitle, sMessage, 1);
  } // 




    // -------------------------------------------

      // gibt einen Klartext für die Konvertierung aus
    public static String getErrorCode() {
      switch (ValError) {
        case C_LEER :      return SZ_LEER;
        case C_KEINEZAHL : return SZ_KEINEZAHL;
        case C_ZUKLEIN :   return SZ_ZUKLEIN;
        case C_ZUGROSS :   return SZ_ZUGROSS;
        default:           return "Fehlerhafter Index in Methode getErrorCode: "+Integer.toString(ValError);
      } // switch
    }
    
    
    public static boolean IVal(String szText) {
        // erläuterung von iIVal = Integer.valueOf(szText).intValue();
        boolean result = true;
        String s;
        s = new String(szText); // neues Objekt
        s.trim();
        if (s.length() == 0) {
            ValError = C_LEER;
            intVal = 0;
            result = false;
        }
        else {
            try {
                intVal = Integer.valueOf(szText).intValue();
                ValError = 0;
            }
            catch (NumberFormatException e) {
                // Check ob die "Zahl" für den Integerbereich zu klein oder zu groß
                // System.err.println(e);
                try {
                    dblVal = Double.valueOf(szText).doubleValue();
                    if ( dblVal<Integer.MIN_VALUE) {
                      ValError = C_ZUKLEIN;
                    }
                    if ( dblVal>Integer.MAX_VALUE) {
                      ValError = C_ZUGROSS;
                    }
                }
                catch (NumberFormatException e2) {
                    // Hier könnte noch eine genauere Abfrage integriert werde,
                    // ob die Zahl nicht zu groß für den int-Bereich ist
                    // System.err.println(e);
                    ValError = C_KEINEZAHL;
                    intVal = 0;
                    result = false;
                }
                intVal = 0;
                result = false;
            }
        }
        return result;
    } // IVal



    /**
     * getIValResult
     * @return int iIVal
     * @param none
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use gibt den Wert der Konvertierung aus, oder den Fehlerwert Example
     * @see #getIValError
     * @see #setIValError
     */
    public static int getIValResult() {
       return intVal;
    }




    /**
     * LVal
     * @return boolean StringIsLong
     * @param String szText
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use Ausgabe des Konvertierten String als long Wert Example
     * @see #getLValError
     * @see #getLValResult
     */
    public static boolean LVal(String szText) {
        // erläuterung von iIVal = Integer.valueOf(szText).intValue();
        boolean result = true;
        String s;
        s = new String(szText); // neues Objekt
        s.trim();
        if (s.length() == 0) {
            ValError = C_LEER;
            longVal = 0;
            result = false;
        }
        else {
            try {
                longVal = Long.valueOf(szText).longValue();
                ValError = 0;
            }
            catch (NumberFormatException e) {
                // Check ob die "Zahl" für den Integerbereich zu klein oder zu groß
                // System.err.println(e);
                try {
                    dblVal = Double.valueOf(szText).doubleValue();
                    if ( dblVal<Long.MIN_VALUE) {
                      ValError = C_ZUKLEIN;
                    }
                    if ( dblVal>Long.MAX_VALUE) {
                      ValError = C_ZUGROSS;
                    }
                }
                catch (NumberFormatException e2) {
                    // Hier könnte noch eine genauere Abfrage integriert werde,
                    // ob die Zahl nicht zu groß für den int-Bereich ist
                    // System.err.println(e);
                    ValError = C_KEINEZAHL;
                    longVal = 0;
                    result = false;
                }
                longVal = 0;
                result = false;
            }
        }
        return result;
    } // LVal



    /**
     * getLValResult
     * @return int lIVal
     * @param none
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use gibt den Wert der Konvertierung aus, oder den Fehlerwert Example
     * @see #getIValError
     * @see #setIValError
     */
    public static long getLValResult() {
       return longVal;
    }



     // Double
    /**
     * LVal
     * @return boolean StringIsLong
     * @param String szText
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use Ausgabe des Konvertierten String als long Wert Example
     * @see #getLValError
     * @see #getLValResult
     */
    public static boolean DVal(String szText) {
        // erläuterung von iIVal = Integer.valueOf(szText).intValue();
        boolean result = true;
        String s;
        s = new String(szText); // neues Objekt
        s.trim();
        if (s.length() == 0) {
            ValError = C_LEER;
            dblVal = 0;
            result = false;
        }
        else {
            try {
                dblVal = Double.valueOf(szText).doubleValue();
                ValError = 0;
            }
            catch (NumberFormatException e) {
                ValError = C_KEINEZAHL;
                dblVal = 0;
                result = false;
            }
        }
        return result;
    } // LVal



    /**
     * getDValResult
     * @return double DVal
     * @param none
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use gibt den Wert der Konvertierung aus, oder den Fehlerwert Example
     * @see #getDValError
     * @see #setDValError
     */
    public static double getDValResult() {
       return dblVal;
    }


    


   // Ausgaben einer formatierten Zahl

   
   /* BESCHREIBUNG     : konvertiert einen double in einem String          */
   /*                    Parameter nk beschreibt die Nachkommastelle       */
   //                    nk = Anzahl der Nachkommastellen
    public static String DStr(double d, int nk) {
        java.text.NumberFormat NF = java.text.NumberFormat.getInstance();
        NF.setMinimumFractionDigits(nk);
        NF.setMaximumFractionDigits(nk);
        return NF.format(d);
    }  // DStr

  /*  BESCHREIBUNG     : konvertiert ein int einen String mit mindestens   */
  /*                     zwei gültigen Ziffern                             */
  /*                     12     --->   "12"                                */
  /*                     123    --->   "123"                               */
  /*                     2      --->   "02"                                */
  /*                     1      --->   "01"                                */
  /*                     8      --->   "08"                                */

    /**
     * IStr2
     * @return String ZweistelligeZahl
     * @param int izahl
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use wandelt den int Wert in einen zweistelligen String um Example 1 -> 01   123 ->  123
     * @see #IStr2
     * @see #LStr2
     */
    public static String IStr2(int iZahl) {
        String s;
        java.text.NumberFormat NF = java.text.NumberFormat.getInstance();
        s = NF.format(iZahl);
        if (s.length() < 2) s = "0" + s;
        return s;
    }  // IStr2



    /**
     * LStr2
     * @return String ZweistelligeZahl
     * @param long lzahl
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use wandelt den long Wert in einen zweistelligen String um Example 1 -> 01   123 ->  123
     * @see #IStr2
     * @see #LStr2
     */
    public static String LStr2(long lZahl) {
        String s;
        java.text.NumberFormat NF = java.text.NumberFormat.getInstance();
        s = NF.format(lZahl);
        if (s.length() < 2) s = "0" + s;
        return s;
    }  // LStr2


  /*  BESCHREIBUNG     : konvertiert alle Kommas in einem String          */
    /**
     * Komma2Point
     * @return String
     * @param String szZ
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use ersetzt die Kommas im Parameter durch Punkte Example 1,23  -> 1.23
     * @see #Point2Komma
     */
    public static String Komma2Point(String szZ) {
        return szZ.replace(',', '.');
    } // siehe Komma2Point



    /**
     * Point2Komma
     * @return String
     * @param String szZ
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use ersetzt die Kommas im Parameter durch Punkte Example 1.234  ->  1,234
     * @see #Komma2Point
     */
    public static String Point2Komma(String szZ) {
        return szZ.replace('.', ',');
    }



    // Numerik

    /**
     * log10
     * @return double zahl
     * @param double x
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use Normierung Example
     * @see #bestimme_xswD
     * @see #IntPowerD
     */
    public static double log10(double x) {
        return Math.log(x) / Math.log(10);
    }

    

    // Datei Methoden



  /*  FUNKTIONSNAME    : changeFileExt                                     */
  /*                                                                       */
  /*  AUTOR            : Michael Wilhelm                                   */
  /*                                                                       */
  /*  DATUM (1.Version): 30.07.1999                                        */
  /*                                                                       */
  /*  BESCHREIBUNG     : ändert die Extention eines Dateinamens            */
    //   Beispiel
    //   szMom = bas.ChangeFileExt(szUFileName, ".MOM");

    /**
     * changeFileExt
     * @return String NewFileName
     * @param String szDateiname, String szExt
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use Example
     * @see #CheckFileName
     * @see #getFileExt Ändern der Dateiwerweiterung  TXT  -> DAT
     */
    public static String changeFileExt(String szDateiname, String szExt) {
        String szErgDatei;
        char ch;
        szErgDatei = "";
        File f = null;
        try {
            // evnetuell kann auch f.pathSeparatorChar verwendet werden
            f = new File(szDateiname);
            szErgDatei = f.getParent();
            ch = szErgDatei.charAt(szErgDatei.length() - 1);
            if (ch != '\\') szErgDatei = szErgDatei + '\\';
            //  + GetName(f.getName())+".ERG";  // Path
            szErgDatei = szErgDatei + getFileName(f.getName()) + szExt;
        }
        catch (Exception e) {
        }
        return szErgDatei;
    }
    //   Beispiel
    //   szMom = bas.getFileExt(szUFileName);
    //   szMom = ".MOM"

    /**
     * getFileExt
     * @return String Extension (.SNP)
     * @param String szDateiname
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use Example
     * @see #CheckFileName
     * @see #ChangeFileExt Ausgabe der Dateierweiterung
     */
    public static String getFileExt(String szDateiname) {
        int k, i, n;
        n = szDateiname.length();
        k = -1;
        // suche von hinten erstes Auftreten eines Punktes
        for (i = n - 1; i >= 0; i--) {
            if (szDateiname.charAt(i) == '.') {
                k = i;
                break;
            }
        }
        if (k == -1) // kein Punkt vorhanden
            return new String("");
        else {
            // substring zählt von NULL
            // Anfangsindex   EndIndex
            String s;
            s = szDateiname.substring(k, n);
            return szDateiname.substring(k, n);
        }
    } // getFileExt

    /**
     * GetFileName
     * @return String Name+Ext
     * @param String szDateiname
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use Example
     * @see #CheckFileName
     * @see #ChangeFileExt
     * @see #getFileName extrahiert den Dateinamen ohne Pfad
     */
    /*
      getFileName
    File F = new File(szDateiname);
    return F.getName();
   */
    public static String getFileNameExt(String szDateiname) {

        int k, i, n;
        n = szDateiname.length();
        k = -1;
        for (i = n - 1; i >= 0; i--) {
            if (szDateiname.charAt(i) == '\\') {
                k = i + 1;
                break;
            }
            if (szDateiname.charAt(i) == '/') {
                k = i + 1;
                break;
            }
        }
        if (k == -1)
            return szDateiname;
        else // beginIndex   endIndex
            return szDateiname.substring(k, n); // ??????  n-1 ist zu klein
    }

    /**
     * GetName
     * @return String Name
     * @param String szDateiname, String szExt
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use interne Prozedur, trennt den Dateinamen und gibt ihn aus Example
     * @see #CheckFileName
     * @see #ChangeFileExt
     * @see #getFileNameExt
     */
     // Schneidet die Extension ab
    public static String getFileName(String szDateiname) {
        int k, i, n;
        n = szDateiname.length();
        k = -1;
        for (i = n - 1; i >= 0; i--) {
            if (szDateiname.charAt(i) == '.') {
                k = i - 1;
                break;
            }
        }
        if (k == -1)
            return szDateiname;
        else
            return szDateiname.substring(0, k + 1);
    }  // getFileName


    public static boolean FileExists(String szDateiname) {
        File f = null;
        try {
            // evnetuell kann auch f.pathSeparatorChar verwendet werden
            f = new File(szDateiname);
            if (f.exists())
                return true;
            else
                return false;
        }
        catch (Exception e) {
            return false;
        }
    }



  /*  FUNKTIONSNAME    : CheckFileName                                     */
  /*  AUTOR            : Michael Wilhelm                                   */
  /*  DATUM (1.Version): 30.07.1999                                        */
  /*                                                                       */
  /*  BESCHREIBUNG     : prüft ob ein Name ein gültiger Dateiname ist      */
  /*  GEHÖRT ZU        : Basis-Routinen                                    */
  /*                                                                       */
  /*  EINGABEPARAMETER : String - Object                                   */
  /*                                                                       */
  /*  AUSGABEPARAMETER : String - Object                                   */
  /*                                                                       */
  /*  DATEIEN          : none                                             */
  /*  (lesen/ändern)                                                       */
  /*                                                                       */
  /*  GLOBALE VARIABLEN:  none                                            */
  /*  (Benutzt/Ändern)                                                     */
  /*                                                                       */
  /*  VERFAHREN        :  Check ob folgende Zeichen vorhanden sind,        */
  /*                      dann falsch                                      */
  /*                      \  /   :  ?  *  "  <  >  |                       */
  /*                      Suche geschieht mit der Methode indexOf          */
  /*                                                                       */
  /*  (Entwurfsscheidungen:                                                */
  /*  EXTERNE AUFRUFE  :  none                                            */
  /*  (Modul.Name)                                                         */
  /*  ÄNDERUNGEN       :                                                   */
  /*  (b. changerequest)                                                   */
  /*  (Änderungsdatum)                                                     */
  /*                                                                       */
  /* ***********************************************************************/

    /**
     * CheckFileName
     * @return boolean FileNameOkay
     * @param String szDateiname
     * @exception none
     * @version      1.0
     * @author Michael Wilhelm HS Harz, FB AI
     * @use Prüft, ob der Dateiname gültig ist Example 1.234  ->  1,234
     * @see #getFileName
     * @see #ChangeFileExt
     */
    public static boolean CheckFileName(String szDateiname) {
        if (szDateiname.length() == 0) {
            return false;
        }
        else {
            int i;
            i = szDateiname.indexOf('\\', 0);
            if (i > 0) return false;
            i = szDateiname.indexOf('/', 0);
            if (i > 0) return false;
            i = szDateiname.indexOf(':', 0);
            if (i > 0) return false;
            i = szDateiname.indexOf('?', 0);
            if (i > 0) return false;
            i = szDateiname.indexOf('*', 0);
            if (i > 0) return false;
            i = szDateiname.indexOf('"', 0);
            if (i > 0) return false;
            i = szDateiname.indexOf('<', 0);
            if (i > 0) return false;
            i = szDateiname.indexOf('>', 0);
            if (i > 0) return false;
            i = szDateiname.indexOf('|', 0);
            if (i > 0) return false;
            return true;
        }
    } //   pruefe_dateinamen


    /**
     * Center a frame to the screen. The size can be presetted or the actual frame size can be used.
     * @param frame Specifies the frame that should be centered
     * @param preset Specifies a preset dimension. If this is null, the dimension of the frame is used.
     */
    public static void centerScreen(java.awt.Window frame, java.awt.Dimension preset) {
        java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
        java.awt.Dimension frameSize;
        if (preset == null)
            preset = frame.getSize();
        if (preset.height > screenSize.height)
            preset.height = screenSize.height;
        if (preset.width > screenSize.width)
            preset.width = screenSize.width;
        // set new pos:
        frame.setBounds((screenSize.width - preset.width) / 2, (screenSize.height - preset.height) / 2,
            preset.width, preset.height);
    }






}  // basis











