/*
 *  jAckup.java
 *  $Source: f:/cvsroot2/open/projects/jAckup/ca/bc/webarts/tools/jackup/jAckup.java,v $
 *  $Name:  $
 *  $Revision: 1.8 $
 *  $Date: 2005-04-10 11:32:43 -0700 (Sun, 10 Apr 2005) $
 *  Copyright (c) 2002 Tom B. Gutwin P.Eng.
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
package ca.bc.webarts.tools.jackup;

import ca.bc.webarts.tools.Log;

import ca.bc.webarts.widgets.ClassConstants;
import ca.bc.webarts.widgets.ColouredLabel;
import ca.bc.webarts.widgets.JAboutBox;
import ca.bc.webarts.widgets.Splash;
import ca.bc.webarts.widgets.Util;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Event;
import java.awt.Font;
import java.awt.Image;
import java.awt.Label;
import java.awt.Panel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import java.io.File;

import java.net.URL;

import java.util.Iterator;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;
import javax.swing.KeyStroke;

import org.apache.log4j.Logger;
import org.apache.log4j.LogManager;
import org.apache.log4j.Priority;
import org.apache.log4j.PropertyConfigurator;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.util.XMLErrorHandler;

import org.xml.sax.SAXException;


/**
 *  jAckup Backup Utility.
 *
 * @author     tgutwin
 * @created    August 12, 2002
 */
public class jAckup extends JFrame implements AutoMenuBarUser
{
  /**  Constant holding the users file seperator. ("/" or "\")  */
  private final static String SYSTEM_FILE_SEPERATOR = File.separator;

  /**  Constant holding the users file seperator. ("/" or "\")  */
  private final static String SYSTEM_LINE_SEPERATOR =
    System.getProperty("line.separator");

  /**  The application name string  */
  private final static String APP_NAME = "jAckup";

  /**  The default jAckup Plan Filename that gets read in on a NEW command.  */
  private final static String JACKUPPLAN_DEFAULT_FILENAME =
    "jAckupPlanDefault.xml";

  /**  A Class holder for its name (used in Logging).  */
  private static String className_ = APP_NAME;

  /**  The log4j logger object. */
  protected static Logger logger_ = Logger.getLogger(jAckup.class.getName());

  /**  A generic Class accessable Label that is used throughout for Debug
   *   Stmnts to the screen. */
  protected ColouredLabel myDebugLabel_ =
    new ColouredLabel(new Color(5,5,100),
                      Color.white,
                      new Font("SanSerif", Font.PLAIN, 11),
                      "Debug Label.");

  /**  The XML jAckup Plan Document.  */
  private Document jAckupPlanDoc_ = null;

  /** Flags if jAckup will validate docs when read in **/
  private static boolean validatingXsd_ = true;

  /**
   *  The MenuBar. It gets initialized by the method <code>initMenuBar</code>
   *  of the AutoMenuBar class.
   *
   * @see    initMenuBar
   */
  private AutoMenuBar menuBar_ = null;

  /**  Description of the Field */
  private final static int NEW_MENUREF = 100;
  /**  Description of the Field */
  private final static int OPEN_MENUREF = 101;
  /**  Description of the Field */
  private final static int SAVE_MENUREF = 102;
  /**  Description of the Field */
  private final static int PRINT_MENUREF = 104;
  /**  Description of the Field */
  private final static int PRINTPREVIEW_MENUREF = 105;
  /**  Description of the Field */
  private final static int CLOSE_MENUREF = 107;
  /**  Description of the Field */
  private final static int EXIT_MENUREF = 108;
  /**  Description of the Field */
  private final static int FILESELECTIONS_MENUREF = 200;
  /**  Description of the Field */
  private final static int ARCHIVEFORMAT_MENUREF = 201;
  /**  Description of the Field */
  private final static int DEBUGLEVEL_MENUREF = 300;
  /**  Description of the Field */
  private final static int JLF_MENUREF = 302;
  /**  Description of the Field */
  private final static int PLF_MENUREF = 303;
  /**  Description of the Field */
  private final static int MLF_MENUREF = 304;
  /**  Description of the Field */
  private final static int HELP_MENUREF = 400;
  /**  Description of the Field */
  private final static int ABOUT_MENUREF = 402;


  /**  Basic constructor for this Object.  */
  public jAckup()
  {
    final String methodName = className_ + ": Constructor()";
    logger_.debug("Entering " + methodName);

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Initializes the GUI Main Area Panel (the tabbed pane, the
   *  inner panels etc.)
   *
   * @return JPanel the panel to go into the Main center area of jAckup
   */
  private JPanel initMainArea()
  {
    final String methodName = className_ + ": initMainArea()";
    logger_.debug("Entering " + methodName);

    JPanel retVal = new JPanel(new BorderLayout());
    JTabbedPane tabbedPane = new JTabbedPane();
    JPanel tab1Content = new JPanel(new BorderLayout());
    JPanel tab2Content = new JPanel(new BorderLayout());
    JPanel tab3Content = new JPanel(new BorderLayout());
    JPanel tab4Content = new JPanel(new BorderLayout());
    tab1Content.add(myDebugLabel_,"Center");
    //tab2Content.add(myDebugLabel_,"Center");
    //tab3Content.add(myDebugLabel_,"Center");
    //tab4Content.add(myDebugLabel_,"Center");
    tabbedPane.add("Tab1", tab1Content);
    tabbedPane.add("Tab2", tab2Content);
    tabbedPane.add("Tab3", tab3Content);
    tabbedPane.add("Tab4", tab4Content);
    tabbedPane.setForeground(Color.black);
    tabbedPane.setBackgroundAt(0,new Color(200,255,255));
    tabbedPane.setBackgroundAt(1,new Color(255,255,200));
    tabbedPane.setBackgroundAt(2,new Color(255,200,255));
    tabbedPane.setBackgroundAt(3,new Color(200,200,255));
    tabbedPane.setToolTipTextAt(0,"Tab1 ToolTip");
    tabbedPane.setToolTipTextAt(1,"Tab2 ToolTip");
    tabbedPane.setToolTipTextAt(2,"Tab3 ToolTip");
    tabbedPane.setToolTipTextAt(3,"Tab4 ToolTip");
    retVal.add(tabbedPane,"Center");

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Initializes the GUI upon startup. Sets up the menu, the tabbed pane, the
   *  inner panels etc.
   */
  private void initGui()
  {
    final String methodName = className_ + ": initGui()";
    logger_.debug("Entering " + methodName);


    /*
     *  create the menu bar
     */
    menuBar_ = new AutoMenuBar(this); //initMenuBar();
    menuBar_.addListeners();
    JPanel mainAreaPanel = initMainArea();

    getContentPane().add(menuBar_, "North");
    getContentPane().add(mainAreaPanel, "Center");


    logger_.debug("Exiting " + methodName);
  }


  /**  Forces a repaint to this apps menubar.  */
  private void repaintMenuBar()
  {
    final String methodName = className_ + ": repaintMenuBar()";


    if (menuBar_ != null)
    {
      menuBar_.repaint();
    }


  }


  /**
   *  Adds an ActionListener to the JMenuItem that is supplied in the passed
   *  param.
   *
   * @param  menuItem  The feature to be added to the Listener attribute
   */
  public void addListener(JMenuItem menuItem)
  {
    // Logger Trace Method Enter
    final String methodName = className_ + ": addListener(JMenuItem)";
    logger_.debug("Entering " + methodName);

    /*  use a simple indexOf helper function to look through the menu
     *  items and return an int to represent its HASH position   */
    String toolTipText = menuItem.getToolTipText();
    int indexRef = menuBar_.indexOf(toolTipText);

    StringBuffer sb = new StringBuffer(" Adding a listener for menu item ");
    sb.append(toolTipText);
    sb.append(" ");
    sb.append(indexRef);
    logger_.debug(sb.toString());

    final Component finalMenuItem = menuItem;
    /**  The log4j logger final object. */
    final Logger finalLogger = logger_;
    switch (indexRef)
    {
        case NEW_MENUREF:
          /*
           *  NEW jAckup Plan with defaults
           */
          menuItem.addActionListener(new newActionListener(finalMenuItem));
          break;

        case OPEN_MENUREF:
          /*
           *  Open  from File
           */
          menuItem.addActionListener(new openActionListener(finalMenuItem));
          break;

        case SAVE_MENUREF:
          /*
           *  Save Window Data To File
           */
          menuItem.addActionListener(new saveActionListener(finalMenuItem));
          break;

        case PRINT_MENUREF:
          /*
           *  print
           */
          menuItem.addActionListener(new printActionListener(finalMenuItem));
          break;

        case PRINTPREVIEW_MENUREF:
          /*
           *  print preview
           */
          menuItem.addActionListener(
            new printpreviewActionListener(finalMenuItem));
          break;

        case CLOSE_MENUREF:
          /*
           *  close
           */
          menuItem.addActionListener(
            new closeActionListener(finalMenuItem));
          break;

        case EXIT_MENUREF:
          /*
           *  exit
           */
          menuItem.addActionListener(
            new exitActionListener(finalMenuItem));
          break;

        case DEBUGLEVEL_MENUREF:
          /*
           *  Set The Debug Level
           */
          menuItem.addActionListener(
            new debuglevelActionListener(finalMenuItem));
          break;

        case JLF_MENUREF:
          /*
           *  Set the L&F to Java
           */
          menuItem.addActionListener(
            new jlfActionListener(finalMenuItem));
          break;

        case PLF_MENUREF:
          /*
           *  Set the L&F to Platform
           */
          menuItem.addActionListener(
            new plfActionListener(finalMenuItem));
          break;

        case MLF_MENUREF:
          /*
           *  Set the L&F to Motif
           */
           menuItem.addActionListener(
            new mlfActionListener(finalMenuItem));
          break;

        case HELP_MENUREF:
          /*
           *  Open the Help window
           */
          menuItem.addActionListener(
            new helpActionListener(finalMenuItem));
          break;

        case ABOUT_MENUREF:
          /*
           *  Open the About Box
           */
          menuItem.addActionListener(
            new aboutActionListener(finalMenuItem));
          break;

        default:
          // Logger Trace Method Enter
          finalLogger.warn("Unknown MenuItem Reference. Cannot Add A Listener:"+
                            indexRef);

    }
    logger_.debug("Exiting " + methodName);

  }


  /**
   *  Gets the Log object that the jAckup instance is using.
   *
   * @return    The Log.
   */
  public Logger getLogger()
  {
    final String methodName = className_ + ": getLogger()";
    return logger_;
  }


  /**
   *  The main program for the jAckup class
   *
   * @param  arg  The command line arguments
   */
  public static void main(String[] arg)
  {
    // log4j logger config
    PropertyConfigurator.configure("/logs/log4jConfig.txt");
    logger_.debug("Entering jAckup:main(String[])");

    String splashGraphic = "/images/dont_pan.jpg";
    logger_.debug("Loading Splash Graphic.");
    Image splashImage = Util.loadImage(splashGraphic);
    Panel p = new Panel();
    /*
     *  p.setBorder(new CompoundBorder(
     *  new MatteBorder(1,1,1,1,Color.black),
     *  new EmptyBorder(12,12,12,12)));
     */
    p.setBackground(new Color(210, 210, 210));
    Label l = new Label("Please wait while loading.");
    p.add(l);
    logger_.debug("Splashing.");
    Splash frame = new Splash(splashImage, 8000, p);

    logger_.debug("Instantiating the jAckup Object.");
    final jAckup classInstance = new jAckup();
    Util.setIconForApp(classInstance, "/images/jAckupIcon.jpg");

    classInstance.addWindowListener(
      new WindowAdapter()
      {
        public void windowClosing(WindowEvent e)
        {
          logger_.info("Window Closing - Close Logger and exit!");
          //close up the log then vamoose
          LogManager.shutdown();
          System.exit(0);
        }
      }
    );

    classInstance.initGui();
    classInstance.pack();
    classInstance.toFront();
    frame.finishSplash();
    classInstance.setVisible(true);


    logger_.info("Exiting jAckup:main(String[])");
  }


  private class newActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public newActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {
      // Logger Trace Method Enter
      final String innerClassMethodName =
        "newActionListener.actionPerformed - " + NEW_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */
      finalLogger.debug("New MenuItem Selected");
      // read in the default jAckup Plan Document
      try
      {
        SAXReader reader = new SAXReader(validatingXsd_);
        // specify the schema to use
        reader.setProperty(
         "http://apache.org/xml/properties/schema/external-"+
         "noNamespaceSchemaLocation",
         "http://warp2/xml/jAckupPlan.xsd"
        );

        // add an error handler which turns any errors into XML
        XMLErrorHandler errorHandler = new XMLErrorHandler();
        reader.setErrorHandler( errorHandler );

        StringBuffer defaultFilename = new StringBuffer().append(
          System.getProperty("user.home"));
        defaultFilename.append(File.separator);
        defaultFilename.append(JACKUPPLAN_DEFAULT_FILENAME);
        //jAckupPlanDoc_ = jAckupPlan.getDefaultDocument();

        // Parse the document
        finalLogger.info("Reading the default jAckup Plan: " +
          defaultFilename.toString());
        jAckupPlanDoc_ = reader.read(defaultFilename.toString());
        StringBuffer sb = new StringBuffer ();
        if (errorHandler.getErrors() != null &&
            errorHandler.getErrors().hasContent())
        {
          finalLogger.info("Default Plan Read In & Validated!");
          sb.append("Success Reading the XML File: ");
          sb.append(defaultFilename.toString());
          sb.append(SYSTEM_LINE_SEPERATOR);
          sb.append(jAckupPlanDoc_.getRootElement().getName());
          sb.append(SYSTEM_LINE_SEPERATOR);
          sb.append(jAckupPlanDoc_.getRootElement().getNamespace());
          sb.append("<BR>");
          Iterator i = jAckupPlanDoc_.getRootElement().elementIterator();
          Element nextElement = null;
          Element nextE = null;
          Iterator i2 = null;
          while (i.hasNext())
          {
            nextElement = (Element)i.next();
            sb.append(nextElement.getName());
            sb.append(" ");
            //sb.append(nextElement.attributeValue("rootPath"));
            sb.append("<BR>");
            i2 = nextElement.elementIterator();
            while (i2.hasNext())
            {
              nextE = ((Element)i2.next());
              sb.append("   ...");
              sb.append(nextE.getName());
              sb.append(" = ");
              sb.append(nextE.attributeValue("name"));
              sb.append("<BR>");
            }
            sb.append("<BR>");
          }
        }
        else
          sb.append("Crppaed Out Reading the XML File: ");

        finalLogger.debug(sb.toString());
        myDebugLabel_.setText(sb.toString());
      }
      catch (DocumentException docEx)
      {
        finalLogger.warn("Problem reading DEFAULT jAckup Plan File.",
          docEx);
        JOptionPane.showMessageDialog(menuItem,
            "The Default settings file cannot be parsed and validated \n" +
            "to create a New jAckup Plan: ",
            "jAckupPlanDefault.xml\n"+docEx.getMessage() ,
            JOptionPane.ERROR_MESSAGE);
      }
      catch (Exception ex)
      {
        finalLogger.warn("Problem reading DEFAULT jAckup Plan File.",
                         ex);
        JOptionPane.showMessageDialog(menuItem,
            "Something crapped Out:\n" + ex.getMessage(),
            "jAckupPlanDefault.xml",
            JOptionPane.ERROR_MESSAGE);
      }
      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  private class openActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public openActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

      // Logger Trace Method Enter
      final String innerClassMethodName =
        "openActionListener.actionPerformed - " + OPEN_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */
      String chosenFileName = Util.chooseAFilename(menuItem,
                                                   Util.USERHOME);
      if (chosenFileName != null && !chosenFileName.equals(""))
      {
        try
        {
          SAXReader reader = new SAXReader(validatingXsd_);
          jAckupPlanDoc_ = reader.read(chosenFileName);
          StringBuffer sb = new StringBuffer (
            "Success Reading the XML File: ");
          sb.append(chosenFileName);
          sb.append(SYSTEM_LINE_SEPERATOR);
          sb.append(jAckupPlanDoc_.getRootElement().getName());
          sb.append(SYSTEM_LINE_SEPERATOR);
          sb.append(jAckupPlanDoc_.getRootElement().getNamespace());
          finalLogger.debug(sb.toString());
          myDebugLabel_.setText(sb.toString());
        }
        catch (DocumentException docEx)
        {
          finalLogger.warn("Problem reading/validating jAckup Plan File:"+
            chosenFileName, docEx);
          JOptionPane.showMessageDialog(menuItem,
              "The jAckup file selected cannot be read or validated.",
              chosenFileName,
              JOptionPane.ERROR_MESSAGE);
        }
        catch (Exception ex)
        {
          finalLogger.warn("Problem reading jAckup Plan File:"+
            chosenFileName, ex);
          JOptionPane.showMessageDialog(menuItem,
              "Something crapped Out:\n" + ex.getMessage(),
              chosenFileName,
              JOptionPane.ERROR_MESSAGE);
        }
      }
      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  private class saveActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public saveActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

      // Logger Trace Method Enter
      final String innerClassMethodName =
        "saveActionListener.actionPerformed - " + SAVE_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */


      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }

  private class printActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public printActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

      // Logger Trace Method Enter
      final String innerClassMethodName =
        "printActionListener.actionPerformed - " + PRINT_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */


      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }

  private class printpreviewActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public printpreviewActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

      // Logger Trace Method Enter
      final String innerClassMethodName =
        "printpreviewActionListener.actionPerformed - " + PRINTPREVIEW_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */


      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  private class closeActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public closeActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

      // Logger Trace Method Enter
      final String innerClassMethodName =
        "closeActionListener.actionPerformed - " + CLOSE_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */

      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  private class exitActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public exitActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

      // Logger Trace Method Enter
      final String innerClassMethodName =
        "printpreviewActionListener.actionPerformed - " + EXIT_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */
      LogManager.shutdown();
      System.exit(0);
    }
  }


  private class debuglevelActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public debuglevelActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

      // Logger Trace Method Enter
      final String innerClassMethodName =
        "debuglevelActionListener.actionPerformed - " + DEBUGLEVEL_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */

      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  private class jlfActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public jlfActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

      // Logger Trace Method Enter
      final String innerClassMethodName =
        "jlfActionListener.actionPerformed - " + JLF_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */
      Util.setTheLookAndFeel(Util.METAL_LOOKANDFEEL, menuItem);

      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  private class plfActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public plfActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

      // Logger Trace Method Enter
      final String innerClassMethodName = this.getClass().getName() + "." +
        "actionPerformed - " + PLF_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */
      Util.setTheLookAndFeel(Util.WINDOZE_LOOKANDFEEL, menuItem);

      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  private class mlfActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public mlfActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

      // Logger Trace Method Enter
      final String innerClassMethodName = this.getClass().getName() + "." +
        "actionPerformed - " + MLF_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */
      Util.setTheLookAndFeel(Util.MOTIF_LOOKANDFEEL, menuItem);

      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  private class helpActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public helpActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

      // Logger Trace Method Enter
      final String innerClassMethodName = this.getClass().getName() + "." +
        "actionPerformed - " + HELP_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */

      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  private class aboutActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = jAckup.logger_;
    Component menuItem = null;

    public aboutActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new jAckup file with default settings.
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

      // Logger Trace Method Enter
      final String innerClassMethodName = this.getClass().getName() + "." +
        "actionPerformed - " + ABOUT_MENUREF;
      finalLogger.debug("Entering " + innerClassMethodName);

      repaintMenuBar();
      /*
       *  now add the specific stuff for this Menu Item
       */
      JAboutBox box = new JAboutBox("jAckup Backup Utility", "");
      box.show();
      box.toFront();

      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


}

class AutoMenuBar extends JMenuBar
{
  /**  A Class holder for its name (used in Logging).  */
  private static String className_ = "AutoMenuBar";

  /**  Constant holding the users file seperator. ("/" or "\")  */
  private final static String SYSTEM_FILE_SEPERATOR = File.separator;

  /**  String Tokens used to automatically create the menu bar.  */
  private String menuName[] = {"File", "Settings", "Options", "Help"};

  /**
   *  String Tokens used to automatically create the menu items for each menu on
   *  the menubar. It is a 2D array of strings that will be used to create
   *  menuitems. If there are 4 menus... there will be 4 lists holding the
   *  words/Strings to use for the menu items.
   */
  private String menuItemName[][] = {
      {"New", "Open", "Save", "---", "Print...", "Print Preview", "---",
      "Close", "Exit"},
      {"File Selections", "Archive Format"},
      {"Set Debug Output Level...", "---",
      "Java L&F", "Platform L&F", "Motif L&F"},
      {"Help", "---", "About jAckup..."}};

  /**  An Enumeration index for the menu items. */
  private final static int MENUREF[][] =
    {
      {100, 101, 102, 103, 104, 105, 106, 107, 108},
      {200, 201},
      {300, 301, 302, 303, 304},
      {400, 401, 402}
    };

  /**
   *  The Tokens used to automatically assign the Mnemonic for each menu items.
   *  It is a 2D array of chars that will be used to assign the Mnemonic. If
   *  there are 4 menus... there will be 4 lists holding the chars to use as the
   *  Mnemonic for the menu items.
   */
  private char menuItemMnemonic[][] = {
      {'N', 'o', 's', ' ', 'P', 'r', ' ', 'C', 'x'},
      {'F', 'A'},
      {'D', ' ', 'J', 'P', 'M'},
      {'H', ' ', 'b'}};

  /**
   *  The Tokens used when automatically assigning the accel key for each menu
   *  items. It is a 2D array of ints that will be used to assign the accel key
   *  constant. If there are 4 menus... there will be 4 lists holding the ints
   *  to use as the accel key constant value for the menu items.
   */
  private int menuItemAccel[][] = {
      {KeyEvent.VK_N, KeyEvent.VK_O, KeyEvent.VK_S, 0,
      KeyEvent.VK_A, KeyEvent.VK_B, 0,
      KeyEvent.VK_W, KeyEvent.VK_Q},
      {0, 0},
      {0, 0, 0, 0, 0},
      {KeyEvent.VK_F1, 0, KeyEvent.VK_F12}};

  /**
   *  The Tokens used when automatically assigning the 2nd level of accel key
   *  for each menu items. It is a 2D array of ints that will be used to assign
   *  the accel key constant. If there are 4 menus... there will be 4 lists
   *  holding the ints to use as the accel key constant value for the menu
   *  items.
   */
  private int menuItemAccel2[][] = {
      {Event.CTRL_MASK, Event.CTRL_MASK, Event.CTRL_MASK, 0, Event.CTRL_MASK |
      Event.SHIFT_MASK, Event.CTRL_MASK |
      Event.SHIFT_MASK, 0, Event.CTRL_MASK, Event.CTRL_MASK},
      {0, 0},
      {0, 0, 0, 0, 0},
      {0, 0, 0}};

  /**
   *  String Tokens used to automatically create the menu items tooltip for each
   *  menu on the menubar. It is a 2D array of strings that will be used to
   *  create menuitems tooltips. If there are 4 menus... there will be 4 lists
   *  holding the words/Strings to use for the menu items tooltip.
   */
  private String menuToolTip[][] =
      {{"New jAckup Plan", "Open jAckup Plan from File...",
      "Save Current jAckup Plan",
      "---", "Print Current jAckup Plan", "Print Preview", "---",
      "Close Current jAckup Plan", "Exit Application"},
      {"View File Selections", "View Archive Format Settings"},
      {"Set Debug Output Level...", "---",
      "Set the User Interface to the Java-Metal L&F",
      "Set the User Interface to the Platform L&F",
      "Set the User Interface to the Motif L&F"},
      {"Help On using jAckup", "---", "About jAckup..."}};

  /**
   *  boolean Tokens used to enable automatic creation of the menu items for
   *  each menu on the menubar. It is a 2D array of booleans each one a flag
   *  directly refering to the menu item arrays already setup. If there are 4
   *  menus... there will be 4 lists holding the flags to use. If a value of
   *  false is specified the menu item will NOT get created.
   */
  private boolean menuItemShown[][] = {
      {true, true, true, true, true, true, true, true, true},
      {true, true},
      {true, true, true, true, true},
      {true, true, true}};

  /**
   *  boolean Tokens used to enable the menu items for each menu on the menubar.
   *  It is a 2D array of booleans each one a flag directly refering to the menu
   *  item arrays already setup. If there are 4 menus... there will be 4 lists
   *  holding the flags to use. If a value of false is specified the menu item
   *  will be grayed.
   */
  private boolean menuItemEnabled[][] = {
      {true, true, true, true, false, false, true, true, true},
      {true, true},
      {true, true, true, true, true},
      {false, true, true}};

  /**
   *  Suffix applied to the key used in resource file lookups for an image.
   */
  private final static String IMAGESUFFIX = "Image.gif";

  /**
   *  Prefix applied to the key used in resource file lookups for an image.
   */
  private final static String IMAGEPREFIX = "/images";

  /**
   *  The Parent Owner of this Auto Menu Bar.
   **/
   private AutoMenuBarUser parent;



  public AutoMenuBar(AutoMenuBarUser passedUser)
  {
    super();
    parent = passedUser;
    this.initMenuBar();
  }


  /**
   *  Populates the menuitms into it. It uses a set of
   *  predefined String arrays that it loops through to create the menus. This
   *  way the menus can be easily changed by simply adding or removing entrys in
   *  the arrays. You can set the name, Accelerator, Mnemonic, Tooltip,
   *  enabled/disabled (clickable/gray), and even if the item gets created at
   *  all! <P>
   *
   *  The fields it uses are:
   *  <UL>
   *    <LI> menuItemShown
   *    <LI> menuName
   *    <LI> menuItemName
   *    <LI> menuItemAccel
   *    <LI> menuItemAccel2
   *  </UL>
   *
   *
   * @return    JMenuBar
   * @see       jAckup#createMenuItem(int,int)
   */
  private void initMenuBar()
  {
    final String methodName = className_ + ": initMenuBar()";

    int i;
    int j;
    JMenu tempMenu;

    for (i = 0; i < menuName.length; i++)
    {
      tempMenu = new JMenu(menuName[i]);
      for (j = 0; j < menuItemName[i].length; j++)
      {
        if (menuItemShown[i][j])
        {
          if (menuItemName[i][j].equals("---"))
          {
            tempMenu.addSeparator();
          }
          else
          /*
           *  Use the HELPER function called *createMenuItem* to actually do
           *  the menuItem Object creation
           */
              if (menuItemAccel[i][j] != 0)
          {
            tempMenu.add(createMenuItem(i, j)).setAccelerator(
                KeyStroke.getKeyStroke(menuItemAccel[i][j],
                menuItemAccel2[i][j]));
          }
          else
          {
            tempMenu.add(createMenuItem(i, j));
          }
        }
      }
      this.add(tempMenu);
    }
  }


  /**
   *  Aa simple indexOf helper function to look through the menu items and
   *  return an int to represent its HASH position
   *
   * @param  s  Description of Parameter
   * @return    int A value that is the HASH in the menuItem array for the
   *      menuItem passed in as a param
   */
  protected int indexOf(String s)
  {
    final String methodName = className_ + ": indexOf(String " + s + ")";
    //

    int i = 0;
    int j = 0;
    int retVal = 0;
    if (s != null)
    {
      try
      {
        for (j = 0; j < menuName.length; j++)
        {
          for (i = 0; i < menuToolTip[j].length; i++)
          {
            if (s.equals(menuToolTip[j][i]))
            {
              retVal = MENUREF[j][i];
              i = menuToolTip[j].length - 1;
              j = menuName.length - 1;
            }
          }
        }
      }
      catch (java.lang.ArrayIndexOutOfBoundsException t)
      {
         /* don't do anything just return the retVal =0;*/
         retVal =0;
      }
    }
    return retVal;
  }


   /**
   *  This is the hook through which all menu items are created. The fields it
   *  uses are:
   *  <UL>
   *    <LI> menuItemMnemonic
   *    <LI> menuToolTip
   *    <LI> menuItemEnabled
   *  </UL>
   *
   *
   * @param  menuRef      Description of Parameter
   * @param  menuItemRef  Description of Parameter
   * @return              Description of the Returned Value
   * @see                 jAckup#initMenuBar()
   */
  private JMenuItem createMenuItem(int menuRef, int menuItemRef)
  {
    final String methodName = className_ + ": createMenuItem(int, int)";

    String cmd = menuItemName[menuRef][menuItemRef];
    JMenuItem mi = new JMenuItem(menuItemName[menuRef][menuItemRef]);
    mi.setMnemonic(menuItemMnemonic[menuRef][menuItemRef]);
    StringBuffer imgFile = new StringBuffer(IMAGEPREFIX);
    imgFile.append(SYSTEM_FILE_SEPERATOR);
    imgFile.append(menuItemName[menuRef][menuItemRef]);
    imgFile.append(IMAGESUFFIX);
    Image menuItmImg = Util.loadImage(imgFile.toString());
    mi.setHorizontalTextPosition(JButton.RIGHT);

    if (menuItmImg != null)
    {
      mi.setIcon(new ImageIcon(menuItmImg));
    }

    mi.setToolTipText(menuToolTip[menuRef][menuItemRef]);
    mi.setEnabled(menuItemEnabled[menuRef][menuItemRef]);

    return mi;
  }

  /**
   * loops through the menuitems adding all the listeners by calling the parent
   * addListener menthod.
   **/
  public void addListeners()
  {

    // loop through menuitems adding the listeners.
    int i;
    int j;
    JMenu tempMenu;

    for (i = 0; i < menuName.length; i++)
    {
      tempMenu = this.getMenu(i);
      for (j = 0; j < menuItemName[i].length; j++)
      {
        /*
         *  call the one size fits all method to add the appropriate
         *  listener to this menu item
         */
        if (!menuItemName[i][j].equals("---"))
          parent.addListener(tempMenu.getItem(j));
      }
    }
  }


}

interface AutoMenuBarUser
{
  /**
   *  Adds an ActionListener to the JMenuItem that is supplied in the passed
   *  param.
   *
   * @param  menuItem  The feature to be added to the Listener attribute
   */
  public void addListener(JMenuItem menuItem);
}