The Java Lesson 32: Using the Scrollbar graphical control

  Click here to read full story

All Java Lessons contents page | Java Lesson 1 | Java Lesson 2 | Java Lesson 3 | Java Lesson 4 | Java Lesson 5 | Java Lesson 6 | Java Lesson 7 | Java Lesson 8 | Java Lesson 9 | Java Lesson 10 | Java Lesson 11 | Java Lesson 12 | Java Lesson 13 | Java Lesson 14 | Java Lesson 15 | Java Lesson 16 | Java Lesson 17 | Java Lesson 18 | Java Lesson 19 | Java Lesson 20 | Java Lesson 21 | Java Lesson 22 | Java Lesson 23 | Java Lesson 24 | Java Lesson 25 | Java Lesson 26 | Java Lesson 27 | Java Lesson 28 | Java Lesson 29 | Java Lesson 30 | Java Lesson 31 | Java Lesson 32 | Java Lesson 33 | Java Lesson 34 | Java Lesson 35 | Java Lesson 36 | Java Lesson 37 | Java Lesson 38 | Java Lesson 39 | Java Lesson 40 | Java Lesson 41 | Java Lesson 42 | Java Lesson 43 | Java Lesson 44 | Java Lesson 45 | Java Lesson 46

Java Lesson 32 by Jon Huhtala: Using the Scrollbar graphical control

The Scrollbar class

• Is part of the java.awt package

• Is an extension of the Component class

Object
	Component
		Scrollbar

• Creates a graphical "slide" with a movable "thumb" the user can adjust to select from a range of values. The application can cause some processing to be performed when the thumb is moved by

1. Implementing the AdjustmentListener interface

2. Registering an AdjustmentListener by calling the scrollbar's addAdjustmentListener() method

3. Coding an adjustmentValueChanged() method within the registered AdjustmentListener that defines the processing to be performed

When the user moves the thumb, an AdjustmentEvent will be fired to the adjustmentValueChanged() method of the registered AdjustmentListener for processing.

• Has several constructors. The most commonly used is shown by

Scrollbar myBar = new Scrollbar(Scrollbar.VERTICAL,15,10,1,100);

which creates a vertical scrollbar with an initial value of 15, a thumb width of 10, a minimum value of 1, and a stated maximum value of 100. The actual maximum value is 90 (stated maximum value - thumb width).

The block increment (how far to move the thumb when the user clicks on either side of it within the scrollbar) defaults to 10.

• Contains fields to help specify the orientation of the scrollbar. These are:

Field	Usage
HORIZONTAL	Indicates a horizontal scrollbar
VERTICAL	Indicates a vertical scrollbar

• Has a number of useful methods as follows:

Method	Usage
addAdjustmentListener()	Adds the specified AdjustmentListener to receive AdjustmentEvent objects from this scrollbar
getBlockIncrement()	Gets the block increment of this scrollbar
getMaximum()	Gets the maximum value of this scrollbar
getMinimum()	Gets the minimum value of this scrollbar
getValue()	Gets the current value (thumb position) of this scrollbar
getVisibleAmount()	Gets the current visible amount (thumb size) of this scrollbar
removeAdjustmentListener()	Removes the specified AdjustmentListener so it no longer receives AdjustmentEvent objects from this scrollbar
setBlockIncrement()	Sets the block increment of this scrollbar
setMaximum()	Sets the maximum value of this scrollbar
setMinimum()	Sets the minimum value of this scrollbar
setValue()	Sets the current value (thumb position) of this scrollbar
setVisibleAmount()	Sets the current visible amount (thumb size) of this scrollbar

Consult the help facility of your Java development environment or the Java API for more details.

Example:

import java.awt.*;
import java.awt.event.*;

public class App extends Frame
implements WindowListener, AdjustmentListener {

class Bubble extends Canvas {
private int width;
private int height;
public Bubble(int iWidth, int iHeight) {
width = iWidth;
height = iHeight;
}
public void setWidth(int newWidth) {
width = newWidth;
}
public void setHeight(int newHeight) {
height = newHeight;
}
public void paint(Graphics g) {
g.setColor(Color.pink);
g.fillOval(0,0,width,height);
}
}

Bubble bubble;
Scrollbar wBar;
Scrollbar hBar;
Label size;

public static void main(String[] args) {
App myWindow = new App("Stretch the bubble");
myWindow.setSize(330,370);
myWindow.setVisible(true);
}

public App(String title) {
super(title);
setLayout(new BorderLayout());
addWindowListener(this);
int sWidth = 50;
int sHeight = 150;
bubble = new Bubble(sWidth,sHeight);
bubble.setBackground(Color.white);
add(bubble);
wBar = new Scrollbar(Scrollbar.HORIZONTAL,sWidth,20,1,320);
wBar.setBlockIncrement(wBar.getVisibleAmount());
wBar.addAdjustmentListener(this);
add(wBar, BorderLayout.NORTH);
hBar = new Scrollbar(Scrollbar.VERTICAL,sHeight,20,1,320);
hBar.setBlockIncrement(hBar.getVisibleAmount());
hBar.addAdjustmentListener(this);
add(hBar, BorderLayout.EAST);
size = new Label("width = " + sWidth + ", height = " + sHeight);
size.setBackground(Color.lightGray);
size.setAlignment(Label.CENTER);
add(size,BorderLayout.SOUTH);
}

public void adjustmentValueChanged(AdjustmentEvent e) {
if (e.getSource().equals(wBar)) {
bubble.setWidth(wBar.getValue());
}
if (e.getSource().equals(hBar)) {
bubble.setHeight(hBar.getValue());
}
bubble.repaint();
size.setText("width = " + wBar.getValue() +
", height = " + hBar.getValue());
}

public void windowClosing(WindowEvent e) {
dispose();
System.exit(0);
}

public void windowOpened(WindowEvent e) {}
public void windowActivated(WindowEvent e) {}
public void windowIconified(WindowEvent e) {}
public void windowDeiconified(WindowEvent e) {}
public void windowDeactivated(WindowEvent e) {}
public void windowClosed(WindowEvent e) {}
}

Notes:

1. The class implements the AdjustmentListener interface in order to become a registered AdjustmentListener

2. Inner class Bubble extends Canvas to render a filled, pink oval of a certain width and height. Its constructor receives the bubble's initial width and height as parameters. The setWidth() and setHeight() methods can be called to change the bubble's width and height respectively. The paint() method overrides the inherited paint() method of the Component class to draw the bubble in the current width and height whenever it needs to be rendered.

3. The application class has instance variables for referencing a Bubble object (bubble), scrollbars for changing the bubble's width and height (wBar and hBar), and a label (size) for displaying the current bubble size.

4. In the application's constructor, the bubble is instantiated and added to the CENTER of the application frame. The width scrollbar (wBar) is then instantiated, its block increment is set to be the same as its "thumb" size, its AdjustmentListener registered, and it is added to the NORTH region of the application frame. This is followed by the instantiation of the height scrollbar (hBar), the setting of its block increment, the registering of its AdjustmentListener registered, and adding it to the EAST region of the application frame. Finally, the size label is instantiated to display the initial width and height of the bubble and added to the SOUTH of the application frame.

5. The adjustmentValueChanged() method is required by the AdjustmentListener interface. It receives an AdjustmentEvent object as a parameter and is automatically called when the user moves the thumb within a scrollbar. In this sample, the method determines which scrollbar was adjusted. If the user adjusted wBar, the current value of wBar is passed to the bubble's setWidth() method. If the user adjusted hBar, the current value of hBar is passed to the bubble's setHeight() method. In either case, the bubble is repainted and the size label's text changed to indicate the bubble's new width and height.

Lab exercise for Ferris students

E-mail your answers to this assignment no later than the due date listed in the class schedule.

Review questions

1. A scrollbar is instantiated as follows. Which of the statements below will be true of the scrollbar? (choose two)

new Scrollbar(Scrollbar.HORIZONTAL,25,20,15,275)

1. the maximum value returned by its getValue() method will be 255

2. the maximum value returned by its getValue() method will be 275

3. it would display better in the NORTH or SOUTH of a frame having a BorderLayout than in the frame's EAST or WEST

4. it would display better in the EAST or WEST of a frame having a BorderLayout than in the frame's NORTH or SOUTH

5. it would display equally well in any location of a frame having a BorderLayout

2. What kind of event or events can be fired by a Scrollbar obect?

1. ActionEvent only

2. ActionEvent and AdjustmentEvent

3. AdjustmentEvent only

4. WindowEvent and AdjustmentEvent

5. ActionEvent, WindowEvent, and AdjustmentEvent

3. Code the method header of a method to process a scrollbar event.

4. Assuming that all unseen code is correct and that line numbers are for reference purposes only, what will result from an attempt to compile and execute the following code?

1 2	Scrollbar x = new Scrollbar(VERTICAL,10,20,1,50); x.setMinimum(x.getValue());

1. a compile error will occur at line 1

2. a compile error will occur at line 2

3. a runtime error will occur

4. a vertical scrollbar with a minimum value of 1

5. a vertical scrollbar with a minimum value of 10

12753 bytes more | 2 comments |    | Score: 5

Java: GUI Overview

  Click here to read full story

A GUI (Graphical User Interface) is easy to create after you have a few basic elements from these groups:

1. Top-level Containers (eg, JFrame)
2. Intermediate Containers (eg, JPanel, JMenuBar)
3. Components (eg, JLabel, JButton, JTextField)
4. Listeners (eg, ActionListener)
5. Layouts (eg, FlowLayout, BorderLayout, GridBagLayout)

Top-level Containers are windows (JFrame, JDialog). Each window has two intermediate containers - a menubar which contains the menus, and the content pane which holds the components.

Intermediate Containers (eg, JPanel) contain components. Components are added to the intermediate container. Every container has a layout manager, which specifies how the components are arranged in the container.

Layouts specify how to arrange components in a JPanel (or other intermediate container). Every JPanel starts with a default layout manager, but it's better to set it explicitly.. Use one of Java's layout managers: FlowLayout, BorderLayout, GridLayout, GridBagLayout, BoxLayout, etc.

Components are the user interface controls like buttons (JButton, ...), text boxes (JTextField, JTextArea, ...), menus, etc. These are added to a container with the add() method, and the place they appear on a container is determined by the layout which is used for that container.

Listeners are attached to components and contain the code that is called when the component is used (eg, a button is clicked). This is how a user action on a component (like a click on a JButton or moving a JSlider) is connected to a Java method. As long as you work with components, you never have to use low-level listeners (eg, mouse listeners and key listener) because the components take care of this for you.

Other. The above are essential elements for user interfaces, but others will be useful in some programs. Eg, drawing graphics, animation, mouse, keyboard, sound, ... Good guidance on the appearance can be found in Sun's Java Look and Feel Design Guidelines, which is available on-line for free (java.sun.com/products/jlf/ed2/book/).

Program Organization

There are some simple patterns using constructors, anonymous listeners, etc to produce a reasonable program.

Tools to help build a GUI

Some IDEs have GUI editors. There are also separate GUI editors, eg XUI and UICompiler.

2 comments |    | Score: 0