Java Swing Overview A.O’Riordan, Nov., 2007 Includes notes by K. Brown,

What is Swing? Swing widget toolkit for Java used for constructing a graphical user interface (GUI) - part of The Java Foundation Classes (JFC) “Swing” was the codename of the project that developed the first JFC components Swing improvement on earlier Abstract Window Toolkit (AWT) AWT includes basic set of GUI widgets such as buttons, text boxes, and menus, several layout managers, core GUI event subsystem, and AWT Native Interface JFC includes Pluggable Look and Feel; Accessibility; Java 2D (Java 2 onwards); Drag and Drop

Swing Characteristics Platform independent Extensible Component based Customizable Event driven Separates Component Model from View Lightweight Demo – WebStart SwingSet –

Swing History 1996AWT part of Java from start 1997Sun incorporates Netscape Communications's IFC (Internet Foundation Classes) with other technologies to form the Java Foundation Classes. 1998Released as part of the Java Standard Edition release Drag and drop added (release 1.4) 2004/6Improvements in Java 5 and 6 Much of the Swing API is generally a extension of the AWT rather than a direct replacement At its core, every Swing component relies on an AWT container, since (Swing's) JComponent extends (AWT's) Container

Swing Structure Swing is large - learn general principles and design styles - then use the API reference Java 6 API Reference available at: – Sun’s Swing tutorial – Swing, like the rest of the Java API, is subdivided into packages: –javax.swing –javax.accessibility –javax.swing.border … Most Swing programs also need AWT packages –java.awt –java.awt.event

Swing Overview Swing applications consists of multiple parts –Containers –Components –Events –Graphics Sun makes a distinction between lightweight and heavyweight components: –Lightweight components are not dependent on native peers to render themselves. They are coded in Java. –Heavyweight components are rendered by the host operating system. They are managed by the underlying window manager.

Top-level Containers At the root of every containment hierarchy All Swing programs have at least one Content panes - contains everything except menu bar for most Swing applications Types of top-level containers: JFrame - Window with border, title and buttons Dialogs – secondary window –More limited than frames –Types of dialogs – JOptionPane, ProgressMonitor, JColorChooser, JDialog JApplet – requires Java plug-in for browser

Panels/Panes – Intermediate-level Containers I You don’t add (atomic) components such as buttons directly onto a top-level container such as a JFrame. Each top-level container has a content pane that contains visible components in that top-level container’s GUI. Add component to the content pane: JFrame frame = new JFrame("HelloWorld App"); JLabel label = new JLabel("Hello World"); frame.getContentPane().add(label);

Panels/Panes – Intermediate-level Containers II JPanel Simplify the positioning of other components Contains everything except menu bar for most Swing applications A panel’s default layout manager is FlowLayout Create as a separate class: MyPanel panel = new MyPanel(); frame.getContentPane().add(panel); JScrollPane; JTabbedPane Allow interaction

Create a Component Created just like any class instance –JButton button_ok = new JButton(“OK”); Range in complexity from very simple (e.g. JButton) to very detailed (e.g. JColorChooser) With an image: ImageIcon cup = new ImageIcon("images/cup.gif"); JButton button1 = new JButton("Java", cup);

Some Types of Component Buttons Combo boxes Lists Menus Sliders Text Fields Labels

More Components Tool tips Progress bars Colour choosers File choosers Tables Text Trees

Basic Swing Components

Swing Component Hierarchy (image from here:

Methods inherited by components … customising appearance –get/set Border/Font/Background... affecting component state –enabling, making visible,... registering listeners displaying the component ("painting") adding and removing other components determining layout –get/set Layout/PreferredSize... absolute positioning –get/set Size/Location/Bounds...

Using a Component 1.Create it 2.Configure it 3.Add children (if container) 4.Add to parent (if not JFrame) 5.Listen to it Event handling and listeners - three key bits of code: 1) add interface 2) register 3) handle Components can have multiple listeners

Container (window) with component (button) All this for one button click... user user clicks button event object is generated ae:ActionEvent event is queued for action Listener objects... do something event dispatch loop: remove from queue, invoke handlers in registered listeners

Types of Events AWT Event Hierarchy (from :

EventObject’s Methods Events are represented as Objects Superclass of all event classes is java.util.EventObject Methods defined in EventObject class : Object getSource() returns the object that originated the event - if the user clickes a button, the method getSource returns the object corresponding to button int getID() returns the integer value corresponding to the type of event - e.g. if the user clickes mouse, method getID returns the integer defined as MouseEvent.MOUSE_CLICKED

Component Listeners Global component listeners may be used for any components ComponentListener (changes in size, position, visibility) FocusListener (whether ability for keyboard input) KeyListener (key press events, only with focus) MouseListener (clicks and movement into/out of component area) MouseMotionListener (changes in position over component) Component-specific listeners relevant to specific components ActionListener, CaretListener, ChangeListener, DocumentListener, ItemListener, ListSelectionListener, WindowListener, etc.

Example: WindowListener the WindowListener interface specifies methods which respond to changes in a window's state: windowActivated(...) : window is set to be active windowClosed(...) : window is closed by program windowClosing(...) : window closed by user windowDeactivated(...) : window is no longer active windowDeiconified(...) : window is restored to normal windowIconified(...) : window is minimised windowOpened(...) : window opened for first time

Listener as Inner Class Listener as Inner Class (what we’ve done in all the examples so far) public class Gui{ public static void main(String[] args) { JFrame frame = new JFrame(); frame.addWindowListener(new MyWinListener()); //... private class MyWinListener extends WindowListener { public void windowClosing(WindowEvent we) { System.exit(0); } // etc.

Anonymous Inner Class Listener as Anonymous Inner Class –No class name frame.addWindowListener(new WindowListener(){ public void windowClosing(WindowEvent we) { System.exit(0); } //etc. } // end class definition

GUI itself implementing Listener GUI implements listener itself: public class Gui implements WindowListener{ public static void main(String[] args) { JFrame frame = new JFrame(); frame.addWindowListener(this); //... public void windowClosing(WindowEvent we) { System.exit(0); } // etc.

Pluggable Look and Feel (PLAF) Import package javax.swing.plaf Provides one interface and many abstract classes that Swing uses to provide its pluggable look-and-feel capabilities Can use third party PLAF or create your own look and feel using the Synth package Here are some utility functions that set the LAF to native, Java (Metal), and Motif, respectively: UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName()); UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");

Look and Feel Example Examples: Java, Windows, Motif respectively:

Graphics class Java AWT Graphics - basic but usually enough Properties stored in Graphics object - Color, Font, etc Methods of Graphics can: Draw shapes - lines, rectangles, 3D rectangles, round-edged rectangles, ovals, arcs, polygons, e.g. –drawImage; drawLine; drawOval; drawArc; drawRect –fillArc; fillOval; fillRect Set or get properties, e.g. –setColor; setFont –getColor; getFont Draw text - Draw string on screen as a graphic –drawString

Java2D Java2D graphics: Extends the AWT graphics to provide much more, e.g. gradients, textures, etc. (package java.awt.Graphics2D ) Graphics2D class extends the Graphics class richer graphics, font, and image APIs enhanced colour definition and composition, hit detection on arbitrary geometric shapes and text, and a uniform rendering model for printers and display devices

Painting Components Each JComponent has method for drawing components: void paintComponent(Graphics g) Every component in a GUI has an object of the class Graphics associated with it known as the graphics context. It holds info about the current output device (e.g. the screen), the current drawing colour, the current font, and the clip rectangle (i.e. the area that needs repainting). Whenever the system invokes a component's paint method, it supplies the component's graphics context as a parameter.

When is a component painted? System-triggered painting: the system requests painting: when a component is first made visible when a component is resized by the user when a component has been damaged and needs repair Application-triggered painting : when a component's model is updated Call repaint() method - paints whole component & any others as needed repaint(int leftx,int lefty,int width,int height) - only repaints a specified area Adds the specified region to the dirty region list if the component is showing. The component will be repainted after all of the currently pending events have been dispatched.

Custom painting define a subclass of some JComponent (e.g. a subclass of JPanel) in your class definition, override paintComponent always have the following as the first line in your definition of paintComponent super.paintComponent(g); send messages to g, the graphics context, to get it to draw things for you

Swing not covered Lots more components –JInternalFrame,.JDesktopIcon, JLayeredPane, JMenuBar,, JPopupMenu, JProgressBar, JRootPane, JScrollBar, JScrollPane, JSeparator, JSpinner, JSplitPane, JTabbedPane, JTable, JTableHeader, JTextComponent, JToolBar, JToolTip, JTree, JViewportJInternalFrame.JDesktopIconJLayeredPaneJMenuBarJPopupMenu JProgressBarJRootPaneJScrollBarJScrollPaneJSeparatorJSpinner JSplitPaneJTabbedPaneJTableJTableHeaderJTextComponentJToolBar JToolTipJTreeJViewport Swing Models - specify how the data and state of a Swing component are stored and retrieved Borders Threaded Applications Assistive Technology – support for voice interfaces, screen readers Internationalization and Localization Integrate with Desktop Focus Subsystem Key bindings Dialog Modality Printing Drag and Drop Undo Framework