Re: I'm looking for someone to appraise my java code for me..

On 10 Mar, 06:38, Roedy Green <see_webs...@mindprod.com.invalid>
wrote:


Okay here it is!

Actually this is another of my projects (my other one is a bit too big
to post here + I don't want to give away my baby). I programmed this
one using JBuilder IDE.

//_______________________________________________

// An application for view Stereophotos. Allow images to be opened
directly from the users hard-drive, or remotely via a URL
// Once opened Images can be resized and viewed in Parallel or
Crosseyed format.
// Will open images in JPEG, PNG or GIF file formats.
// The Method for returning an image to the paint() method is
getBufferedImage();
// Programmed using JBuilder IDE

//to compile: 'ImagesFrame.java' (this file) should be inside
directory 'testingimages'
//then compile from testingimages parent directory with: 'javac
testingimages\ImagesFrame.java'
//to run: run from testingimages parent directory with: 'java
testingimages.ImagesFrame'

package testingimages;

import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
import java.net.URL;

import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.geom.AffineTransform;
import java.util.EventListener;

import java.awt.Toolkit;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import java.awt.Dimension;

public class ImagesFrame extends JFrame implements MouseWheelListener,
KeyListener, MouseListener {
    JPanel contentPane;
    BorderLayout borderLayout1 = new BorderLayout();
    JMenuBar jMenuBar1 = new JMenuBar();
    JMenu jMenuFile = new JMenu();
    JMenuItem jMenuFileOpen = new JMenuItem();
    JMenuItem jMenuFileExit = new JMenuItem();
    JMenu jMenuHelp = new JMenu();
    JMenuItem jMenuHelpAbout = new JMenuItem();

    JLabel statusBar = new JLabel();

    displayPanel displayP;
    JScrollPane jsp;
    JPanel ButtonPanel;
    int zInc;
    JMenuItem jMenuFileLoad = new JMenuItem();
    JMenu jMenuEdit = new JMenu();
    JMenuItem jMenuEditSwap = new JMenuItem();
    JMenuItem jMenuEditNormal = new JMenuItem();

    JMenuItem jMenuEditDivider = new JMenuItem();
    JMenuItem jMenuEditCenter = new JMenuItem();
    JMenuItem jMenuEditSize = new JMenuItem();

    public int incValue = 100;

    double scaleFactor = 1;
    JSlider jSlider1 = new JSlider();
    JLabel sizeField = new JLabel(" ");
    JMenuItem jMenuItem1 = new JMenuItem();
    JMenu jMenuResize = new JMenu();
    JRadioButtonMenuItem Scale3 = new JRadioButtonMenuItem();
   JRadioButtonMenuItem Scale2 = new JRadioButtonMenuItem();
    JRadioButtonMenuItem Scale1 = new JRadioButtonMenuItem();

    JRadioButtonMenuItem Scale4 = new JRadioButtonMenuItem();
    JRadioButtonMenuItem Scale5 = new JRadioButtonMenuItem();
    ButtonGroup group = new ButtonGroup();
    JButton jButton1 = new JButton();

    boolean controlPressed = false;

    int resizeInc = 10;

/**
     * Application entry point.
     *
     * @param args String[]
     */
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.
 
getSystemLookAndFeelClassName());
                } catch (Exception exception) {
                    exception.printStackTrace();
                }
            ImagesFrame frame = new ImagesFrame();
         // Validate frames that have preset sizes
         // Pack frames that have useful preferred size info, e.g.
from their layout
             boolean packFrame = false;
        if (packFrame) {
          frame.pack();
        } else {
          frame.validate();
        }

         // Center the window
         Dimension screenSize =
Toolkit.getDefaultToolkit().getScreenSize();
         Dimension frameSize = frame.getSize();
         if (frameSize.height > screenSize.height) {
           frameSize.height = screenSize.height;
         }
       if (frameSize.width > screenSize.width) {
            frameSize.width = screenSize.width;
        }
        frame.setTitle("Stereo Photo Viewer");
       frame.setLocation((screenSize.width - frameSize.width) / 2,
                          (screenSize.height - frameSize.height) / 2);
       frame.setVisible(true);
            }
        });
    }

    public ImagesFrame() {
        try {
            setDefaultCloseOperation(EXIT_ON_CLOSE);
            jbInit();
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }

    private void jbInit() throws Exception {

        this.zInc = 1;
        contentPane = (JPanel) getContentPane();
        contentPane.setLayout(borderLayout1);
        setSize(new Dimension(400, 300));
        setTitle("Frame Title");
        statusBar.setText(" ");
        jMenuFile.setText("File");
        jMenuFileOpen.setText("Open");
        jMenuFileOpen.addActionListener(new
 
ImagesFrame_jMenuFileOpen_ActionAdapter(this));
        jMenuFileExit.setText("Exit");
        jMenuFileExit.addActionListener(new
 
ImagesFrame_jMenuFileExit_ActionAdapter(this));
        jMenuHelp.setText("Help");
        jMenuHelpAbout.setText("About");
        //jMenuHelpAbout.addActionListener(new
                                         //
ImagesFrame_jMenuHelpAbout_ActionAdapter(this));
        jMenuFileLoad.setText("Load from URL");
        jMenuFileLoad.addActionListener(new
 
ImagesFrame_jMenuFileLoad_actionAdapter(this));
        jMenuEdit.setText("Edit");
        jMenuEditSwap.setText("Swap Left/Right");
        jMenuEditSwap.addActionListener(new
 
ImagesFrame_jMenuEditSwap_actionAdapter(this));
        jMenuEditNormal.setText("Original size");
        jMenuEditNormal.addActionListener(new
                ImagesFrame_jMenuEditNormal_actionAdapter(this));
        jMenuEditDivider.setText("Show Divider");
        jMenuEditDivider.addActionListener(new
                ImagesFrame_jMenuEditDivider_actionAdapter(this));
        jMenuEditCenter.setText("Center Divider");
        jMenuEditCenter.addActionListener(new
                ImagesFrame_jMenuEditCenter_actionAdapter(this));
        jMenuEditSize.setText("Change size");
        jMenuEditSize.addActionListener(new
 
ImagesFrame_jMenuEditSize_actionAdapter(this));
        sizeField.setText("sizeField");
        jMenuResize.setText("Select resize algorythm");
        Scale1.setText("SCALE_AREA_AVERAGING");
        Scale1.addActionListener(new
ImagesFrame_Scale1_actionAdapter(this));
        Scale2.setText("SCALE_DEFAULT");
        Scale2.addActionListener(new
ImagesFrame_Scale2_actionAdapter(this));
        Scale5.setText("SCALE_SMOOTH");
        Scale5.addActionListener(new
ImagesFrame_Scale5_actionAdapter(this));
        Scale3.setText("SCALE_FAST");
        Scale3.addActionListener(new
ImagesFrame_Scale3_actionAdapter(this));
        Scale4.setText("SCALE_REPLICATE");
        Scale4.addActionListener(new
ImagesFrame_Scale4_actionAdapter(this));
        jButton1.setText("Original Size");
        jButton1.addActionListener(new
ImagesFrame_jButton1_actionAdapter(this));
        jMenuBar1.add(jMenuFile);
        jMenuBar1.add(jMenuEdit);
        jMenuFile.add(jMenuFileOpen);
        jMenuFile.add(jMenuFileLoad);
        jMenuFile.add(jMenuFileExit);
        //jMenuBar1.add(jMenuHelp);
        //jMenuHelp.add(jMenuHelpAbout);
        setJMenuBar(jMenuBar1);

        contentPane.add(statusBar, BorderLayout.SOUTH);

        ButtonPanel = new JPanel();
        contentPane.add(statusBar, BorderLayout.NORTH);

        JTextField messageField = new JTextField("");
        displayP = new displayPanel(50, 50);
        jsp = new JScrollPane(displayP,
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
        jsp.getViewport().add(displayP);
        contentPane.add(jsp, BorderLayout.CENTER);
        jMenuEdit.add(jMenuEditSwap);
        jMenuEdit.addSeparator();
        jMenuEdit.add(jMenuEditNormal);
        jMenuEdit.add(jMenuEditSize);
        jMenuEdit.add(jMenuResize);
        jMenuEdit.addSeparator();
        jMenuEdit.add(jMenuEditDivider);
        jMenuEdit.add(jMenuEditCenter);
        ButtonPanel.add(jButton1);
        ButtonPanel.add(jSlider1);
        ButtonPanel.add(sizeField);
        contentPane.add(ButtonPanel, BorderLayout.NORTH);
        group.add(Scale1);
        group.add(Scale2);
        group.add(Scale3);
        group.add(Scale4);
        group.add(Scale5);
        Scale5.setSelected(true);
        jMenuResize.add(Scale1);
        jMenuResize.add(Scale2);
        jMenuResize.add(Scale3);
        jMenuResize.add(Scale4);
        jMenuResize.add(Scale5);

        Dimension x = Toolkit.getDefaultToolkit().getScreenSize();
        this.setSize(x);
        this.setExtendedState(JFrame.MAXIMIZED_BOTH);
        initSlider();

        displayP.resizing = false;
        incValue = jSlider1.getValue();
        sizeField.setText(incValueToString());
        refactor(incValue);

        jSlider1.addMouseWheelListener(this);

        this.addMouseListener(this);
        this.displayP.addMouseListener(this);
        this.setFocusable(true);
        this.addKeyListener(this);
        this.displayP.addKeyListener(this);

        this.displayP.addMouseWheelListener(this);
        this.addMouseWheelListener(this);

        displayP.repaint();

    }

    private void initSlider() {
        jSlider1.setSize(new Dimension(400, 20));
        jSlider1.setPreferredSize(new Dimension(this.getWidth()/4,
20));
        jSlider1.addChangeListener(new
ImagesFrame_jSlider1_actionAdapter(this));
        jSlider1.addMouseListener(new
ImagesFrame_jSlider1_actionAdapter(this));
        jSlider1.setMinimum(1);
        jSlider1.setMaximum(400);

        incValue = 100;
        jSlider1.setValue(incValue);
        sizeField.setText("100%");
    }

    public void jSlider1_changeEvent(ChangeEvent e) {

            displayP.resizing = true;
            incValue = jSlider1.getValue();
            sizeField.setText(incValueToString());
            refactor(incValue);

    }
    public void jSlider1_mousePressed(MouseEvent e) {
        displayP.resizing = true;
    }
    public void jSlider1_mouseReleased(MouseEvent e) {
        displayP.resizing = false;
        incValue = jSlider1.getValue();
        sizeField.setText(incValueToString());
        refactor(incValue);
        resetScrollBars();

        displayP.repaint();

    }

    public void resetScrollBars() {
        JScrollBar tempScrollV = jsp.getVerticalScrollBar();
        JScrollBar tempScrollH = jsp.getHorizontalScrollBar();
        tempScrollV.setValue((tempScrollV.getMaximum()-
tempScrollV.getVisibleAmount())/2);
        tempScrollH.setValue((tempScrollH.getMaximum()-
tempScrollH.getVisibleAmount())/2);
    }

    public boolean isBiggerThanPane() {
        if (displayP.getBufferedImage().getWidth()>
displayP.getWidth() ||
            displayP.BufferedI.getHeight() > displayP.getHeight())
return true;
        else return false;
    }

    void jMenuFileOpen_actionPerformed(ActionEvent actionEvent) {

        System.gc();

        FileDialog fd = new FileDialog(this);
        fd.show();
        String f = fd.getDirectory() + fd.getFile();
        Image im = null;
        try {
            im = Toolkit.getDefaultToolkit().getImage(f);
            displayP.waitForImage(im, this);
        } catch (Exception mye) {
            statusBar.setText(mye.toString());
        }

        if (im.getWidth(this) > 0) {
            reportImageOpened(im);
            displayP.repaint();
        } else {
            statusBar.setText("Incorrect file type.");
        }

    }

    public void reportImageOpened(Image im) {
        statusBar.setText("Image loaded successfully.");
        displayP.resizing = false;
        displayP.swapped = false;
        displayP.initBufferedI(im);
        displayP.initMiniBufferedI();
        incValue = 100;
        jSlider1.setValue(incValue);
        sizeField.setText(incValueToString());
        displayP.resizing = false;
        refactor(incValue);
        resetScrollBars();
        displayP.repaint();
        this.resetDisplay();
    }

    public void resetDisplay() {
        int xInc = this.getWidth() + zInc;
        int yInc = this.getHeight() + zInc;
        zInc = -zInc;
        this.setSize(new Dimension(xInc, yInc));
            this.show();
            this.setFocusable(true);
    }
    /**
     * File | Exit action performed.
     *
     * @param actionEvent ActionEvent
     */
    void jMenuFileExit_actionPerformed(ActionEvent actionEvent) {
        System.exit(0);
    }

    /**
     * Help | About action performed.
     *
     * @param actionEvent ActionEvent
     */
    /*void jMenuHelpAbout_actionPerformed(ActionEvent actionEvent) {
        ImagesFrame_AboutBox dlg = new ImagesFrame_AboutBox(this);
        Dimension dlgSize = dlg.getPreferredSize();
        Dimension frmSize = getSize();
        Point loc = getLocation();
        dlg.setLocation((frmSize.width - dlgSize.width) / 2 + loc.x,
                        (frmSize.height - dlgSize.height) / 2 +
loc.y);
        dlg.setModal(true);
        dlg.pack();
        dlg.show();
    }*/

    public void jMenuFileLoad_actionPerformed(ActionEvent e) {
        System.gc();
        String s = (String)JOptionPane.showInputDialog(this, "Enter a
URL", null);

//If a string was returned, say so.
        if ((s != null) && (s.length() > 0)) {
            URL u = null;
            try {
                u = new URL(s);
            } catch (Exception mye) {
                statusBar.setText(mye.toString());
            }
            if (u != null) {
                ImageIcon ii = null;
                try {
                    ii = new ImageIcon(u);

                } catch (Exception mye) {
                    statusBar.setText(mye.toString());
                }
                if (ii != null && ii.getImage().getWidth(this) > 0) {
                    statusBar.setText("Image loaded successfully.");
                    Image urlImage = ii.getImage();
                    reportImageOpened(urlImage);

                }
            }
        }

    }

    public void centerDivider() {
        if (displayP.dividerVisible == true) {
            this.jMenuEditCenter.setEnabled(true);
        }
    }

    public void jMenuEditSwap_actionPerformed(ActionEvent e) {
        displayP.swap();
       if (displayP.swapped == false) {
           this.jMenuEditCenter.setEnabled(true);
           this.jMenuEditDivider.setEnabled(true);

        } else {
            this.jMenuEditCenter.setEnabled(false);
            this.jMenuEditDivider.setEnabled(false);

        }
    }

    public void jMenuEditNormal_actionPerformed(ActionEvent e) {
        if (displayP.scaleFactor !=1) {

            incValue = 100;
            jSlider1.setValue(incValue);
            sizeField.setText(incValueToString());
            displayP.resizing = false;
            refactor(incValue);
            displayP.repaint();

        }
        statusBar.setText("Full size (edit mode)");
    }

    public String incValueToString() {
        return ("" + incValue + "%");
    }

    public void jMenuEditDivider_actionPerformed(ActionEvent e) {
        if (this.displayP.dividerVisible == true) {
            this.displayP.dividerVisible = false;
            this.jMenuEditCenter.setEnabled(false);
            this.jMenuEditDivider.setText("Show Divider");
            displayP.repaint();
        } else {
            this.displayP.dividerVisible = true;
            this.jMenuEditDivider.setText("Hide Divider");
            this.jMenuEditCenter.setEnabled(true);

            displayP.repaint();
        }

    }

    public void jMenuEditCenter_actionPerformed(ActionEvent e) {
        displayP.centered = true;
        displayP.centerDiv();
    }

    public void jMenuEditSize_actionPerformed(ActionEvent e) {
        String inputValue = JOptionPane.showInputDialog("Please enter
a percentage..");
        try {
            incValue = Integer.parseInt(inputValue);
            if (incValue > 400) incValue = 400;
            if (incValue <1) incValue = 1;

            jSlider1.setValue(incValue);
            sizeField.setText("" + incValue);
            displayP.resizing = false;
            refactor(incValue);
        } catch (Exception mye) {
            System.out.println(mye.toString());
        }

    }

    public void refactor(int s) {
        int inputValue = s;

            try {

                double tempSF = displayP.scaleFactor;

                displayP.scaleFactor = Math.sqrt(((double)
                        inputValue / 100));

                displayP.initScaledBufferedI();

                this.statusBar.setText("Reduced size view");

            } catch (Exception mye) {
                JOptionPane.showMessageDialog(null, null, "Incorrect
format",
 
JOptionPane.ERROR_MESSAGE);

            }
        }

    public void Scale1_actionPerformed(ActionEvent e) {
        displayP.scaleType = Image.SCALE_AREA_AVERAGING;
        displayP.initScaledBufferedI();
        displayP.repaint();
    }

    public void Scale2_actionPerformed(ActionEvent e) {
        displayP.scaleType = Image.SCALE_DEFAULT;
        displayP.initScaledBufferedI();
        displayP.repaint();
    }

    public void Scale3_actionPerformed(ActionEvent e) {
        displayP.scaleType = Image.SCALE_FAST;
        displayP.initScaledBufferedI();
        displayP.repaint();
    }

    public void Scale4_actionPerformed(ActionEvent e) {
        displayP.scaleType = Image.SCALE_REPLICATE;
        displayP.initScaledBufferedI();
        displayP.repaint();
    }

    public void Scale5_actionPerformed(ActionEvent e) {
        displayP.scaleType = Image.SCALE_SMOOTH;
        displayP.initScaledBufferedI();
        displayP.repaint();
    }

    public void jButton1_actionPerformed(ActionEvent e) {
        jMenuEditNormal_actionPerformed(null);
    }

    public void mouseWheelMoved(MouseWheelEvent e) {
        if (controlPressed == true) {
            this.incValue += e.getWheelRotation() * resizeInc;
            if (incValue > 400) incValue = 400;
            if (incValue < 1) incValue = 1;
            displayP.resizing = true;
            sizeField.setText("" + incValue);
            jSlider1.setValue(incValue);
            refactor(incValue);
            displayP.repaint();
            System.out.println("wheel turning");
        }

    }

    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_CONTROL ) {
            System.out.println("" + controlPressed);
           controlPressed = true;
        }

    }

    public void keyReleased(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_CONTROL) {
        controlPressed = false;
        displayP.resizing = false;
        incValue = jSlider1.getValue();
        sizeField.setText(incValueToString());
        refactor(incValue);

        displayP.repaint();
    }

    }

    public void keyTyped(KeyEvent e) {
    }

    public void mouseClicked(MouseEvent e) {
        this.requestFocusInWindow();
    }

    public void mouseEntered(MouseEvent e) {
    }

    public void mouseExited(MouseEvent e) {
    }

    public void mousePressed(MouseEvent e) {
    }

    public void mouseReleased(MouseEvent e) {
    }

}

class ImagesFrame_jButton1_actionAdapter implements ActionListener {
    private ImagesFrame adaptee;
    ImagesFrame_jButton1_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {
        adaptee.jButton1_actionPerformed(e);
    }
}

class ImagesFrame_Scale5_actionAdapter implements ActionListener {
    private ImagesFrame adaptee;
    ImagesFrame_Scale5_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {
        adaptee.Scale5_actionPerformed(e);
    }
}

class ImagesFrame_Scale4_actionAdapter implements ActionListener {
    private ImagesFrame adaptee;
    ImagesFrame_Scale4_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {
        adaptee.Scale4_actionPerformed(e);
    }
}

class ImagesFrame_Scale3_actionAdapter implements ActionListener {
    private ImagesFrame adaptee;
    ImagesFrame_Scale3_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {

        adaptee.Scale3_actionPerformed(e);
    }
}

class ImagesFrame_Scale1_actionAdapter implements ActionListener {
    private ImagesFrame adaptee;
    ImagesFrame_Scale1_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {
        adaptee.Scale1_actionPerformed(e);
    }
}

class ImagesFrame_jMenuEditSize_actionAdapter implements
ActionListener {
    private ImagesFrame adaptee;
    ImagesFrame_jMenuEditSize_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {
        adaptee.jMenuEditSize_actionPerformed(e);
    }
}

class ImagesFrame_Scale2_actionAdapter implements ActionListener {
    private ImagesFrame adaptee;
    ImagesFrame_Scale2_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {
        adaptee.Scale2_actionPerformed(e);
    }
}

class ImagesFrame_jSlider1_actionAdapter implements ChangeListener,
MouseListener {
    private ImagesFrame adaptee;
    ImagesFrame_jSlider1_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void stateChanged(ChangeEvent e) {
       adaptee.jSlider1_changeEvent(e);
    }

    public void mouseClicked(MouseEvent e) {
    }
    public void mouseEntered(MouseEvent e) {
    }

    public void mouseExited(MouseEvent e) {

    }

    public void mousePressed(MouseEvent e) {
        adaptee.jSlider1_mousePressed(e) ;
    }
    public void mouseReleased(MouseEvent e) {
        adaptee.jSlider1_mouseReleased(e) ;
    }

}

class ImagesFrame_jMenuEditCenter_actionAdapter implements
ActionListener {
    private ImagesFrame adaptee;
    ImagesFrame_jMenuEditCenter_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {
        adaptee.jMenuEditCenter_actionPerformed(e);
    }
}

class ImagesFrame_jMenuEditDivider_actionAdapter implements
ActionListener {
    private ImagesFrame adaptee;
    ImagesFrame_jMenuEditDivider_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {
        adaptee.jMenuEditDivider_actionPerformed(e);
    }
}

class ImagesFrame_jMenuEditNormal_actionAdapter implements
ActionListener {
    private ImagesFrame adaptee;
    ImagesFrame_jMenuEditNormal_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {
        adaptee.jMenuEditNormal_actionPerformed(e);
    }
}

class ImagesFrame_jMenuEditSwap_actionAdapter implements
ActionListener {
    private ImagesFrame adaptee;
    ImagesFrame_jMenuEditSwap_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {
        adaptee.jMenuEditSwap_actionPerformed(e);
    }
}

class ImagesFrame_jMenuFileLoad_actionAdapter implements
ActionListener {
    private ImagesFrame adaptee;
    ImagesFrame_jMenuFileLoad_actionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {
        adaptee.jMenuFileLoad_actionPerformed(e);
    }
}

class ImagesFrame_jMenuFileOpen_ActionAdapter implements
ActionListener {
    ImagesFrame adaptee;
    ImagesFrame_jMenuFileOpen_ActionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent actionEvent) {
        adaptee.jMenuFileOpen_actionPerformed(actionEvent);
    }
}

class ImagesFrame_jMenuFileExit_ActionAdapter implements
ActionListener {
    ImagesFrame adaptee;

    ImagesFrame_jMenuFileExit_ActionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent actionEvent) {
        adaptee.jMenuFileExit_actionPerformed(actionEvent);
    }
}

/*class ImagesFrame_jMenuHelpAbout_ActionAdapter implements
ActionListener {
    ImagesFrame adaptee;

    ImagesFrame_jMenuHelpAbout_ActionAdapter(ImagesFrame adaptee) {
        this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent actionEvent) {
        adaptee.jMenuHelpAbout_actionPerformed(actionEvent);
    }
}*/

class displayPanel extends JPanel implements ImageObserver,
MouseMotionListener, MouseListener{

    BufferedImage BufferedI;
    BufferedImage ScaledBufferedI;
    BufferedImage MiniBufferedI;
    BufferedImage left;
    BufferedImage right;
    int width;
    int height;
    boolean swapped;
    int div = 0;
    int lineWidth = 2;
    boolean dividerVisible = false;
    String viewText = "Normal View";
    boolean scaled = false;
    double scaleFactor = 1;
    boolean centered = true;
    boolean resizing = false;
    int scaleType = Image.SCALE_SMOOTH;
    int resizeFactor = 5;

    public displayPanel(int w, int h) {
        super();
        this.swapped = false;
        this.left = null;
        this.right = null;
        this.initBufferedI(null);
        this.initMiniBufferedI();
        this.initScaledBufferedI();
        this.addMouseMotionListener(this);
        this.addMouseListener(this);
        this.repaint();
    }

    public void initBufferedI(Image im) {
        if (im == null) {
            this.BufferedI = new BufferedImage(300, 200,
BufferedImage.TYPE_INT_ARGB);
            this.drawBufferedI();
        } else {

            this.BufferedI = new BufferedImage(im.getWidth(this),
im.getHeight(this), BufferedImage.TYPE_INT_ARGB);
            Graphics b2d = BufferedI.createGraphics();
            b2d.drawImage(im, 0, 0, im.getWidth(this),
im.getHeight(this), this);
            this.repaint();
        }
        this.scaleFactor = 1;
        this.resizing = false;
        centerDiv();

    }

    public void initScaledBufferedI() {
          if (MiniBufferedI == null) {
              initMiniBufferedI();
          }
          Image i = null;
         if (resizing == true) {
              i = (Image) MiniBufferedI.getScaledInstance((int)
(MiniBufferedI.getWidth() *
                      scaleFactor), (int) (MiniBufferedI.getHeight() *
scaleFactor),
                      Image.SCALE_FAST);
          } else {
             i = (Image) BufferedI.getScaledInstance((int)
(BufferedI.getWidth()* scaleFactor), (int)
(BufferedI.getHeight()*scaleFactor),
                      this.scaleType);

          }

         waitForImage(i, this);

           ScaledBufferedI = new BufferedImage(i.getWidth(this),
                                                 i.getHeight(this),
 
BufferedImage.TYPE_INT_ARGB);

           Graphics2D g2d = ScaledBufferedI.createGraphics();

           g2d.drawImage(i, 0, 0, this);

     }

     //initialise Buffered Image to be used for display during
resizing
     public void initMiniBufferedI() {
         Image t = null;

         t = BufferedI.getScaledInstance((int) (BufferedI.getWidth() /
this.resizeFactor
              ), (int) (BufferedI.getHeight() /this.resizeFactor),
                     Image.SCALE_FAST);
        waitForImage(t, this);

        MiniBufferedI = new BufferedImage(t.getWidth(this),
t.getHeight(this), BufferedImage.TYPE_INT_ARGB);
        Graphics2D i2D = MiniBufferedI.createGraphics();
        i2D.drawImage(t, null, this);
    }

   // standard method for loading images
  public static boolean waitForImage(Image image, Component c) {
      MediaTracker tracker = new MediaTracker(c);
      tracker.addImage(image, 0);
      try {
          tracker.waitForAll();
      } catch(InterruptedException ie) {}
      return(!tracker.isErrorAny());
  }

    public BufferedImage getBufferedImage() {
     if (scaleFactor == 1) {
          return BufferedI;
     }
     else {
        return ScaledBufferedI;
     }
  }

    public int getCentered() {
        return (int)(((this.getBufferedImage().getWidth()/ 2) /
scaleFactor)) ;
    }

    public void centerDiv() {
        if (swapped == false)
        this.div = (int)(((this.getBufferedImage().getWidth()/ 2) /
scaleFactor)) ;

    }

    public void drawBufferedI() {
        Graphics2D b2d = this.getBufferedImage().createGraphics();
        b2d.setColor(Color.CYAN);
        b2d.fillRect(0, 0, getBufferedImage().getWidth(),
getBufferedImage().getHeight());
        b2d.setColor(Color.BLUE);
        b2d.drawString("No Image Loaded", 100,
getBufferedImage().getHeight()/2);
    }

    public int getDisplayX() {
        if (resizing == false) {
            return (this.getWidth() - getBufferedImage().getWidth()) /
2;
        } else {
            if (scaleFactor == 1) {
                return (this.getWidth() - BufferedI.getWidth()) / 2;

            } else {
                return (this.getWidth() -
(getBufferedImage().getWidth() * resizeFactor)) /
                        2;
            }
        }
    }

    public int getDisplayY() {
        if (resizing == false) {
            return (this.getHeight() -
getBufferedImage().getHeight()) / 2;
        } else {
            if (scaleFactor == 1) {
                return (this.getHeight() - BufferedI.getHeight()) / 2;
            } else {
                return (this.getHeight() -
(getBufferedImage().getHeight()* resizeFactor)) / 2;
            }
        }
    }

    public Dimension getPreferredSize() {
       return new Dimension(BufferedI.getWidth()*2,
BufferedI.getHeight()*2);
    }

    public void paint(Graphics g) {

        if (this.BufferedI == null) {
            this.initBufferedI(null);
        }
        else {
            Graphics2D g2d = (Graphics2D) g;
                g2d.setColor(Color.BLACK);
                g2d.fillRect(0,0, this.getWidth(), this.getHeight());
                g2d.setColor(Color.CYAN);
                if (resizing == true && scaleFactor != 1) {
                    // Resising.. so draw a pixelated version of
ScaledBufferedI
                    for (int y = 0; y < getBufferedImage().getWidth();
y++) {
                        for (int x = 0; x <
getBufferedImage().getHeight(); x++) {
                            int[] colArray = new int[3];
                            colArray = getSingleColor(y, x,
getBufferedImage().getRGB(y, x));
                            g2d.setColor(new Color(colArray[0],
colArray[1], colArray[2]));
                            g2d.fillRect((y * resizeFactor) +
getDisplayX(),
                                             (x * resizeFactor) +
getDisplayY(),
                                             resizeFactor,
resizeFactor);
                        }
                    }

                } else if (resizing == true && scaleFactor == 1) {
                    // draw BufferedI
                    g2d.drawImage(BufferedI, null, getDisplayX(),
getDisplayY());
                }

                else {
                   // Draw BufferedI or ScaledBufferedI (using
getBufferedImage method)
                   g2d.drawImage(getBufferedImage(), null,
getDisplayX(), getDisplayY());
               }

            if (dividerVisible == true && resizing == false && swapped
== false) {
                // Draw dividing line
                g2d.setColor(Color.RED);
                g2d.fillRect(getLineX(), getLineY(), getLineWidth(),
getLineHeight());

            }
        }
    }

    public BufferedImage drawOffscreen() {
        BufferedImage bi = new BufferedImage(this.getWidth(),
this.getHeight(), BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2d = bi.createGraphics();

        return null;
    }

    //standard method for extracting pixels
    public int[] getSingleColor(int y, int x, int pixel) {
        int[] retInt = new int[3];
        retInt[0] = (pixel >> 16) & 0xff; //red
        retInt[1] = (pixel >> 8) & 0xff; //green
        retInt[2] = (pixel ) & 0xff; //blue
        return retInt;

    }

    public int getLineWidthOffset() {
        return this.lineWidth/2;
    }

    public int getLineX() {
        return getDisplayX() + ((int)(getDiv()*scaleFactor) -
getLineWidthOffset());
    }
    public int getLineY() {
        return getDisplayY();
    }

    public int getLineWidth() {
        return this.lineWidth;

    }

    public int getLineHeight() {
       return this.getBufferedImage().getHeight();
    }

    public int getLineFarX() {
        return getLineX() + getLineWidth();
    }

    public int getLineFarY() {
        return getLineY() + getLineHeight();
    }

    public boolean checkIntersects(int x, int y) {
            if (x >= getDisplayX() && x <= getDisplayX() +
getBufferedImage().getWidth()) {
                if (y >= getDisplayY() && y <= getDisplayY() +
getBufferedImage().getHeight()) {
                    return true;
                }
            }
            return false;
    }

    public int getDiv() {
        return (int)((div));
    }

    public int getDivX() {
            return getDiv();
    }

    public int getDivLength() {
        return this.getBufferedImage().getWidth() - getDivX();
    }

    public void swap() {
        if (BufferedI != null) {

            if (swapped == false) {
                swapped = true;
            } else {
                swapped = false;
            }

                this.left = BufferedI.getSubimage(0, 0,
                        getDivX(),
                        BufferedI.getHeight());
                this.right = BufferedI.getSubimage(getDivX(), 0,
                        (int)(BufferedI.getWidth()-getDivX()),
                        BufferedI.getHeight());

                BufferedImage temp = new
BufferedImage(BufferedI.getWidth(),
                                         BufferedI.getHeight(),
                                         BufferedImage.TYPE_INT_ARGB);
                Graphics2D tg = temp.createGraphics();

                    tg.drawImage(right, null, 0, 0);
                    tg.drawImage(left, null, BufferedI.getWidth()-
getDivX(), 0);

            Graphics2D b2d = BufferedI.createGraphics();

            b2d.drawImage(temp, null, 0, 0);
            this.initMiniBufferedI();
            this.initScaledBufferedI();
            div = BufferedI.getWidth()-getDivX();
            this.repaint();
        }

    }

    public void mouseDragged(MouseEvent e) {

            int x = e.getX();
            int y = e.getY();
            if (checkIntersects(x, y) && swapped == false ) {
                centered = false;
                div = (int)((x - this.getDisplayX()) / scaleFactor);
                this.repaint();
            }
    }

    public void mouseMoved(MouseEvent e) {
    }

    public void mouseClicked(MouseEvent e) {
    }

    public void mouseEntered(MouseEvent e) {
    }

    public void mouseExited(MouseEvent e) {
    }

    public void mousePressed(MouseEvent e) {

            int x = e.getX();
            int y = e.getY();
            if (scaleFactor == 1 && swapped == false) {
                if (checkIntersects(x, y)) {
                    div = (int) ((x - this.getDisplayX()) /
scaleFactor);
                    this.repaint();
                }
            }
    }

    public void mouseReleased(MouseEvent e) {
    }

}

//thanks for any advice!