Aug 27
import java.applet.Applet; import java.awt.*; /** Prints a message saying where the user clicks. * Uses an external listener. *
public class ClickReporter extends Applet {
public void init() {
setBackground(Color.yellow);
addMouseListener(new ClickListener());
}
}
Aug 27
*****************
Custom AWT Slider
* LabeledCostSlider.java. A numeric slider class with attached label.
* CostSlider.java. A slider class that lets you read numeric values. Used in the LabeledCostSlider class.
* Slider.java. A slider class: a combination of Scrollbar and TextField. Used in the CostSlider class.
* ScrollbarPanel.java A Panel with adjustable top and bottom insets, used by the Slider class to change the thickness of the Slider.
*****************
LabeledCostSlider.java. A numeric slider class with attached label.
>>>>>>>>>>>>>>>>>
import java.awt.*;
/** A CostSlider with a label centered above it.
*************
public class LabeledCostSlider extends Panel {
public LabeledCostSlider(String labelString,
Font labelFont,
int minValue, int maxValue,
int initialValue,
Everest app) {
setLayout(new BorderLayout());
Label label = new Label(labelString, Label.CENTER);
if (labelFont != null) {
label.setFont(labelFont);
}
add(label, BorderLayout.NORTH);
CostSlider slider = new CostSlider(minValue,
maxValue,
initialValue,
app);
add(slider, BorderLayout.CENTER);
}
}
<<<<<<<<<<<<<<<<<<<
>>>>>>>>>>>>>>>>>>>
CostSlider.java. A slider class that lets you read numeric values. Used in the LabeledCostSlider class.
>>>>>>>>>>>>>>>>>>>
/** A Slider that takes an Everest applet as an argument,
* calling back to its setCostField when the slider value
* changes.
*
*******************
public class CostSlider extends Slider {
private Everest app;
public CostSlider(int minValue, int maxValue,
int initialValue, Everest app) {
super(minValue, maxValue, initialValue);
this.app = app;
}
public void doAction(int value) {
app.setCostField(value);
}
}
<<<<<<<<<<<<<<<<<<<<<
>>>>>>>>>>>>>>>>>>>>>
Slider.java. A slider class: a combination of Scrollbar and TextField. Used in the CostSlider class.
>>>>>>>>>>>>>>>>>>>>>
import java.awt.*;
import java.awt.event.*;
/** A class that combines a horizontal Scrollbar and a TextField
* (to the right of the Scrollbar). The TextField shows the
* current scrollbar value, plus, if setEditable(true) is set,
* it can be used to change the value as well.
*
********************
public class Slider extends Panel implements ActionListener,
AdjustmentListener {
private Scrollbar scrollbar;
private TextField textfield;
private ScrollbarPanel scrollbarPanel;
private int preferredWidth = 250;
/** Construct a slider with the specified min, max and initial
* values. The "bubble" (thumb) size is set to 1/10th the
* scrollbar range.
*/
public Slider(int minValue, int maxValue, int initialValue) {
this(minValue, maxValue, initialValue,
(maxValue - minValue)/10);
}
/** Construct a slider with the specified min, max,and initial
* values, plus the specified "bubble" (thumb) value. This
* bubbleSize should be specified in the units that min and
* max use, not in pixels. Thus, if min is 20 and max is 320,
* then a bubbleSize of 30 is 10% of the visible range.
*/
public Slider(int minValue, int maxValue, int initialValue,
int bubbleSize) {
setLayout(new BorderLayout());
maxValue = maxValue + bubbleSize;
scrollbar = new Scrollbar(Scrollbar.HORIZONTAL,
initialValue, bubbleSize,
minValue, maxValue);
scrollbar.addAdjustmentListener(this);
scrollbarPanel = new ScrollbarPanel(6);
scrollbarPanel.add(scrollbar, BorderLayout.CENTER);
add(scrollbarPanel, BorderLayout.CENTER);
textfield = new TextField(numDigits(maxValue) + 1);
textfield.addActionListener(this);
setFontSize(12);
textfield.setEditable(false);
setTextFieldValue();
add(textfield, BorderLayout.EAST);
}
/** A place holder to override for action to be taken when
* scrollbar changes.
*/
public void doAction(int value) {
}
/** When textfield changes, sets the scrollbar */
public void actionPerformed(ActionEvent event) {
String value = textfield.getText();
int oldValue = getValue();
try {
setValue(Integer.parseInt(value.trim()));
} catch(NumberFormatException nfe) {
setValue(oldValue);
}
}
/** When scrollbar changes, sets the textfield */
public void adjustmentValueChanged(AdjustmentEvent event) {
setTextFieldValue();
doAction(scrollbar.getValue());
}
/** Returns the Scrollbar part of the Slider. */
public Scrollbar getScrollbar() {
return(scrollbar);
}
/** Returns the TextField part of the Slider */
public TextField getTextField() {
return(textfield);
}
/** Changes the preferredSize to take a minimum width, since
* super-tiny scrollbars are hard to manipulate.
*/
public Dimension getPreferredSize() {
Dimension d = super.getPreferredSize();
d.height = textfield.getPreferredSize().height;
d.width = Math.max(d.width, preferredWidth);
return(d);
}
/** This just calls preferredSize */
public Dimension getMinimumSize() {
return(getPreferredSize());
}
/** To keep scrollbars legible, a minimum width is set. This
* returns the current value (default is 150).
*/
public int getPreferredWidth() {
return(preferredWidth);
}
/** To keep scrollbars legible, a minimum width is set. This
* sets the current value (default is 150).
*/
public void setPreferredWidth(int preferredWidth) {
this.preferredWidth = preferredWidth;
}
/** This returns the current scrollbar value */
public int getValue() {
return(scrollbar.getValue());
}
/** This assigns the scrollbar value. If it is below the
* minimum value or above the maximum, the value is set to
* the min and max value, respectively.
*/
public void setValue(int value) {
scrollbar.setValue(value);
setTextFieldValue();
}
/** Sometimes horizontal scrollbars look odd if they are very
* tall. So empty top/bottom margins can be set. This returns
* the margin setting. The default is four.
*/
public int getMargins() {
return(scrollbarPanel.getMargins());
}
/** Sometimes horizontal scrollbars look odd if they are very
* tall. So empty top/bottom margins can be set. This sets
* the margin setting.
*/
public void setMargins(int margins) {
scrollbarPanel.setMargins(margins);
}
/** Returns the current textfield string. In most cases this
* is just the same as a String version of getValue, except
* that there may be padded blank spaces at the left.
*/
public String getText() {
return(textfield.getText());
}
/** This sets the TextField value directly. Use with extreme
* caution since it does not right-align or check if value
* is numeric.
*/
public void setText(String text) {
textfield.setText(text);
}
/** Returns the Font being used by the textfield.
* Courier bold 12 is the default.
*/
public Font getFont() {
return(textfield.getFont());
}
/** Changes the Font being used by the textfield. */
public void setFont(Font textFieldFont) {
textfield.setFont(textFieldFont);
}
/** The size of the current font */
public int getFontSize() {
return(getFont().getSize());
}
/** Rather than setting the whole font, you can just set the
* size (Monospaced bold will be used for the family/face).
*/
public void setFontSize(int size) {
setFont(new Font("Monospaced", Font.BOLD, size));
}
/** Determines if the textfield is editable. If it is, you can
* enter a number to change the scrollbar value. In such a
* case, entering a value outside the legal range results in
* the min or max legal value. A non-integer is ignored.
*/
public boolean isEditable() {
return(textfield.isEditable());
}
/** Determines if you can enter values directly into the
* textfield to change the scrollbar.
*/
public void setEditable(boolean editable) {
textfield.setEditable(editable);
}
// Sets a right-aligned textfield number.
private void setTextFieldValue() {
int value = scrollbar.getValue();
int digits = numDigits(scrollbar.getMaximum());
String valueString = padString(value, digits);
textfield.setText(valueString);
}
// Repeated String concatenation is expensive, but this is
// only used to add a small amount of padding, so converting
// to a StringBuffer would not pay off.
private String padString(int value, int digits) {
String result = String.valueOf(value);
for(int i=result.length(); i>>>>>>>>>>>>>>>>>>>
ScrollbarPanel.java A Panel with adjustable top and bottom insets, used by the Slider class to change the thickness of the Slider.
>>>>>>>>>>>>>>>>>>>
import java.awt.*;
/** A Panel with adjustable top/bottom insets value.
* Used to hold a Scrollbar in the Slider class.
*
*******************
public class ScrollbarPanel extends Panel {
private Insets insets;
public ScrollbarPanel(int margins) {
setLayout(new BorderLayout());
setMargins(margins);
}
public Insets insets() {
return(insets);
}
public int getMargins() {
return(insets.top);
}
public void setMargins(int margins) {
this.insets = new Insets(margins, 0, margins, 0);
}
}
<<<<<<<<<<<<<<<<<<<<<
Aug 27
##################################
GridBagTest.java Layout of a complicated GUI interface with GridLayout. Uses WindowUtilities.java and ExitListener.java.
##################################
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;
/** An example demonstrating a GridBagLayout GUI with
* input text area and multiple buttons.
*
*********
public class GridBagTest extends JPanel {
private JTextArea textArea;
private JButton bSaveAs, bOk, bExit;
private JTextField fileField;
private GridBagConstraints c;
public GridBagTest() {
setLayout(new GridBagLayout());
setBorder(BorderFactory.createEtchedBorder());
textArea = new JTextArea(12,40); // 12 rows, 40 cols
bSaveAs = new JButton("Save As");
fileField = new JTextField("C:\\Document.txt");
bOk = new JButton("OK");
bExit = new JButton("Exit");
c = new GridBagConstraints();
// Text Area.
c.gridx = 0;
c.gridy = 0;
c.gridwidth = GridBagConstraints.REMAINDER;
c.gridheight = 1;
c.weightx = 1.0;
c.weighty = 1.0;
c.fill = GridBagConstraints.BOTH;
c.insets = new Insets(2,2,2,2); //t,l,b,r
add(textArea,c);
// Save As Button.
c.gridx = 0;
c.gridy = 1;
c.gridwidth = 1;
c.gridheight = 1;
c.weightx = 0.0;
c.weighty = 0.0;
c.fill = GridBagConstraints.VERTICAL;
add(bSaveAs,c);
// Filename Input (Textfield).
c.gridx = 1;
c.gridwidth = GridBagConstraints.REMAINDER;
c.gridheight = 1;
c.weightx = 1.0;
c.weighty = 0.0;
c.fill = GridBagConstraints.BOTH;
add(fileField,c);
// OK Button.
c.gridx = 2;
c.gridy++;
c.gridwidth = 1;
c.gridheight = 1;
c.weightx = 0.0;
c.weighty = 0.0;
c.fill = GridBagConstraints.NONE;
add(bOk,c);
// Exit Button.
c.gridx = 3;
c.gridwidth = 1;
c.gridheight = 1;
c.weightx = 0.0;
c.weighty = 0.0;
c.fill = GridBagConstraints.NONE;
add(bExit,c);
// Filler so Column 1 has nonzero width.
Component filler = Box.createRigidArea(new Dimension(1,1));
c.gridx = 1;
c.weightx = 1.0;
add(filler,c);
}
public static void main(String[] args) {
WindowUtilities.setNativeLookAndFeel();
JFrame frame = new JFrame("GrigBagLayout Test");
frame.setContentPane(new GridBagTest());
frame.addWindowListener(new ExitListener());
frame.pack();
frame.setVisible(true);
}
}
Aug 27
TextAreas.java
**************
import java.applet.Applet;
import java.awt.*;
/././././././,/././././
public class TextAreas extends Applet {
public void init() {
setBackground(Color.lightGray);
add(new TextArea(3, 10));
add(new TextArea("Some\nInitial\nText", 3, 10));
}
}
Aug 27
Lists.java Inherits from CloseableFrame.java.
/./././././././././
import java.awt.*;
/*****************/
public class Lists extends CloseableFrame {
public static void main(String[] args) {
new Lists();
}
public Lists() {
super("Lists");
setLayout(new FlowLayout());
setBackground(Color.lightGray);
setFont(new Font("SansSerif", Font.BOLD, 18));
List list1 = new List(3, false);
list1.add("Vanilla");
list1.add("Chocolate");
list1.add("Strawberry");
add(list1);
List list2 = new List(3, true);
list2.add("Colored Sprinkles");
list2.add("Cashews");
list2.add("Kiwi");
add(list2);
pack();
setVisible(true);
}
}
Aug 27
import java.applet.Applet;
import java.awt.*;
/*******/
public class ChoiceTest extends Applet {
private Choice choice;
public void init() {
setFont(new Font("SansSerif", Font.BOLD, 36));
choice = new Choice();
choice.addItem("Choice 1");
choice.addItem("Choice 2");
choice.addItem("Choice 3");
add(choice);
}
}
Aug 27
/./././././././././
# ButtonExample.java Uses the following classes:
* CloseableFrame.java
* FgReporter.java
* BgReporter.java
* SizeReporter.java
******************
ButtonExample.java
******************
import java.awt.*;
import java.awt.event.*;
/././././././././././
public class ButtonExample extends CloseableFrame {
public static void main(String[] args) {
new ButtonExample();
}
public ButtonExample() {
super("Using ActionListeners");
setLayout(new FlowLayout());
Button b1 = new Button("Button 1");
Button b2 = new Button("Button 2");
Button b3 = new Button("Button 3");
b1.setBackground(Color.lightGray);
b2.setBackground(Color.gray);
b3.setBackground(Color.darkGray);
FgReporter fgReporter = new FgReporter();
BgReporter bgReporter = new BgReporter();
SizeReporter sizeReporter = new SizeReporter();
b1.addActionListener(fgReporter);
b2.addActionListener(fgReporter);
b2.addActionListener(bgReporter);
b3.addActionListener(fgReporter);
b3.addActionListener(bgReporter);
b3.addActionListener(sizeReporter);
add(b1);
add(b2);
add(b3);
setSize(350, 100);
setVisible(true);
}
}
/./././././././././
FgReporter.java
***************
import java.awt.event.*;
import java.awt.*;
/././././././././././
public class FgReporter implements ActionListener {
public void actionPerformed(ActionEvent event) {
Component c = (Component)event.getSource();
System.out.println("Foreground: " + c.getForeground());
}
}
****************
BgReporter.java
****************
/././././././././
import java.awt.event.*;
import java.awt.*;
/././././././././././././
public class BgReporter implements ActionListener {
public void actionPerformed(ActionEvent event) {
Component c = (Component)event.getSource();
System.out.println("Background: " + c.getBackground());
}
}
/././././././././././
SizeReporter.java
***********************
import java.awt.event.*;
import java.awt.*;
/././././././././
public class SizeReporter implements ActionListener {
public void actionPerformed(ActionEvent event) {
Component c = (Component)event.getSource();
Dimension d = c.getSize();
System.out.println("Size: " + d.width + "x" + d.height);
}
}
********************
Aug 27
DisplayFile.java
****************
import java.awt.*;
import java.awt.event.*;
import java.io.*;
/** Uses a FileDialog to choose the file to display.
***************
public class DisplayFile extends CloseableFrame
implements ActionListener {
public static void main(String[] args) {
new DisplayFile();
}
private Button loadButton;
private TextArea fileArea;
private FileDialog loader;
public DisplayFile() {
super("Using FileDialog");
loadButton = new Button("Display File");
loadButton.addActionListener(this);
Panel buttonPanel = new Panel();
buttonPanel.add(loadButton);
add(buttonPanel, BorderLayout.SOUTH);
fileArea = new TextArea();
add("Center", fileArea);
loader = new FileDialog(this, "Browse", FileDialog.LOAD);
// Default file extension: .java.
loader.setFile("*.java");
setSize(350, 450);
setVisible(true);
}
/** When the button is clicked, a file dialog is opened. When
* the file dialog is closed, load the file it referenced.
*/
public void actionPerformed(ActionEvent event) {
loader.show();
displayFile(loader.getFile());
}
public void displayFile(String filename) {
try {
File file = new File(filename);
FileInputStream in = new FileInputStream(file);
int fileLength = (int)file.length();
byte[] fileContents = new byte[fileLength];
in.read(fileContents);
String fileContentsString = new String(fileContents);
fileArea.setText(fileContentsString);
} catch(IOException ioe) {
fileArea.setText("IOError: " + ioe);
}
}
}
*************
CloseableFrame.java.
*************
import java.awt.*;
import java.awt.event.*;
/** A Frame that you can actually quit. Used as the starting
* point for most Java 1.1 graphical applications.
**********************
public class CloseableFrame extends Frame {
public CloseableFrame(String title) {
super(title);
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
}
/** Since we are doing something permanent, we need
* to call super.processWindowEvent first.
*/
public void processWindowEvent(WindowEvent event) {
super.processWindowEvent(event); // Handle listeners.
if (event.getID() == WindowEvent.WINDOW_CLOSING) {
// If the frame is used in an applet, use dispose().
System.exit(0);
}
}
}
Aug 27
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
/** Draw circles centered where the user clicks.
* Uses anonymous inner classes.
*
**********************
public class CircleDrawer4 extends Applet {
public void init() {
setForeground(Color.blue);
addMouseListener
(new MouseAdapter() {
private int radius = 25;
public void mousePressed(MouseEvent event) {
Graphics g = getGraphics();
g.fillOval(event.getX()-radius,
event.getY()-radius,
2*radius,
2*radius);
}
});
}
}
*******************
Aug 27
import java.applet.Applet;
import java.awt.*;
/** Draw circles centered where the user clicks.
* Uses an external listener.
*
***********
public class CircleDrawer1 extends Applet {
public void init() {
setForeground(Color.blue);
addMouseListener(new CircleListener());
}
}
