I'm finding that writing good OO code with Swing is incredibly hard. My problem is essentially that I have a view (a JPanel) that has action listeners. The action listeners figure out which button was clicked and call the appropriate controller method. The issue is that this controller method needs to update another view. So the issue I'm having is I have views being passed all over the place to controllers. Here's an example.
public class MyView extends JPanel implements ActionListener {
private final MyController controller = new MyController();
@Override public void actionPerformed(ActionEvent e) {
this.controller.updateOtherView();
}
}
This is essentially what I want, but this is what ends up happening.
public class MyView extends JPanel implements ActionListener {
private MyController controller = new MyController();
private OtherView otherView;
public MyView(MyOtherView otherView) {
this.otherView = otherView;
}
@Override public void actionPerformed(ActionEvent e) {
this.controller.updateOtherView(otherView);
}
}
And you can see that as the number of views that need to be updated increase and the number of classes that look like this increase, the views are essentially global variables and the code becomes complex and unclear. Another problem I'm running into is this other view usually isn't directly passed into MyView, but it has to go through the parents of MyView to get to MyView, which really just bugs me.
For a real example of this, lets say I have a Menu and this MyView. MyView has a play button, which plays some music for a while and it disables (greys out) the play button until the music is finished. If I have a menu option called play, now I need to access the other views play button so I can grey it out. How can I do this without this annoying passing of views everywhere? Although there might be specific solutions for this problem, I'm looking for something that will solve this view access problem in the general case.
I'm not sure at all how to fix this. I'm kind of using MVC pattern terminology at the moment without using the MVC pattern, which may or may not necessary. Any help is appreciated.
One solution: simply have the controller update the model. Then listeners attached to the model would update the views. You can also have the JMenuItems and corresponding JButtons share the same Action, and thereby when you disable the Action it will disable all buttons/menus/etc that use that Action.
For example, the main class:
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
public class MvcExample {
private static void createAndShowGui() {
MyView view = new MyView();
MyMenuBar menuBar = new MyMenuBar();
MyModel model = new MyModel();
MyControl control = new MyControl(model);
control.addProgressMonitor(view);
control.addView(view);
control.addView(menuBar);
model.setState(MyState.STOP);
JFrame frame = new JFrame("MVC Example");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.getContentPane().add(view.getMainPanel());
frame.setJMenuBar(menuBar.getMenuBar());
frame.pack();
frame.setLocationByPlatform(true);
frame.setVisible(true);
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
createAndShowGui();
}
});
}
private static final byte[] DATA_ARRAY = { 0x43, 0x6f, 0x70, 0x79, 0x72,
0x69, 0x67, 0x68, 0x74, 0x20, 0x46, 0x75, 0x62, 0x61, 0x72, 0x61,
0x62, 0x6c, 0x65, 0x2c, 0x20, 0x30, 0x36, 0x2f, 0x31, 0x36, 0x2f,
0x32, 0x30, 0x31, 0x32, 0x2e, 0x20, 0x46, 0x75, 0x62, 0x61, 0x72,
0x61, 0x62, 0x6c, 0x65, 0x20, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x21 };
}
The Control:
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.List;
import javax.swing.AbstractAction;
@SuppressWarnings("serial")
public class MyControl {
private MyModel model;
private PlayAction playAction = new PlayAction();
private PauseAction pauseAction = new PauseAction();
private StopAction stopAction = new StopAction();
private List<MyProgressMonitor> progMonitorList = new ArrayList<MyProgressMonitor>();
public MyControl(MyModel model) {
this.model = model;
model.addPropertyChangeListener(new MyPropChangeListener());
}
public void addProgressMonitor(MyProgressMonitor progMonitor) {
progMonitorList.add(progMonitor);
}
public void addView(MySetActions setActions) {
setActions.setPlayAction(playAction);
setActions.setPauseAction(pauseAction);
setActions.setStopAction(stopAction);
}
private class MyPropChangeListener implements PropertyChangeListener {
@Override
public void propertyChange(PropertyChangeEvent pcEvt) {
if (MyState.class.getName().equals(pcEvt.getPropertyName())) {
MyState state = (MyState) pcEvt.getNewValue();
if (state == MyState.PLAY) {
playAction.setEnabled(false);
pauseAction.setEnabled(true);
stopAction.setEnabled(true);
} else if (state == MyState.PAUSE) {
playAction.setEnabled(true);
pauseAction.setEnabled(false);
stopAction.setEnabled(true);
} else if (state == MyState.STOP) {
playAction.setEnabled(true);
pauseAction.setEnabled(false);
stopAction.setEnabled(false);
}
}
if (MyModel.PROGRESS.equals(pcEvt.getPropertyName())) {
for (MyProgressMonitor progMonitor : progMonitorList) {
int progress = (Integer) pcEvt.getNewValue();
progMonitor.setProgress(progress);
}
}
}
}
private class PlayAction extends AbstractAction {
public PlayAction() {
super("Play");
putValue(MNEMONIC_KEY, KeyEvent.VK_P);
}
@Override
public void actionPerformed(ActionEvent e) {
model.play();
}
}
private class StopAction extends AbstractAction {
public StopAction() {
super("Stop");
putValue(MNEMONIC_KEY, KeyEvent.VK_S);
}
@Override
public void actionPerformed(ActionEvent e) {
model.stop();
}
}
private class PauseAction extends AbstractAction {
public PauseAction() {
super("Pause");
putValue(MNEMONIC_KEY, KeyEvent.VK_A);
}
@Override
public void actionPerformed(ActionEvent e) {
model.pause();
}
}
}
A State Enum:
public enum MyState {
PLAY, STOP, PAUSE
}
One of the view interfaces:
import javax.swing.Action;
public interface MySetActions {
void setPlayAction(Action playAction);
void setPauseAction(Action pauseAction);
void setStopAction(Action stopAction);
}
Another view interface:
public interface MyProgressMonitor {
void setProgress(int progress);
}
The main GUI View:
import java.awt.BorderLayout;
import java.awt.GridLayout;
import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
public class MyView implements MySetActions, MyProgressMonitor {
private JButton playButton = new JButton();
private JButton stopButton = new JButton();
private JButton pauseButton = new JButton();
private JPanel mainPanel = new JPanel();
private JProgressBar progressBar = new JProgressBar();
public MyView() {
progressBar.setBorderPainted(true);
JPanel btnPanel = new JPanel(new GridLayout(1, 0, 5, 0));
btnPanel.add(playButton);
btnPanel.add(pauseButton);
btnPanel.add(stopButton);
mainPanel.setLayout(new BorderLayout(0, 5));
mainPanel.setBorder(BorderFactory.createEmptyBorder(5, 15, 5, 15));
mainPanel.add(btnPanel, BorderLayout.CENTER);
mainPanel.add(progressBar, BorderLayout.PAGE_END);
}
@Override
public void setPlayAction(Action playAction) {
playButton.setAction(playAction);
}
@Override
public void setStopAction(Action stopAction) {
stopButton.setAction(stopAction);
}
@Override
public void setPauseAction(Action pauseAction) {
pauseButton.setAction(pauseAction);
}
@Override
public void setProgress(int progress) {
progressBar.setValue(progress);
}
public JComponent getMainPanel() {
return mainPanel;
}
}
The menu bar portion of the View:
import java.awt.event.KeyEvent;
import javax.swing.Action;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
public class MyMenuBar implements MySetActions {
private JMenuItem playMenItem = new JMenuItem();
private JMenuItem pauseMenuItem = new JMenuItem();
private JMenuItem stopMenItem = new JMenuItem();
private JMenuBar menuBar = new JMenuBar();
public MyMenuBar() {
JMenu menu = new JMenu("Main Menu");
menu.setMnemonic(KeyEvent.VK_M);
menu.add(playMenItem);
menu.add(pauseMenuItem);
menu.add(stopMenItem);
menuBar.add(menu);
}
public JMenuBar getMenuBar() {
return menuBar;
}
@Override
public void setPlayAction(Action playAction) {
playMenItem.setAction(playAction);
}
@Override
public void setStopAction(Action stopAction) {
stopMenItem.setAction(stopAction);
}
@Override
public void setPauseAction(Action pauseAction) {
pauseMenuItem.setAction(pauseAction);
}
}
And finally, the model:
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeListener;
import javax.swing.Timer;
import javax.swing.event.SwingPropertyChangeSupport;
public class MyModel {
public final static String PROGRESS = "progress";
protected static final int MAX_PROGRESS = 100;
private MyState state = null;
private SwingPropertyChangeSupport pcSupport = new SwingPropertyChangeSupport(
this);
private Timer timer;
private int progress = 0;
public MyState getState() {
return state;
}
public void setState(MyState state) {
MyState oldValue = this.state;
MyState newValue = state;
this.state = newValue;
pcSupport.firePropertyChange(MyState.class.getName(), oldValue, newValue);
}
public int getProgress() {
return progress;
}
public void setProgress(int progress) {
Integer oldValue = this.progress;
Integer newValue = progress;
this.progress = newValue;
pcSupport.firePropertyChange(PROGRESS, oldValue, newValue);
}
public void play() {
MyState oldState = getState();
setState(MyState.PLAY);
if (oldState == MyState.PAUSE) {
if (timer != null) {
timer.start();
return;
}
}
int timerDelay = 50;
// simulate playing ....
timer = new Timer(timerDelay, new ActionListener() {
int timerProgress = 0;
@Override
public void actionPerformed(ActionEvent actEvt) {
timerProgress++;
setProgress(timerProgress);
if (timerProgress >= MAX_PROGRESS) {
setProgress(0);
MyModel.this.stop();
}
}
});
timer.start();
}
public void pause() {
setState(MyState.PAUSE);
if (timer != null && timer.isRunning()) {
timer.stop();
}
}
public void stop() {
setState(MyState.STOP);
setProgress(0);
if (timer != null && timer.isRunning()) {
timer.stop();
}
timer = null;
}
public void addPropertyChangeListener(PropertyChangeListener listener) {
pcSupport.addPropertyChangeListener(listener);
}
public void removePropertyChangeListener(PropertyChangeListener listener) {
pcSupport.removePropertyChangeListener(listener);
}
}
Please ask if any of this is the least bit confusing.
In such situation I tend to use Singletons. Of course this depends on the uniqueness of your views. I usually have Singletons for my "windows" (JFrames) so I can navigate from those to whatever children I need by using getters. However this might not be the best idea in very complex situations.
