Reputation: 27

Uploading multiple images with JFileChooser

I tried searching for help to this question all over the web and cannot find any answers. I have a working program at this point that allows you to select an image file and display it. I would like to build upon this by allowing the user to select multiple files and then choose which one to display. For example a user would select an image and it would be displayed. He could then click a button that would allow another image to be queued up and perhaps a button would show up that upon clicking, the image would load in the frame. Could anyone guide me in the right direction for how this may be implemented? Thank you so much for any help!

Here is my current code implementation:

import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;
import java.util.ArrayList;



public class Images extends JFrame{
    JButton button;
    JButton button2;
    JButton button3;
    JLabel label;
    ArrayList<File> images = new ArrayList<>();
    int selectedImageIndex =0;

    public Images(){
    super("Java Image Selector");
    button = new JButton("Select");
    button.setBounds(300,300,100,40);
    button2 = new JButton("Next Image");
    button2.setBounds(250,250,100,40);
    button3 = new JButton("Previous Image");
    button3.setBounds(350,350,100,40);
    label = new JLabel();
    label.setBounds(10,10,670,250);
    add(button);
    add(button2);
    add(button3);
    add(label);

    button.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {



          JFileChooser file = new JFileChooser();
          file.setMultiSelectionEnabled(true);
          File selected[] = file.getSelectedFiles();
          file.setCurrentDirectory(new File(System.getProperty("user.home")));
          //filter the files
          FileNameExtensionFilter filter = new FileNameExtensionFilter("*.Images", "jpg","gif","png");
          file.addChoosableFileFilter(filter);
          int result = file.showSaveDialog(null);
           //if the user click on save in Jfilechooser
          if(result == JFileChooser.APPROVE_OPTION){
              File selectedFile = file.getSelectedFile();
              String path = selectedFile.getAbsolutePath();
              File[] files = file.getSelectedFiles();
              for (File open : files) {
                  images.add(open);
              }
              startProgram(selectedImageIndex);
          }
           //if the user click on save in Jfilechooser

          else if(result == JFileChooser.CANCEL_OPTION){
              System.out.println("No File Selected");
          }
        }
    });

    button2.addActionListener(new ActionListener() { 
      public void actionPerformed(ActionEvent e) { 
         goToNextImages();
      } 
    });

    button3.addActionListener(new ActionListener() { 
      public void actionPerformed(ActionEvent e) { 
        goToPreviousImage();
      } 
    });



    setLayout(null);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLocationRelativeTo(null);
    setSize(700,400);
    setVisible(true);
    }

     // Methode to resize imageIcon with the same size of a Jlabel
    public ImageIcon ResizeImage(String ImagePath)
    {
        ImageIcon MyImage = new ImageIcon(ImagePath);
        Image img = MyImage.getImage();
        Image newImg = img.getScaledInstance(label.getWidth(), label.getHeight(), Image.SCALE_SMOOTH);
        ImageIcon image = new ImageIcon(newImg);
        return image;
    }

    public void setImage(int index){

      if (index<images.size()) {
        File imageFile = images.get(index);
        String path = imageFile.getAbsolutePath();
        selectedImageIndex = index;
        label.setIcon(ResizeImage(path));
        //read the file and set the image
      }else{
        System.out.println("no image found");
      }

    }

   public void goToNextImages(){
      ++selectedImageIndex;
      setImage(selectedImageIndex);
   }

   public void goToPreviousImage(){
      --selectedImageIndex;
       setImage(selectedImageIndex);
   }

   public void startProgram(int index){
       setImage(index);
   }

    public static void main(String[] args){
        new Work();
    }
   }

Upvotes: 0

Answers (2)

MadProgrammer

Reputation: 347234

Okay, let's break this down a bit, you basically need:

Some kind of "model" which contains a list of the image files
Some kind of "view" which shows the current image
Some kind of "controller" which manages the relationships between the view and the model
Some kind of "model" which keeps track of the current viewable image and knows if it can load the next or previous image
Some kind of "view" to allow the user to control the navigation
Some way to control it all

Well, if that's no a Model-View-Controller, I don't know what is...

Okay, because I like well defined contracts and boundaries of responsibility, I like to start with interfaces...

Navigation...

public interface NavigationModel {
    public boolean next();
    public boolean previous();
    public int getIndex();
    public void addChangeListener(ChangeListener listener);
    public void removeChangeListener(ChangeListener listener);
    public boolean canNavigateForward();
    public boolean canNavigateBack();
}

public interface NavigationViewDelegate {
    public boolean next(NavigationView view);
    public boolean previous(NavigationView view);
    public boolean canNavigateForward();
    public boolean canNavigateBack();
}

public interface NavigationView {
    public void setDelegate(NavigationViewDelegate delegate);
    public NavigationViewDelegate getDelegate();
    public JComponent getView();
    public void stateChanged();
}

public interface NavigationContoller {
    public NavigationView getView();
    public NavigationModel getModel();
    public void addChangeListener(ChangeListener listener);
    public void removeChangeListener(ChangeListener listener);
}

Okay, so the delegate allows the view to ask "someone" for more information about the current state, this is typically the controller. The model triggers ChangeEvents which tell anybody who's interested that the state of the model has changed in some way and the controller binds them all together.

Default implementation

Normally, I would have a series abstract implementations, but for brevity, I've gone straight to the implementation

public class DefaultNavigationController implements NavigationContoller {

    private NavigationView view;
    private NavigationModel model;

    private ChangeListener modelChangeListener;
    private final Set<ChangeListener> changeListeners;

    public DefaultNavigationController(NavigationView view, NavigationModel model) {
        Objects.requireNonNull(model, "Model can not be null");
        Objects.requireNonNull(view, "View can not be null");
        this.view = view;
        this.model = model;

        view.setDelegate(new NavigationViewDelegate() {
            @Override
            public boolean next(NavigationView view) {
                return getModel().next();
            }

            @Override
            public boolean previous(NavigationView view) {
                return getModel().previous();
            }

            @Override
            public boolean canNavigateForward() {
                NavigationModel model = getModel();
                return model.canNavigateForward();
            }

            @Override
            public boolean canNavigateBack() {
                NavigationModel model = getModel();
                return model.canNavigateBack();
            }
        });

        changeListeners = new HashSet<>(25);

        modelChangeListener = new ChangeListener() {
            @Override
            public void stateChanged(ChangeEvent e) {
                getView().stateChanged();
                fireStateChanged();
            }
        };
        this.model.addChangeListener(modelChangeListener);
        getView().stateChanged();
    }

    @Override
    public NavigationView getView() {
        return view;
    }

    @Override
    public NavigationModel getModel() {
        return model;
    }

    protected void setModel(NavigationModel model) {
        this.model.removeChangeListener(modelChangeListener);
        this.model = model;
        this.model.addChangeListener(modelChangeListener);
        getView().stateChanged();
        fireStateChanged();
    }

    @Override
    public void addChangeListener(ChangeListener listener) {
        changeListeners.add(listener);
    }

    @Override
    public void removeChangeListener(ChangeListener listener) {
        changeListeners.remove(listener);
    }

    protected void fireStateChanged() {
        ChangeEvent evt = new ChangeEvent(this);
        for (ChangeListener listener : changeListeners) {
            listener.stateChanged(evt);
        }
    }

}

public class DefaultNavigationModel implements NavigationModel {

    private final int minValue;
    private final int maxValue;
    private int currentIndex;
    private final Set<ChangeListener> changeListeners;

    public DefaultNavigationModel(int minValue, int maxValue) {
        this.maxValue = maxValue;
        this.minValue = minValue;
        currentIndex = minValue;

        changeListeners = new HashSet<>(25);
    }

    @Override
    public boolean next() {
        if (currentIndex + 1 < maxValue) {
            currentIndex++;
            fireStateChanged();
        }
        return canNavigateForward();
    }

    @Override
    public boolean previous() {
        if (currentIndex >= minValue) {
            currentIndex--;
            fireStateChanged();
        }
        return canNavigateBack();
    }

    @Override
    public int getIndex() {
        return currentIndex;
    }

    @Override
    public void addChangeListener(ChangeListener listener) {
        changeListeners.add(listener);
    }

    @Override
    public void removeChangeListener(ChangeListener listener) {
        changeListeners.remove(listener);
    }

    protected void fireStateChanged() {
        ChangeEvent evt = new ChangeEvent(this);
        for (ChangeListener listener : changeListeners) {
            listener.stateChanged(evt);
        }
    }

    @Override
    public boolean canNavigateForward() {
        return size() > 0 && currentIndex < maxValue - 1;
    }

    @Override
    public boolean canNavigateBack() {
        return size() > 0 && currentIndex > minValue;
    }

    public int size() {
        return maxValue - minValue;
    }

}

public class DefaultNavigationView extends JPanel implements NavigationView {

    private JButton nextButton;
    private JButton previousButton;

    private NavigationViewDelegate delegate;

    public DefaultNavigationView() {
        setLayout(new GridBagLayout());
        nextButton = new JButton(">");
        previousButton = new JButton("<");

        nextButton.setEnabled(false);
        previousButton.setEnabled(false);

        GridBagConstraints gbc = new GridBagConstraints();
        gbc.weightx = 1;
        gbc.anchor = GridBagConstraints.WEST;
        add(previousButton, gbc);
        gbc.anchor = GridBagConstraints.EAST;
        add(nextButton, gbc);

        nextButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                NavigationViewDelegate delegate = getDelegate();
                if (delegate != null) {
                    nextButton.setEnabled(delegate.next(DefaultNavigationView.this));
                }
            }
        });
        previousButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                NavigationViewDelegate delegate = getDelegate();
                if (delegate != null) {
                    previousButton.setEnabled(delegate.previous(DefaultNavigationView.this));
                }
            }
        });
    }

    @Override
    public NavigationViewDelegate getDelegate() {
        return delegate;
    }

    @Override
    public JComponent getView() {
        return this;
    }

    @Override
    public void setDelegate(NavigationViewDelegate delegate) {
        this.delegate = delegate;
        stateChanged();
    }

    @Override
    public void stateChanged() {
        nextButton.setEnabled(delegate != null && delegate.canNavigateForward());
        previousButton.setEnabled(delegate != null && delegate.canNavigateBack());
    }

}

What's important here to note, is the navigation API doesn't care about the images, it simply cares about a "range" and what value it's current up to.

This could, for example, mean you could change the view to be based on a JSlider or included a JComboBox or what ever controls you want to allow the user to change the index and the rest of the code won't care.

Images...

In a similar fashion, we define a simple model, which maintains a list of Files which represent the available images, a view to show them and a controller to bind them...

public interface ImageModel {
    public File getImageAt(int index);
    public int size();
}

public interface ImageView {
    public void loadImageAt(int index);
    public void setDelegate(ImageViewDelegate delegate);
    public ImageViewDelegate getDelegate();
    public JComponent getView();
}

public interface ImageViewDelegate {
    public File imageAt(ImageView view, int index);
}

public interface ImageViewController {
    public ImageModel getModel();
    public ImageView getView();
    public void loadImageAt(int index);
}

Default implementation...

Again, for brevity, straight to the implementation...

public class DefaultImageModel implements ImageModel {

    private List<File> images;
    private int currentImage = -1;

    public DefaultImageModel(List<File> images) {
        this.images = new ArrayList<>(images);
    }

    @Override
    public File getImageAt(int index) {
        return images.get(index);
    }

    @Override
    public int size() {
        return images.size();
    }

}

public class DefaultImageController implements ImageViewController {

    private ImageView view;
    private ImageModel model;

    public DefaultImageController(ImageView view, ImageModel model) {
        Objects.requireNonNull(model, "Model can not be null");
        Objects.requireNonNull(view, "View can not be null");
        this.view = view;
        this.model = model;

        view.setDelegate(new ImageViewDelegate() {
            @Override
            public File imageAt(ImageView view, int index) {
                return getModel().getImageAt(index);
            }
        });
    }

    public void setModel(ImageModel model) {
        Objects.requireNonNull(model, "Model can not be null");
        this.model = model;
    }

    @Override
    public ImageModel getModel() {
        return model;
    }

    @Override
    public ImageView getView() {
        return view;
    }

    @Override
    public void loadImageAt(int index) {
        getView().loadImageAt(index);
    }

}

public class DefaultImageViewPane extends JPanel implements ImageView {

    private ImageViewDelegate delegate;
    private BufferedImage img = null;

    public DefaultImageViewPane() {
    }

    @Override
    public Dimension getPreferredSize() {
        return img == null ? new Dimension(200, 200) : new Dimension(img.getWidth(), img.getHeight());
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        if (img != null) {
            Graphics2D g2d = (Graphics2D) g.create();
            int x = (getWidth() - img.getWidth()) / 2;
            int y = (getHeight() - img.getHeight()) / 2;
            g2d.drawImage(img, x, y, this);
            g2d.dispose();
        }
    }

    @Override
    public void setDelegate(ImageViewDelegate delegate) {
        this.delegate = delegate;
    }

    @Override
    public ImageViewDelegate getDelegate() {
        return delegate;
    }

    @Override
    public JComponent getView() {
        return this;
    }

    @Override
    public void loadImageAt(int index) {
        ImageViewDelegate delegate = getDelegate();
        if (delegate != null) {             
            img = null;
            File file = delegate.imageAt(this, index);
            if (file != null) {
                try {
                    img = ImageIO.read(file);
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
            revalidate();
            repaint();
        }
    }
}

Putting it all together...

Now, you're probably wondering how all this would fit together?

This is a great example of how controllers can work together, neither actually know about each other, both feed information into each other to achieve their required results...

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.prefs.Preferences;
import javax.imageio.ImageIO;
import javax.swing.AbstractAction;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JToolBar;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.filechooser.FileNameExtensionFilter;

public class Test {

    public static void main(String[] args) {
        new Test();
    }

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new MainPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class MainPane extends JPanel {

        private DefaultImageController imageController;
        private DefaultNavigationController navigationController;

        public MainPane() {
            setLayout(new BorderLayout());

            ImageView imageView = new DefaultImageViewPane();
            ImageModel imageModel = new DefaultImageModel(new ArrayList<>());
            imageController = new DefaultImageController(imageView, imageModel);

            add(new JScrollPane(imageController.getView().getView()));

            NavigationView navView = new DefaultNavigationView();
            NavigationModel navModel = new DefaultNavigationModel(0, 0);
            navigationController = new DefaultNavigationController(navView, navModel);
            navigationController.addChangeListener(new ChangeListener() {
                @Override
                public void stateChanged(ChangeEvent e) {
                    NavigationContoller controller = (NavigationContoller) e.getSource();
                    imageController.loadImageAt(controller.getModel().getIndex());
                }
            });

            add(navigationController.getView().getView(), BorderLayout.SOUTH);

            JToolBar tb = new JToolBar();
            tb.add(new AbstractAction("Browse") {
                @Override
                public void actionPerformed(ActionEvent e) {
                    String lastDirectory = Preferences.userNodeForPackage(MainPane.class).get("Images.lastDirectory", System.getProperty("user.home"));
                    JFileChooser fc = new JFileChooser();
                    File lastPath = new File(lastDirectory);
                    if (lastPath.exists() && lastPath.isDirectory()) {
                        fc.setCurrentDirectory(new File(lastDirectory));
                    }
                    fc.addChoosableFileFilter(new FileNameExtensionFilter("Image files", ImageIO.getReaderFileSuffixes()));
                    fc.setMultiSelectionEnabled(true);
                    if (fc.showOpenDialog(MainPane.this) == JFileChooser.APPROVE_OPTION) {
                        lastDirectory = fc.getCurrentDirectory().getPath();
                        Preferences.userNodeForPackage(MainPane.class).put("Images.lastDirectory", lastDirectory);

                        File[] files = fc.getSelectedFiles();
                        imageController.setModel(new DefaultImageModel(Arrays.asList(files)));
                        navigationController.setModel(new DefaultNavigationModel(0, files.length));
                    }
                }
            });
            add(tb, BorderLayout.NORTH);
        }

    }

    public interface ImageModel {
        public File getImageAt(int index);
        public int size();
    }

    public interface ImageView {
        public void loadImageAt(int index);
        public void setDelegate(ImageViewDelegate delegate);
        public ImageViewDelegate getDelegate();
        public JComponent getView();
    }

    public interface ImageViewDelegate {
        public File imageAt(ImageView view, int index);
    }

    public interface ImageViewController {
        public ImageModel getModel();
        public ImageView getView();
        public void loadImageAt(int index);
    }

    public class DefaultImageModel implements ImageModel {

        private List<File> images;
        private int currentImage = -1;

        public DefaultImageModel(List<File> images) {
            this.images = new ArrayList<>(images);
        }

        @Override
        public File getImageAt(int index) {
            return images.get(index);
        }

        @Override
        public int size() {
            return images.size();
        }

    }

    public class DefaultImageController implements ImageViewController {

        private ImageView view;
        private ImageModel model;

        public DefaultImageController(ImageView view, ImageModel model) {
            Objects.requireNonNull(model, "Model can not be null");
            Objects.requireNonNull(view, "View can not be null");
            this.view = view;
            this.model = model;

            view.setDelegate(new ImageViewDelegate() {
                @Override
                public File imageAt(ImageView view, int index) {
                    return getModel().getImageAt(index);
                }
            });
        }

        public void setModel(ImageModel model) {
            Objects.requireNonNull(model, "Model can not be null");
            this.model = model;
        }

        @Override
        public ImageModel getModel() {
            return model;
        }

        @Override
        public ImageView getView() {
            return view;
        }

        @Override
        public void loadImageAt(int index) {
            getView().loadImageAt(index);
        }

    }

    public class DefaultImageViewPane extends JPanel implements ImageView {

        private ImageViewDelegate delegate;
        private BufferedImage img = null;

        public DefaultImageViewPane() {
        }

        @Override
        public Dimension getPreferredSize() {
            return img == null ? new Dimension(200, 200) : new Dimension(img.getWidth(), img.getHeight());
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            if (img != null) {
                Graphics2D g2d = (Graphics2D) g.create();
                int x = (getWidth() - img.getWidth()) / 2;
                int y = (getHeight() - img.getHeight()) / 2;
                g2d.drawImage(img, x, y, this);
                g2d.dispose();
            }
        }

        @Override
        public void setDelegate(ImageViewDelegate delegate) {
            this.delegate = delegate;
        }

        @Override
        public ImageViewDelegate getDelegate() {
            return delegate;
        }

        @Override
        public JComponent getView() {
            return this;
        }

        @Override
        public void loadImageAt(int index) {
            ImageViewDelegate delegate = getDelegate();
            if (delegate != null) {             
                img = null;
                File file = delegate.imageAt(this, index);
                if (file != null) {
                    try {
                        img = ImageIO.read(file);
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                }
                revalidate();
                repaint();
            }
        }
    }

    /**
     * *************************************************************************
     */
    public interface NavigationModel {
        public boolean next();
        public boolean previous();
        public int getIndex();
        public void addChangeListener(ChangeListener listener);
        public void removeChangeListener(ChangeListener listener);
        public boolean canNavigateForward();
        public boolean canNavigateBack();
    }

    public interface NavigationViewDelegate {
        public boolean next(NavigationView view);
        public boolean previous(NavigationView view);
        public boolean canNavigateForward();
        public boolean canNavigateBack();
    }

    public interface NavigationView {
        public void setDelegate(NavigationViewDelegate delegate);
        public NavigationViewDelegate getDelegate();
        public JComponent getView();
        public void stateChanged();
    }

    public interface NavigationContoller {
        public NavigationView getView();
        public NavigationModel getModel();
        public void addChangeListener(ChangeListener listener);
        public void removeChangeListener(ChangeListener listener);
    }

    public class DefaultNavigationController implements NavigationContoller {

        private NavigationView view;
        private NavigationModel model;

        private ChangeListener modelChangeListener;
        private final Set<ChangeListener> changeListeners;

        public DefaultNavigationController(NavigationView view, NavigationModel model) {
            Objects.requireNonNull(model, "Model can not be null");
            Objects.requireNonNull(view, "View can not be null");
            this.view = view;
            this.model = model;

            view.setDelegate(new NavigationViewDelegate() {
                @Override
                public boolean next(NavigationView view) {
                    return getModel().next();
                }

                @Override
                public boolean previous(NavigationView view) {
                    return getModel().previous();
                }

                @Override
                public boolean canNavigateForward() {
                    NavigationModel model = getModel();
                    return model.canNavigateForward();
                }

                @Override
                public boolean canNavigateBack() {
                    NavigationModel model = getModel();
                    return model.canNavigateBack();
                }
            });

            changeListeners = new HashSet<>(25);

            modelChangeListener = new ChangeListener() {
                @Override
                public void stateChanged(ChangeEvent e) {
                    getView().stateChanged();
                    fireStateChanged();
                }
            };
            this.model.addChangeListener(modelChangeListener);
            getView().stateChanged();
        }

        @Override
        public NavigationView getView() {
            return view;
        }

        @Override
        public NavigationModel getModel() {
            return model;
        }

        protected void setModel(NavigationModel model) {
            this.model.removeChangeListener(modelChangeListener);
            this.model = model;
            this.model.addChangeListener(modelChangeListener);
            getView().stateChanged();
            fireStateChanged();
        }

        @Override
        public void addChangeListener(ChangeListener listener) {
            changeListeners.add(listener);
        }

        @Override
        public void removeChangeListener(ChangeListener listener) {
            changeListeners.remove(listener);
        }

        protected void fireStateChanged() {
            ChangeEvent evt = new ChangeEvent(this);
            for (ChangeListener listener : changeListeners) {
                listener.stateChanged(evt);
            }
        }

    }

    public class DefaultNavigationModel implements NavigationModel {

        private final int minValue;
        private final int maxValue;
        private int currentIndex;
        private final Set<ChangeListener> changeListeners;

        public DefaultNavigationModel(int minValue, int maxValue) {
            this.maxValue = maxValue;
            this.minValue = minValue;
            currentIndex = minValue;

            changeListeners = new HashSet<>(25);
        }

        @Override
        public boolean next() {
            if (currentIndex + 1 < maxValue) {
                currentIndex++;
                fireStateChanged();
            }
            return canNavigateForward();
        }

        @Override
        public boolean previous() {
            if (currentIndex >= minValue) {
                currentIndex--;
                fireStateChanged();
            }
            return canNavigateBack();
        }

        @Override
        public int getIndex() {
            return currentIndex;
        }

        @Override
        public void addChangeListener(ChangeListener listener) {
            changeListeners.add(listener);
        }

        @Override
        public void removeChangeListener(ChangeListener listener) {
            changeListeners.remove(listener);
        }

        protected void fireStateChanged() {
            ChangeEvent evt = new ChangeEvent(this);
            for (ChangeListener listener : changeListeners) {
                listener.stateChanged(evt);
            }
        }

        @Override
        public boolean canNavigateForward() {
            return size() > 0 && currentIndex < maxValue - 1;
        }

        @Override
        public boolean canNavigateBack() {
            return size() > 0 && currentIndex > minValue;
        }

        public int size() {
            return maxValue - minValue;
        }

    }

    public class DefaultNavigationView extends JPanel implements NavigationView {

        private JButton nextButton;
        private JButton previousButton;

        private NavigationViewDelegate delegate;

        public DefaultNavigationView() {
            setLayout(new GridBagLayout());
            nextButton = new JButton(">");
            previousButton = new JButton("<");

            nextButton.setEnabled(false);
            previousButton.setEnabled(false);

            GridBagConstraints gbc = new GridBagConstraints();
            gbc.weightx = 1;
            gbc.anchor = GridBagConstraints.WEST;
            add(previousButton, gbc);
            gbc.anchor = GridBagConstraints.EAST;
            add(nextButton, gbc);

            nextButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    NavigationViewDelegate delegate = getDelegate();
                    if (delegate != null) {
                        nextButton.setEnabled(delegate.next(DefaultNavigationView.this));
                    }
                }
            });
            previousButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    NavigationViewDelegate delegate = getDelegate();
                    if (delegate != null) {
                        previousButton.setEnabled(delegate.previous(DefaultNavigationView.this));
                    }
                }
            });
        }

        @Override
        public NavigationViewDelegate getDelegate() {
            return delegate;
        }

        @Override
        public JComponent getView() {
            return this;
        }

        @Override
        public void setDelegate(NavigationViewDelegate delegate) {
            this.delegate = delegate;
            stateChanged();
        }

        @Override
        public void stateChanged() {
            nextButton.setEnabled(delegate != null && delegate.canNavigateForward());
            previousButton.setEnabled(delegate != null && delegate.canNavigateBack());
        }

    }
}

Upvotes: 3

Priyamal

Reputation: 2989

ArrayList<File> images = new ArrayList<>();
int selectedImageIndex =0;

public void selectFiles() {
    //you can call this method multiple times it wont matter
    //files selected at each time will be stored on the images arraylist
    JFileChooser chooser = new JFileChooser();
    chooser.setMultiSelectionEnabled(true);
    chooser.showOpenDialog(this);
    File[] files = chooser.getSelectedFiles();
    for (File file : files) {
        images.add(file);
    }
    startProgram(selectedImageIndex);
}

public void setImage(int index){

  if (index<images.size()) {
        File imageFile = images.get(index);
        selectedImageIndex = index;
        //read the file and set the image
   }else{
      System.out.println("no image found");
  }

}

public void goToNextImages(){
    ++selectedImageIndex;
    setImage(selectedImageIndex);
}

public void goToPreviousImage(){
    --selectedImageIndex;
    setImage(selectedImageIndex);
}

public void startProgram(int index){
    setImage(index);
}

Upvotes: -1