/*
 *  PDFEditor.java
 *  $URL: svn://svn.webarts.bc.ca/open/trunk/projects/WebARTS/ca/bc/webarts/tools/pdf/PDFEditor.java $
 *  $Revision: 1297 $
 *  $Date: 2019-04-18 18:25:12 -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.FlowLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
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.net.MalformedURLException;

import java.util.Iterator;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
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.JComboBox;
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 com.pdfgo.pdf.Document;
import com.pdfgo.pdf.PDFException;


/**
 * PDFEditor is a utility application to help you massage existing PDF files
 * into a cropped form that lets you see more per page. Its basic capabilities
 * are: <ul><li>to load and view a PDF,</li><li>selectivly crop the edges or
 * margin from a document,</li><li>automatically take the cropped PDF and format
 * it into a 2Up view of the document</li><li>enlarges the cropped pages to fill
 * the newly created 2Up page (eliminating all that empty whitespace on a normal
 * 2Up page)</li><li>allows for alternating odd/even page margins when an
 * original document has a binding offset</li><li>allows for the inclusion of an
 * alternating even/odd page binding offset on the resultant 2Up page so you can
 * print the pages double sided</li><li>add bookmarks (to be done)</li>
 * <li>rearrange bookmarks (to be done).</li></ul>
 * <p><b>It does it all in Java (no native code calls) and its FREE!</b></p>
 * <br>All PDF document handling is done using the freely available iText PDF
 * Java library -
 * <a href="http://www.lowagie.com/iText/">http://www.lowagie.com/iText/</a>
 * <br>The viewing of the PDF docs requires the PDFGo library -
 * <a href="http://www.pdfgo.com">http://www.pdfgo.com</a> the
 * <a href="http://www.pdfgo.com/downloads.html">free demo version</a>
 * is enough for this application to work, since the actual processing of the
 * pdfs is handled by Lowagie iText.
 * <hr><br>License: GNU GPL<pre>
 * 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; version 2 of the License.
 *
 * 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.</pre>
 *
 * @author     tgutwin
 * @created    August 12, 2002
 */
public class PDFEditor extends JFrame implements AutoMenuBarUser, ActionListener
{
  /**  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 = "PDFEditor";

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

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

  /** The Crop PDF helper object that abstracts and performs the cropping. **/
  protected CropPDF cropper_ = null;

  /**
   * The 2Up Crop PDF helper object that abstracts and performs the creation
   * of the 2Up doc.
   **/
  protected 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.");

  /** The class holder for the URL of the current PDF being manipulated. **/
  URL inputPDFURL_ = null;

  /**
   * The class holder for the filename of the current PDF being manipulated.
   **/
  String inputPDF_ = "";

  /**
   * A control panel/holder for the control buttons at the top of the original
   * PDF view screen.
   **/
  JPanel borderCropControlPanel1_ = null;

  /**
   * A control panel/holder for the control buttons at the top of the Cropped
   * PDF view screen.
   **/
  JPanel borderCropControlPanel2_ = null;

  /**
   * A control panel/holder for the control buttons at the top of the Cropped2Up
   * PDF view screen.
   **/
  JPanel borderCropControlPanel3_ = null;

  /**
   * A control panel/holder for the control buttons at the top of the 4th tab
   * pane. (Currently unused)
   **/
  JPanel borderCropControlPanel4_ = null;

  /**
    * A Checkbox to select if the page cropping will alternate left/right
    * margins given that the original doc had even/odd page margins for a
    * binding offset.
    **/
  JCheckBox facingPageMargins_ = null;

  /**
    * A Checkbox to select if the Two Up page will have alternating even/odd top
    * page margin to allow for a twosided binding offset on the long side
    * of the page.
    **/
  JCheckBox bindingPageMargins_ = null;

  /**
   * The class holder for the amount to crop of the <b>left</b> edge of the original
   * PDF documen when creating the Cropped PDF. Please use the get and set
   * methods to access this instance var.
   **/
  private float leftCrop_ = 0.25f;

  /**
   * The class holder for the amount to crop of the <b>right</b> edge of the original
   * PDF documen when creating the Cropped PDF. Please use the get and set
   * methods to access this instance var.
   **/
  private float rightCrop_ = 0.25f;

  /**
   * The class holder for the amount to crop of the <b>top</b> edge of the original
   * PDF documen when creating the Cropped PDF. Please use the get and set
   * methods to access this instance var.
   **/
  private float topCrop_ = 0.25f;

  /**
   * The class holder for the amount to crop of the <b>bottom</b> edge of the original
   * PDF documen when creating the Cropped PDF. Please use the get and set
   * methods to access this instance var.
   **/
  private float bottomCrop_ = 0.25f;

  /**
   * The instance object that represents the original PDF document.
   **/
  Document originalPDFDoc_ = new Document();

  /**
   * The instance object that represents the original Cropped PDF document.
   **/
  Document croppedPDFDoc_ = new Document();

  /**
   * The instance object that represents the original Cropped 2Up PDF document.
   **/
  Document cropped2UpPDFDoc_ = new Document();

  /**
   * The iText PDF Document object.
   **/
   com.itextpdf.text.Document iTextDoc = null;

  /**
   *  The MenuBar. All creating and setup is handled by the the AutoMenuBar
   *  class.
   *
   * @see    AutoMenuBar
   */
  private AutoMenuBar menuBar_ = null;

  /**  A class constant representing an ID value for the Open Menuitem. **/

  final static int OPEN_MENUREF = 100;

  /**  A class constant representing an ID value for the Save Menuitem. **/
  final static int SAVE_MENUREF = 101;

  /**  A class constant representing an ID value for the Print Menuitem. **/
  final static int PRINT_MENUREF = 103;

  /**  A class constant representing an ID value for the Close Menuitem. **/
  final static int CLOSE_MENUREF = 105;

  /**  A class constant representing an ID value for the Exit Menuitem. **/
  final static int EXIT_MENUREF = 106;

  /**  A class constant representing an ID value for the Debug Level Menuitem. **/
  final static int DEBUGLEVEL_MENUREF = 200;

  /**  A class constant representing an ID value for the Java Look And Feel Menuitem. **/
  final static int JLF_MENUREF = 202;

  /**  A class constant representing an ID value for the Platform Look And Feel Menuitem. **/
  final static int PLF_MENUREF = 203;

  /**  A class constant representing an ID value for the Motif Look And Feel Menuitem. **/
  final static int MLF_MENUREF = 204;

  /**  A class constant representing an ID value for the Help Menuitem. **/
  final static int HELP_MENUREF = 300;

  /**  A class constant representing an ID value for the About Menuitem. **/
  final static int ABOUT_MENUREF = 302;


  /**  Basic constructor for this Object that only gets the frame title setup..  */
  public PDFEditor()
  {
    final String methodName = className_ + ": Constructor()";
    logger_.debug("Entering " + methodName);
    setTitle("PDFEditor - Java PDF Editing by Tom B. Gutwin, WebARTS Design");
    logger_.debug("Exiting " + methodName);
  }

  /** Setter for the inputPDF_ field.**/
  public void setInputPDF_(String inputPDF)
  {
    this.inputPDF_ = inputPDF;
  }


  /** Getter for the inputPDF_ field.**/
  public String getInputPDF_()
  {
    return inputPDF_;
  }


  /** Setter for the leftCrop_ field.**/
  public void setLeftCrop_(float leftCrop)
  {
    final String methodName = className_ + ": setLeftCrop_("+leftCrop+")";
    logger_.debug("Entering " + methodName);
    this.leftCrop_ = leftCrop;
    logger_.debug("Exiting " + methodName);
  }


  /** Getter for the leftCrop_ field.**/
  public float getLeftCrop_()
  {
    return leftCrop_;
  }


  /** Setter for the rightCrop_ field.**/
  public void setRightCrop_(float rightCrop)
  {
    final String methodName = className_ + ": setRightCrop_("+rightCrop+")";
    logger_.debug("Entering " + methodName);
    this.rightCrop_ = rightCrop;
    logger_.debug("Exiting " + methodName);
  }


  /** Getter for the rightCrop_ field.**/
  public float getRightCrop_()
  {
    return rightCrop_;
  }


  /** Setter for the topCrop_ field.**/
  public void setTopCrop_(float topCrop)
  {
    final String methodName = className_ + ": setTopCrop_("+topCrop+")";
    logger_.debug("Entering " + methodName);
    this.topCrop_ = topCrop;
    logger_.debug("Exiting " + methodName);
  }


  /** Getter for the topCrop_ field.**/
  public float getTopCrop_()
  {
    return topCrop_;
  }


  /** Setter for the bottomCrop_ field.**/
  public void setBottomCrop_(float bottomCrop)
  {
    final String methodName = className_ + ": setBottomCrop_("+bottomCrop+")";
    logger_.debug("Entering " + methodName);
    this.bottomCrop_ = bottomCrop;
    logger_.debug("Exiting " + methodName);
  }


  /** Getter for the bottomCrop_ field.**/
  public float getBottomCrop_()
  {
    return bottomCrop_;
  }


  /**
   *
   * Returns the String representing the filename of the Cropped-2up file that
   * is based on the input PDF filename.
   *
   */
  private String get2UpCroppedPDFName()
  {
    final String methodName = className_ + ": get2UpCroppedPDFName()";
    logger_.debug("Entering " + methodName);
    logger_.debug("Exiting " + methodName);
    return inputPDF_.substring(0,inputPDF_.length()-4)+"-Crop-2Up.pdf";
  }


  /**
   *
   * Returns the String representing the filename of the Cropped file that
   * is based on the input PDF filename.
   */
  private String getCroppedPDFName()
  {
    final String methodName = className_ + ": getCroppedPDFName()";
    logger_.debug("Entering " + methodName);
    logger_.debug("Exiting " + methodName);
    return inputPDF_.substring(0,inputPDF_.length()-4)+"-Crop.pdf";
  }


  /**
   * Perform the actual cropping of the Doc. All
   * processing is done using the WebARTS Library Tool
   * <a href="CropPDF.html">ca.bc.webarts.tools.CropPDF</a> which wraps all
   * the calls to the lowagie iText Library..
   *
   */
  private void doCrop()
  {
    final String methodName = className_ + ": doCrop()";
    logger_.debug("Entering " + methodName);
    boolean faceMargins = (facingPageMargins_!=null?
                           facingPageMargins_.isSelected():
                           false);
    if (faceMargins)
    {
      logger_.debug("   Calling CropPDF ("+
          leftCrop_+", "+rightCrop_+", "+topCrop_+", "+bottomCrop_+", "+
          rightCrop_+", "+leftCrop_+", "+topCrop_+", "+bottomCrop_+")");
      cropper_ = new CropPDF(leftCrop_, rightCrop_, topCrop_, bottomCrop_,
                             rightCrop_, leftCrop_, topCrop_, bottomCrop_,
                             getInputPDF_());
    }
    else
    {
      logger_.debug("   Calling CropPDF ("+leftCrop_+", "+rightCrop_+", "+topCrop_+", "+bottomCrop_+")");
      cropper_ = new CropPDF(leftCrop_, rightCrop_, topCrop_, bottomCrop_,
                             getInputPDF_());
    }
    cropper_.doCrop(faceMargins);

    logger_.debug("Exiting " + methodName);

  }


  /**
   * Perform the actual conversion of the Cropped Doc to the 2Up Doc. All
   * processing is done using the WebARTS Library Tool
   * <a href="TwoUpPDF.html">ca.bc.webarts.tools.TwoUpPDF</a> which wraps all
   * the calls to the lowagie iText Library..
   *
   */
  private void do2Up()
  {
    final String methodName = className_ + ": do2Up()";
    logger_.debug("Entering " + methodName);
    if (bindingPageMargins_.isSelected())
    {
      String [] cropAmounts = {"-doubleBind", "0.0", cropper_.getOutFileName()};
      TwoUpPDF.main(cropAmounts);
    }
    else
    {
      String [] cropAmounts = {cropper_.getOutFileName()};
      TwoUpPDF.main(cropAmounts);
    }

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

    JPanel retVal = new JPanel(new BorderLayout());
    retVal.add(new ColouredLabel(new Color(5,5,100),
                                 Color.white,
                                 new Font("SanSerif", Font.PLAIN, 11),
                                 "Cropped-2Up PDF Placeholder"));
    try
    {
      //originalPDFDoc_ = new Document();
      cropped2UpPDFDoc_.setFile(get2UpCroppedPDFName());
      cropped2UpPDFDoc_.setToolbarVisible(true);
      cropped2UpPDFDoc_.fitPage();
      if (cropped2UpPDFDoc_.getPeer() != null)
        retVal = cropped2UpPDFDoc_.getPeer();
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
    logger_.debug("Exiting " + methodName);
    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_ + ": initCroppedPDFPanel()";
    logger_.debug("Entering " + methodName);

    JPanel retVal = new JPanel(new BorderLayout());
    retVal.add(new ColouredLabel(new Color(5,5,100),
                                 Color.white,
                                 new Font("SanSerif", Font.PLAIN, 11),
                                 "Cropped PDF Placeholder"));
    try
    {
      croppedPDFDoc_.setFile(getCroppedPDFName());
      croppedPDFDoc_.setToolbarVisible(true);
      croppedPDFDoc_.fitPage();
      if (croppedPDFDoc_.getPeer() != null)
        retVal = croppedPDFDoc_.getPeer();
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
    logger_.debug("Exiting " + methodName);
    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 void refreshCroppedView()
  {
    final String methodName = className_ + ": refreshCroppedView()";
    logger_.debug("Entering " + methodName);

    try
    {
      croppedPDFDoc_.setUrl((new File(getCroppedPDFName())).toURL());
      //cropped2UpPDFDoc_.setUrl((new File(get2UpCroppedPDFName())).toURL());
    }
    catch (MalformedURLException badUrlEx)
    {
      logger_.debug("cannot convert "+getCroppedPDFName()+" to a URL.");
    }
    catch (PDFException pdfEx)
    {
      logger_.debug("cannot update PDF to "+getCroppedPDFName());
    }

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

    try
    {
      //croppedPDFDoc_.setUrl((new File(getCroppedPDFName())).toURL());
      cropped2UpPDFDoc_.setUrl((new File(get2UpCroppedPDFName())).toURL());
    }
    catch (MalformedURLException badUrlEx)
    {
      logger_.debug("cannot convert "+get2UpCroppedPDFName()+" to a URL.");
    }
    catch (PDFException pdfEx)
    {
      logger_.debug("cannot update PDF to "+get2UpCroppedPDFName());
    }

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


  /**
   *  Initializes the original PDF Document view panel.
   *
   * @return JPanel the panel to go into the Main center area of jAckup
   */
  private JPanel initOriginalPDFPanel()
  {
    final String methodName = className_ + ": initOriginalPDFPanel()";
    logger_.debug("Entering " + methodName);

    JPanel retVal = new JPanel(new BorderLayout());
    retVal.add(new ColouredLabel(new Color(5,5,100),
                                 Color.white,
                                 new Font("SanSerif", Font.PLAIN, 11),
                                 "PDF Placeholder"));
    try
    {
      iTextDoc = CropPDF.parsePDFFile(inputPDF_);
      originalPDFDoc_.setFile(inputPDF_);
      originalPDFDoc_.setToolbarVisible(true);
      originalPDFDoc_.fitPage();
      if (originalPDFDoc_.getPeer() != null)
        retVal = originalPDFDoc_.getPeer();
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
    logger_.debug("Exiting " + methodName);
    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());
    URL codeBase = null;
    try
    {
      codeBase = new URL("file:///d:/tbg/pkgs/images");
    }
    catch (java.net.MalformedURLException t)
    {
      logger_.debug("caught exception: " + t );
    }

    String[] possibleCropValues = { "0.1", "0.2", "0.25", "0.3", "0.4", "0.5",
                                    "0.6", "0.7", "0.75", "0.8", "0.9", "1.0",
                                    "1.1", "1.2", "1.25", "1.5"};


    // ****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"};
    AutoButtonBar p1ButtonBar =
        new AutoButtonBar(codeBase, p1ButtonNames, p1ButtonTips, this);
    borderCropControlPanel1_.add(p1ButtonBar,"Center");

    // ****build the Panel 2 Control Bar
    borderCropControlPanel2_  = new JPanel(new BorderLayout());
    JPanel p1 = new JPanel(new FlowLayout(FlowLayout.LEFT,3,3));
    JPanel p2 = new JPanel(new FlowLayout(FlowLayout.RIGHT,10,3));
    JPanel p3 = new JPanel(new FlowLayout(FlowLayout.LEFT,10,3));
    Dimension dimens = new Dimension(70,25);
    JComboBox leftCropBox = new JComboBox(possibleCropValues);
    leftCropBox.setEditable(true);
    leftCropBox.setPreferredSize(dimens);
    leftCropBox.addActionListener(new leftCropActionListener(leftCropBox));
    JComboBox rightCropBox = new JComboBox(possibleCropValues);
    rightCropBox.setEditable(true);
    rightCropBox.setPreferredSize(dimens);
    rightCropBox.addActionListener(new rightCropActionListener(rightCropBox));
    JComboBox topCropBox = new JComboBox(possibleCropValues);
    topCropBox.setEditable(true);
    topCropBox.setPreferredSize(dimens);
    topCropBox.addActionListener(new topCropActionListener(topCropBox));
    JComboBox bottomCropBox = new JComboBox(possibleCropValues);
    bottomCropBox.setEditable(true);
    bottomCropBox.setPreferredSize(dimens);
    bottomCropBox.addActionListener(new bottomCropActionListener(bottomCropBox));
    Color backLabelColour = new Color(210,210,210);
    p1.add(new ColouredLabel(backLabelColour,
                                          Color.black,
                                          new Font("SanSerif", Font.PLAIN, 10),
                                          "Left:"));
    p1.add(leftCropBox);
    p1.add(new ColouredLabel(backLabelColour,
                                          Color.black,
                                          new Font("SanSerif", Font.PLAIN, 10),
                                          "   Right:"));
    p1.add(rightCropBox);
    p1.add(new ColouredLabel(backLabelColour,
                                          Color.black,
                                          new Font("SanSerif", Font.PLAIN, 10),
                                          "   Top:"));
    p1.add(topCropBox);
    p1.add(new ColouredLabel(backLabelColour,
                                          Color.black,
                                          new Font("SanSerif", Font.PLAIN, 10),
                                          "   Bottom:"));
    p1.add(bottomCropBox);
    facingPageMargins_ = new JCheckBox("Alternate Facing Page Margins");
    bindingPageMargins_ = new JCheckBox("Offset for Two Sided \nPrint Binding");
    p3.add(facingPageMargins_);
    p3.add(bindingPageMargins_);

    JButton doCropButton = new JButton("Do Crop");
    doCropButton.addActionListener(this);
    p2.add(doCropButton);
    borderCropControlPanel2_.add(p1,"West");
    borderCropControlPanel2_.add(p2,"Center");
    borderCropControlPanel2_.add(p3,"South");

    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();
    }
    logger_.debug("Exiting " + methodName);
  }


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

  }


  /**
   *  Does the initial loading of the document and then gets the cropped
   *  versions done and ready for initial display and editing.
   *
   * @return    success or not.
   */
  private boolean doInitialLoadAndCrop()
  {
    boolean retVal = true;
    final String methodName = className_ + ": doInitialLoadAndCrop()";
    logger_.debug("Entering " + methodName);

    try
    {
      doCrop();
      logger_.debug("   Calling TwoUpPDF");
      String [] cropAmounts = {cropper_.getOutFileName()};
      TwoUpPDF.main(cropAmounts);

    }
    catch ( Exception ex)
    {
      logger_.debug("Error Preparing inital files");
      logger_.debug(ex);
      retVal = false;
    }

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


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

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


  /**
   *  The main entrypoint for this class. 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 PDFEditor: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, 10000, p);

    logger_.debug("Instantiating the PDFEditor Object.");
    final PDFEditor classInstance = new PDFEditor();
    //Util.setIconForApp(classInstance, "/images/PDFEditorIcon.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.doInitialLoadAndCrop();
    classInstance.initGui();
    classInstance.pack();
    classInstance.toFront();
    frame.finishSplash();
    classInstance.setVisible(true);

    logger_.info("Exiting PDFEditor: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);

    JButton actionButtion = ((JButton) (e.getSource()));
    ImageIcon buttonIcon = (ImageIcon) actionButtion.getIcon();
    String command = "";
    if (actionButtion != null)
    {
      command = actionButtion.getText();
    }
    try
    {
      /* Move Bookmark Left Button Was Pressed */
      /* *********************** */
      if (command.trim().equals("moveLeft"))
      {
        logger_.info(command.trim()+" Button Pressed");
      }
      /* Move Bookmark Right Button Was Pressed */
      /* *********************** */
      else if (command.trim().equals("moveRight"))
      {
        logger_.info(command.trim()+" Button Pressed");
      }

      /* Do Crop Button Was Pressed */
      /* *********************** */
      else if (command.trim().equals("Do Crop"))
      {
        logger_.info(command.trim()+" Button Pressed");
        doCrop();
        do2Up();

        refreshCroppedView();
        refresh2UpView();
      }
    }
    catch (Exception ex)
    {
      logger_.debug("Action Listener Exception", ex);
    }
    logger_.debug("Exiting " + methodName);
  }


  /** Listener for the leftCrop drop Down JComboBox. **/
  private class leftCropActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = PDFEditor.logger_;
    JComboBox leftBox = null;

    public leftCropActionListener(Component mi)
    {
      super();
      leftBox = (JComboBox)mi;
    }
    /**
     *  .
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

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

      /*
       *  now add the specific stuff for this Menu Item
       */
      setLeftCrop_(Float.parseFloat((String)leftBox.getSelectedItem()));
      finalLogger.debug("   leftCrop = " + getLeftCrop_());
      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  /** Listener for the leftCrop drop Down JComboBox. **/
  private class rightCropActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = PDFEditor.logger_;
    JComboBox rightBox = null;

    public rightCropActionListener(Component mi)
    {
      super();
      rightBox = (JComboBox)mi;
    }
    /**
     *  .
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

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

      /*
       *  now add the specific stuff for this Menu Item
       */
      setRightCrop_(Float.parseFloat((String)rightBox.getSelectedItem()));
      finalLogger.debug("   rightCrop = " + getRightCrop_());
      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  /** Listener for the leftCrop drop Down JComboBox. **/
  private class topCropActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = PDFEditor.logger_;
    JComboBox box = null;

    public topCropActionListener(Component mi)
    {
      super();
      box = (JComboBox)mi;
    }
    /**
     *  .
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

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

      /*
       *  now add the specific stuff for this Menu Item
       */
      setTopCrop_(Float.parseFloat((String)box.getSelectedItem()));
      finalLogger.debug("   topCrop = " + getTopCrop_());
      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  /** Listener for the bottomCrop drop Down JComboBox. **/
  private class bottomCropActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = PDFEditor.logger_;
    JComboBox box = null;

    public bottomCropActionListener(Component mi)
    {
      super();
      box = (JComboBox)mi;
    }
    /**
     *  .
     *
     * @param  event  The Initiating event
     */
    public void actionPerformed(ActionEvent event)
    {

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

      /*
       *  now add the specific stuff for this Menu Item
       */
      setBottomCrop_(Float.parseFloat((String)box.getSelectedItem()));
      finalLogger.debug("   bottomCrop = " + getBottomCrop_());
      // logger method exit
      finalLogger.debug("Exiting " + innerClassMethodName);
    }
  }


  private class openActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = PDFEditor.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");
      String fileNameToOpen =
          Util.chooseAFilename(((Component) (event.getSource())),
                               System.getProperty("user.dir"),
                               null,
                               false);
      if (fileNameToOpen != null && !fileNameToOpen.equals(""))
      {
        setInputPDF_(fileNameToOpen);
        doInitialLoadAndCrop();
        try
        {
          iTextDoc = CropPDF.parsePDFFile(fileNameToOpen);
          originalPDFDoc_.setUrl((new File(fileNameToOpen)).toURL());
          croppedPDFDoc_.setUrl((new File(getCroppedPDFName())).toURL());
          cropped2UpPDFDoc_.setUrl((new File(get2UpCroppedPDFName())).toURL());
        }
        catch (MalformedURLException badUrlEx)
        {
          finalLogger.debug("cannot convert "+fileNameToOpen+" to a URL.");
        }
        catch (PDFException pdfEx)
        {
          finalLogger.debug("cannot update PDF to "+fileNameToOpen);
        }
      }

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


  private class saveActionListener implements ActionListener
  {
    /**  The log4j logger final object. */
    final Logger finalLogger = PDFEditor.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 = PDFEditor.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 = PDFEditor.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 = PDFEditor.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 = PDFEditor.logger_;
    Component menuItem = null;

    public debuglevelActionListener(Component mi)
    {
      super();
      menuItem = mi;
    }
    /**
     *  Creates a new 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 = PDFEditor.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 = PDFEditor.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 = PDFEditor.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 = PDFEditor.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 = PDFEditor.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("PDFEditor 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 PDFEditor..."}};

  /**  An Enumeration index for the menu items. */
  private final static int MENUREF[][] =
    {
      {PDFEditor.OPEN_MENUREF, PDFEditor.SAVE_MENUREF, 999,
       PDFEditor.PRINT_MENUREF, 998, PDFEditor.CLOSE_MENUREF,
       PDFEditor.EXIT_MENUREF},
      {PDFEditor.DEBUGLEVEL_MENUREF, 997, PDFEditor.JLF_MENUREF,
       PDFEditor.PLF_MENUREF, PDFEditor.MLF_MENUREF},
      {PDFEditor.HELP_MENUREF, 996, PDFEditor.ABOUT_MENUREF }
    };

  /**
   *  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 PDFEditor Plan",
      "---", "Print Current PDFEditor 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 PDFEditor", "---", "About PDFEditor..."}};

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