Week 9 Notes and Questions

• The model, which is the state of the data in the application
• The view, which is the visual representation of the model
• The control, which is the way that a user interacts with the application

For example, the model for an on/off switch might be as simple as a boolean variable, displayed as a checkbox, and controlled by the user clicking the check-box on and off. In practise, the distinction between view and control is not often made - they're generally the same thing in Swing. The important separation is between data and UI. From now on I'll just refer to model and view.

• The model and view interact with one another to ensure consistency, and the means by which they interact is defined, but it is not necessary for each part to know how the other is implemented. Changes to the implementation of the model are therefore possible without requiring corresponding changes to the view, and vice versa. This kind of encapsulation fits in well with the OO paradigm.
• A model can have any number of views attached to it, and views don't all have to be the same. E.g. the "switch" model could simultaneously have a "checkbox" view and a "green/red square" view - each view representing the same model but in a different way.
• A view doesn't have to show all of the model. E.g. in an editor, the edit window (the view) only shows a portion of the file (the model). The model doesn't know or care which bit of the file is visible in the view
• The Swing library includes many xxxxModels (e.g. ListModel, TreeModel) and many classes which attach to a model to produce a view of it (e.g. JList, JTree).
• What is a TreeModel? - It's an interface, so in order to make your class be a model for a tree view, you just implement TreeModel. There's nothing to stop you implementing more than one interface, e.g. in Apu the data is held in a class which implements TreeModel and TableModel. What kind of methods do you think you might find in the TreeModel interface?
• So that you don't have to do all the work, Swing in many cases provides concrete classes which implement the xxxxModel interfaces, e.g. DefaultTreeModel.

Connecting models and views

• Typically, a model will have zero or more views, but any view will map to only one model. There's nothing to stop you writing a class which acts as a view on to multiple models, but if you think you need that you're probably doing something wrong; better to try and use multiple views (even if you make them look on the screen as if they are a single component).
• So a view must know what it's model is. How can we tell an object which is a "view" class what its model is? - either at constructor time (e.g. JTree(TreeModel newModel), or using a "set" method, e.g. JTree.setModel(TreeModel newModel)
• When a view knows what its model is, it can ask the model for information so that it can paint an appropriate representation on the screen, and it can tell the model if something's changed which means the model data must be altered (e.g. someone clicks on the checkbox).
• A model also needs to know what views it has. Why? Because if the information changes inside the model, the views might want to change what they are displaying.
• How does a model know what views are using it? It maintains a list of listeners, which are objects that have asked the model to be kept notified of any changes to the model's data.
• A model (such as TreeModel) will keep a list of all the "listeners" who are interested in it, and so whenever the data in the model changes, it can work through the list and tell each listener that it may need to repaint itself
• What do you think the parameter is to the TreeModel method which adds a new listener? It's a TreeModelListener, which is an interface, and the interface for TreeModelListener contains methods such as treeNodesRemoved(), treeStructureChanged(). So you may well find that when you write a class which is can display a view of a Tree, that class will be declared as implements TreeModelListener.
• In summary, a view object will typically be associated with a single model object, and that object implements a defined interface which means that the view can talk to it. A model maintains a list of listeners all of which are objects that implement the appropriate listener interface to that model, and which are notified through the interface whenever the model wants to let them know something has happened.

Other Swing Features

• Swing has the concept of layouts, which can be used to define how a series of components are positioned within a window. While there's nothing to stop you positioning buttons, labels etc. at absolute co-ordinates inside a window, doing this means that if the window is resized you have to catch the resize event and re-calculate new positions for all your components. (Or you could just make your window non-resizeable.)

  If you use a layout manager, you can tell Swing how you want your components arranged, and leave it to work out what things should look like when the window changes size. For example, you might say that you want a label on the left of the window, and a text field to its right, and that as the window gets wider, the label stays the same width while the text field expands.

• Swing has support for different Look and Feels; Sun produce L&Fs for Java ("Metal"), Windows, Motif and Mac. It is possible to swap the L&F at run-time without the application having to know anything about it (JBuilder does this for example). You can write your own L&F, and there are some that are downloadable on the WWW.
• There is built in support for cut-and-paste, and for drag and drop
• There are many components available, from buttons and labels to text panes, and file-chooser dialogs which you can use in your own applications

Questions

1. Find and run "SwingSet2" to get an idea of what you can do with Swing
2. Compile and run this program:

   import javax.swing.*;
   public class Swing1 
   {
       public static void main(String[] args) 
       {
   	if (args.length == 0) {
   	    System.out.println("please give me some arguments");
   	    return;
   	}
   	
   	JFrame frame = new JFrame("Swing1");
   	JPanel panel = new JPanel();
   
   	for (int i=0; i<args.length; i++) {
   	    JButton button = new JButton(args[i]);
   	    panel.add(button);
   	}
   	
   	frame.getContentPane().add(panel);
   	frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   	frame.setVisible(true);
       }
   }
   

3. How big is the window when the program starts? If you have to re-size it before you can see the window contents, change the program so that the window appears with all the contents showing
4. What happens to the buttons in the window as you re-size it? Why?
5. Change the program so that the buttons are layed out in a grid
6. Change the program so that any argument passed to it that starts with "x" results in a JCheckBox rather than a button
7. Change the program so that any argument starting with a "t" results in a JTextArea rather than a JButton. What happens when you type loads of text into the text area?
8. If you add some "System.out.println" statements after the "setVisible(true)", when do you expect them to be displayed? Try it and see if you were right. Explain what actually happens.
9. Write some code to catch any button presses, so that when a button gets pressed you send a message to the console with the name of the button.
10. Create a DefaultButtonModel object and make it be the model for all the buttons that the program creates. What do you think will happen now? Try it and see.