Java GUI Basics

Swing

• Need libary javax.swing for Swing GUI components
• Extends capabilities in Abstract Window Toolkit (awt)
• GUI components will display differently, depending on the OS (e.g., Windows vs. Mac)
• Most Swing components are lightweight: written in Java so they are not "weighed down" by GUI capabilities of specific platforms
• AWT components are heavyweight because they interact with platform's windowing system.  Every heavyweight component has a peer that is responsible for this interaction.
• Class hierarchy: JComponent extends Container extends Component extends Object.
  

• Deitel & Deitel, Java How to Program
• Lewis & Loftus,
  

• JOptionPane simplifies creation and use of basic dialog boxes.
• Three categories of dialogs: message (ShowMessageDialog), input (ShowInputDialog), and confirm (ShowConfirmDialog).
• Static methods (no need to create new JOptionPane).

• A GUI in Java is created with at least three kinds of objects: components, events and listeners.
• A component is an object that defines a screen element such as a push button, text field, scroll bar, menu, etc.
• A container is a special type of component used to hold and organize other components.  A dialog box and an applet are examples of container components.
• Components are typically attached to the window's content pane.
  
• An event is an object that represents some occurrence.  Often events correspond to user actions such as pressing a mouse button, selecting an item from a menu,  or typing in a text field.  A program that is oriented around a GUI responding to events from the user is called event-driven.  Events from package java.awt.event are used with both Swing and AWT components, with additional Swing events in javax.swing.event.
• The event source is the GUI component in which the event occurred.
  
• A listener is an object that is “waiting” for an event to occur and can respond in some way when it does.
• The programmer must establish the relationships among the listener, the event it listens for, and the component that will generate the event.  This includes two tasks: registering the event listener and implementing the event handler.  
• To create a GUI program, we must: define and set up the necessary components, create listener objects and establish the relationships, and define what happens as a result of various user interactions.

• There are three top-level containers: JFrame, JDialog, and JApplet.
  
• JFrame provides the basic attributes and behaviors of a window.  
  • A frame is displayed as a separate window with its own title bar.
    
  • JFrame constructor accepts a string that will be shown in the title bar.  
  • The setDefaultCloseOperation method specifies what will happen when the close button on the frame is pushed.  Common to terminate (exit).
  • The pack method uses the preferred sizes of the components to determine the window's size.
  • The setVisible method makes the frame visible.
• Every GUI component (button, label, text field etc.) must be part of a containment hierarchy.  The top-level container is the root of the hierarchy. 
  
• Each component should be contained only once.
  
• Each top-level container has a content pane (Container) that contains the GUI components.  For components to be visible, you must add them to the content pane.   Content pane is obtained via getContentPane method.
• Content panes use layout managers to control the positioning/sizing of components.   A layout manager can be selected using the setLayout method.  
  
• The JPanel class provides general-purpose containers for organizing components.  Opaque panels work well as content panes (common technique: create a JPanel, add layout manager and components as needed, add the JPanel to the content pane of the JFrame).
• The default layout manager for JPanel is FlowLayout. 
  
• The size of the panel is specified using a Dimension object, which encapsulates the height and width of a component.
  
• The color is specified using the setBackground method. 
  
• Objects are added using the add method.

• JLabel  allows uneditable text or icons to be displayed.  JLabel constructor takes a String parameter.  Images can also be displayed.
  
• JTextField allows user input, can also be used to display text.
  • The constructor for JTextField accepts an integer that indicates how many characters it can display. 
    
  • A text field generates an action event when the enter key is pressed. 
    
  • The input text can be retrieved using the getText method.
• JButton provides button capabilities.  Constructor takes a String parameter that specifies the label.  Event of interest is when button is pushed.  This is an action event.  The ButtonListener class implements ActionListener.
• JCheckBox provides check box
  • Generates an item event when it changes state.  
  • The ItemListener interface contains a single method called itemStateChanged. 
• JComboBox provides a drop-down list of items from which a selection can be made or new items can be added.
• JList is a list of items from which a selection can be made.  Multiple elements can be selected.
• JRadioButton provides radio buttons.
  • Radio buttons provide mutually exclusive options. 
  • JRadioButton class allows each button to have a label and background color.
    
  • ButtonGroup contains a set of buttons, appended to group using add method.  This simply defines a group of buttons that form a set of dependent options, it is not a container to organize and display components.
  • A radio button produces an item event when it is selected.  Unlike checkboxes, which generate events both when selected and deselected, radio buttons only generate an event when selected.
  • The actionPerformed method can use the getSource method to determine which button was the source of the event.
• The Font class represents a particular character font.  
  • A Font object is defined by font name, font style and font size. 
  • Font styles are plain, bold, italic, and bold+italic. The style is represented as an integer, and constants are defined in Font class. 

• Use of event listeners as described above corresponds to the delegation event model. 
  
• The interfaces for EventListener include: ActionListener, AdjustmentListener, ComponentListener, ContainerListener, FocusListener, ItemListener, KeyListener, MouseListener, MouseMotionListener, TextListener and WindowListener.
  
• The ActionListener interface has just one method: actionPerformed.  It takes one parameter of type ActionEvent.  Can be used to get more information about the event, such as modifier keys.
• Inner classes are often used to define listener objects.
• Labels are used to display information or to identify other components.  
• GUI components must be added to the container in which they are displayed.  May be done in the init method.  The components are added to the content pane that is the primary container for the applet.  The color of the pane can be specified using the setBackground method.
• When GUI components change, need to repaint the screen.
• The JComponent superclass provides common attributes and behaviors such as: pluggable look-and-feel, shortcut keys (mnemonics), event-handling capabilities, tool tips, assistive technologies such as braille screen readers, and localization for different languages/cultures.
• Common organization: file with main defines a JFrame of a particular type, JFrame definition includes private variable to hold the content panel and a private class (or classes) to handle events.

1. Extend JFrame. Used in MusicPreference. The main method is basically a call to the constructor.
2. Create a JFrame, add components, show. Used in DisplayStyles.

• A program might have one listener per event, or a single listener for all events.
  
• A program might also have more than one listener for a single kind of event.
  
• EventObject is the superclass for all AWT and Swing events.   All EventObjects include the method getSource which returns the object that fired the event. 
  
• Event listeners should execute quickly, because all drawing and event-listening methods are executed in the same thread.  If you need to do a lengthy operation, start a new thread.
• Design considerations:
• Having many classes for different kinds of events may be a simple architecture, but can mean reduced performance.
• Putting event listeners in private classes may be more secure.
• Low-level events are window-system occurrences or low-level input such as mouse and key events.  Other events are considered semantic.   Prefer semantic events over low-level, where possible.  Example: an action event for a button will also trigger on a keyboard alternative.
• A component fires only those events for which listeners have registered on it.
• Some listeners are  supported on all Swing components:
• component listener (changes in component size, position, visibility)
• focus listener (whether component has gained/lost ability to receive keyboard input)
• key listener (listens for key presses, must have keyboard focus)
• mouse listener (listen for mouse clicks/movements in or out of drawing area)
• mouse-motion listener (changes in cursor's positon over component)
• mouse-wheel listener (mouse wheel movement over component)
• property-change listener (various)
• Other listeners are specific to components (not all listed here!)
  
• action (buttons, etc.)
• item (menu etc.)
• list selection
• window
• change

• A pixel (picture element) is a tiny region that represents a very small piece of a picture.
• A black and white picture can be stored by representing each pixel using a single bit.
  
• Java coordinate system represents each point using an (x,y) pair of values
• Top-left corner of any Java drawing area has coordinates (0,0).
• X-axis coordinates get larger as you move to the right, y-axis coordinates get larger as you move down (just as in .Net)
• Each graphical component in a Java program has its own coordinate system.

• Requires more than 1 bit per pixel
• Colors are represented as mix of three primary colors: red, green and blue (RGB)
• Using one byte (8 bits) to represent one color, values range from 0 to 255.
• Level of each primary color determines overall color.
• The Color class (part of package java.awt) is used to manage colors. 
  
• Some predefined colors: Color.black (0,0,0), Color.blue (0,0,255), Color.cyan (0,255,255), Color.red(255,0,0), Color.white (255,255,255). 

• void drawLine(int x1, int y1, int x2, int y2) 
  
• void drawRect(int x, int y, int width, int height)  also fillRect, same params, use for filled rectangle.
  
• void drawOval(int x, int y, int width, int height)  also fillOval, same params
  
• void drawString(String str, int x, int y)
• void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) also fillArc, same params
  • x, y, width and height determine an oval
  • start angle is the starting point of the arc in degrees
  • arc angle is not the end point but the range (i.e., "distance" from starting point)
    
• void setColor (Color color).  Use this command before you draw, to set the color for the graphics context.