/*
 *  PDFCropper.java
 *  $URL: svn://svn.webarts.bc.ca/open/trunk/projects/WebARTS/ca/bc/webarts/tools/pdf/PDFCropper.java $
 *  $REVISION: $
 *  $Date: 2019-04-18 18:30:08 -0700 (Thu, 18 Apr 2019) $
 *  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.pdf;

import ca.bc.webarts.tools.pdf.CropPDF;
import ca.bc.webarts.tools.pdf.TwoUpPDF;

import ca.bc.webarts.widgets.AutoButtonBar;
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;



/**
 *  PDFCropper X10 controller application Utility.
 *
 * @author     tgutwin
 * @created    August 12, 2002
 */
public class PDFCropper 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 = "PDFCropper";

  /**  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(PDFCropper.class.getName());

  /** the Crop PDF helper object **/
  CropPDF cropper_ = null;

  /** the Crop PDF helper object **/
  TwoUpPDF twoUpper_ = null;

  /**  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),
                      "Crop Controls Go Here.");

  String inputPDF_ = "/home/tgutwin/docs/pdfOutput/JSTLReference.pdf";
  String croppedPDF_ = inputPDF_.substring(0,inputPDF_.length()-4)+"-Crop.pdf";
  JPanel borderCropControlPanel1_ = null;
  JPanel borderCropControlPanel2_ = null;
  JPanel borderCropControlPanel3_ = null;
  JPanel borderCropControlPanel4_ = null;

  /**
   *  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 OPEN_MENUREF = 100;
  /**  Description of the Field */
  private final static int SAVE_MENUREF = 101;
  /**  Description of the Field */
  private final static int PRINT_MENUREF = 103;
  /**  Description of the Field */
  private final static int CLOSE_MENUREF = 105;
  /**  Description of the Field */
  private final static int EXIT_MENUREF = 106;
  /**  Description of the Field */
  private final static int DEBUGLEVEL_MENUREF = 200;
  /**  Description of the Field */
  private final static int JLF_MENUREF = 202;
  /**  Description of the Field */
  private final static int PLF_MENUREF = 203;
  /**  Description of the Field */
  private final static int MLF_MENUREF = 204;
  /**  Description of the Field */
  private final static int HELP_MENUREF = 300;
  /**  Description of the Field */
  private final static int ABOUT_MENUREF = 302;


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

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


  public void setInputPDF_(String inputPDF)
  {
    this.inputPDF_ = inputPDF;
  }



  public String getInputPDF_()
  {
    return inputPDF_;
  }



  /**
   *
   *
   *
   */
  private String get2UpCroppedPDF_()
  {
    final String methodName = className_ + ": initMainArea()";
    logger_.debug("Entering " + methodName);
    return inputPDF_.substring(0,inputPDF_.length()-4)+"-Crop-2Up.pdf";
  }


  /**
   *
   *
   *
   */
  private String getCroppedPDF_()
  {
    final String methodName = className_ + ": initMainArea()";
    logger_.debug("Entering " + methodName);
    return inputPDF_.substring(0,inputPDF_.length()-4)+"-Crop.pdf";
  }


  /**
   *
   *
   *
   */
  private void doCrop()
  {
    final String methodName = className_ + ": initMainArea()";
    logger_.debug("Entering " + 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 init2UpCroppedPDFPanel()
  {
    final String methodName = className_ + ": initMainArea()";
    logger_.debug("Entering " + methodName);

    JPanel retVal = new JPanel(new BorderLayout());
    try
    {
      com.pdfgo.pdf.Document pdfDoc = new com.pdfgo.pdf.Document();
      pdfDoc.setFile(get2UpCroppedPDF_());
      pdfDoc.setToolbarVisible(false);
      pdfDoc.fitPage();
      retVal = pdfDoc.getPeer();
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
    return retVal;
  }


  /**
   *  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 initCroppedPDFPanel()
  {
    final String methodName = className_ + ": initMainArea()";
    logger_.debug("Entering " + methodName);

    JPanel retVal = new JPanel(new BorderLayout());
    try
    {
      com.pdfgo.pdf.Document pdfDoc = new com.pdfgo.pdf.Document();
      pdfDoc.setFile(getCroppedPDF_());
      pdfDoc.setToolbarVisible(false);
      pdfDoc.fitPage();
      retVal = pdfDoc.getPeer();
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
    return retVal;
  }


  /**
   *  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 initOriginalPDFPanel()
  {
    final String methodName = className_ + ": initMainArea()";
    logger_.debug("Entering " + methodName);

    JPanel retVal = new JPanel(new BorderLayout());
    try
    {
      com.pdfgo.pdf.Document pdfDoc = new com.pdfgo.pdf.Document();
      pdfDoc.setFile(inputPDF_);
      pdfDoc.setToolbarVisible(false);
      pdfDoc.fitPage();
      retVal = pdfDoc.getPeer();
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
    return retVal;
  }

    /**
   *  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());

    // build the Panel 1 Control Bar
    borderCropControlPanel1_  = new JPanel(new BorderLayout());
    String [] p1ButtonNames = {"moveLeft", "moveRight", "moveUp", "moveDown", "delete", "add"};
    String [] p1ButtonTips  = {"Move the selected bookmark Left",
                               "Move the selected bookmark Right",
                               "Move the selected bookmark Up",
                               "Move the selected bookmark Down",
                               "Delete the selected bookmark",
                               "Add A New bookmark"};
    URL codeBase = null;
    try
    {
      codeBase = new URL("FILE:/./");
    }
    catch (java.net.MalformedURLException t)
    {
      logger_.debug("caught exception: " + t );
    }
    AutoButtonBar p1ButtonBar =
        new AutoButtonBar(codeBase, p1ButtonNames, p1ButtonTips, this);
    borderCropControlPanel1_.add(p1ButtonBar,"Center");

    borderCropControlPanel2_  = new JPanel(new BorderLayout());
    borderCropControlPanel2_.add(new ColouredLabel(new Color(5,5,100),
                                          Color.white,
                                          new Font("SanSerif", Font.PLAIN, 11),
                                          "Panel 2 Controls Go Here."),"Center");
    borderCropControlPanel3_  = new JPanel(new BorderLayout());
    borderCropControlPanel3_.add(new ColouredLabel(new Color(5,5,100),
                                          Color.white,
                                          new Font("SanSerif", Font.PLAIN, 11),
                                          "Panel 3 Controls Go Here."),"Center");
    tab1Content.add(borderCropControlPanel1_,"North");
    tab1Content.add(initOriginalPDFPanel(),"Center");
    tab2Content.add(borderCropControlPanel2_,"North");
    tab2Content.add(initCroppedPDFPanel(),"Center");
    tab3Content.add(borderCropControlPanel3_,"North");
    tab3Content.add(init2UpCroppedPDFPanel(),"Center");
    tabbedPane.add("Original PDF", tab1Content);
    tabbedPane.add("Cropped PDF", tab2Content);
    tabbedPane.add("Two Up Cropped PDF", 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 OPEN_MENUREF:
          /*
           *  Save Window Data To File
           */
          menuItem.addActionListener(new saveActionListener(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 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[] args)
  {
    // log4j logger config
    PropertyConfigurator.configure(System.getProperty("user.home")+
                                   "/logs/log4jConfig.txt");
    logger_.debug("Entering PDFCropper: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, 5000, p);

    logger_.debug("Instantiating the PDFCropper Object.");
    final PDFCropper classInstance = new PDFCropper();
    //Util.setIconForApp(classInstance, "/images/PDFCropperIcon.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);
        }
      }
    );

    if (args.length > 0)
      classInstance.setInputPDF_(args[0]);
    classInstance.cropper_ = new CropPDF();
    classInstance.cropper_.setInFileName(classInstance.getInputPDF_());
    classInstance.cropper_.setOutFileName();
    classInstance.cropper_.doCrop();
    String [] cropAmounts = {classInstance.cropper_.getOutFileName()};
    TwoUpPDF.main(cropAmounts);
    classInstance.initGui();
    classInstance.pack();
    classInstance.toFront();
    frame.finishSplash();
    classInstance.setVisible(true);

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


  /**
   * Handles all the Actions originating from the Control Buttons.
   *
   * @param e  Description of Parameter
   */
  public void actionPerformed(ActionEvent e)
  {
    // Logger Trace Method Enter
    final String methodName = className_ + ": actionPerformed()";
    logger_.debug("Entering " + methodName);

    ImageIcon buttonIcon = (ImageIcon) ((JButton) (e.getSource())).getIcon();
    String command = "";
    if (buttonIcon != null)
    {
      command = buttonIcon.getDescription();
    }
    try
    {
      /* Open Button Was Pressed */
      /* *********************** */
      if (command.trim().equals("moveLeft"))
      {
        logger_.info(command.trim()+" Button Pressed");
      }
      /* Save Button Was Pressed */
      /* *********************** */
      else if (command.trim().equals("moveRight"))
      {
        logger_.info(command.trim()+" Button Pressed");
      }
    }
    catch (Exception ex)
    {
      logger_.debug("Action Listener Exception", ex);
    }
    logger_.debug("Exiting " + methodName);
  }


  private class openActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = PDFCropper.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
       */
      finalLogger.debug("Open MenuItem Selected");

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


  private class saveActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = PDFCropper.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 = PDFCropper.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 closeActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = PDFCropper.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 = PDFCropper.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 = PDFCropper.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 = PDFCropper.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 = PDFCropper.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 = PDFCropper.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 = PDFCropper.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 = PDFCropper.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("PDFCropper Acrobat Editor 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", "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[][] = {
      {"Open", "Save", "---", "Print...", "---", "Close", "Exit"},
      {"Set Debug Output Level...", "---",
      "Java L&F", "Platform L&F", "Motif L&F"},
      {"Help", "---", "About PDFCropper..."}};

  /**  An Enumeration index for the menu items. */
  private final static int MENUREF[][] =
    {
      {100, 101, 102, 103, 104, 105, 106, 107},
      {200, 201, 202, 203, 204},
      {300, 301, 302}
    };

  /**
   *  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[][] = {
      {'o', 's', ' ', 'P', ' ', 'C', 'x'},
      {'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_O, KeyEvent.VK_S, 0,
      KeyEvent.VK_A, 0,
      KeyEvent.VK_W, KeyEvent.VK_Q},
      {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, 0, Event.CTRL_MASK | Event.SHIFT_MASK,
      0, Event.CTRL_MASK, Event.CTRL_MASK},
      {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[][] =
      {{"Open PDF from File...",
      "Save Current PDFCropper Plan",
      "---", "Print Current PDFCropper Plan", "---",
      "Close Current PDF", "Exit Application"},
      {"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 PDFCropper", "---", "About PDFCropper..."}};

  /**
   *  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}};

  /**
   *  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, false, 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);
}