> ### Section 7.3
> Basic Components and Their Events

> THIS SECTION DISCUSSES some of the GUI interface elements that are represented by subclasses of `JComponent`. The treatment here is brief and covers only the basic uses of each component type. After you become familiar with the basics, you might want to consult a Java reference for more details. I will give some examples of programming with components in the next section.

> The exact appearance of a Swing component and the way that the user interacts with the component are not fixed. They depend on the look-and-feel of the user interface. While Swing supports a default look-and-feel, which is probably the one that you will see most often, it is possible to change the look-and-feel. For example, a Windows look-and-feel could be used to make a Java program that is running on a Windows computer look more like a standard Windows program. While this can improve the user's experience, it means that some of the details that I discuss will have to be qualified with the phrase "depending on the look-and-feel."

> The `JComponent` class itself defines many useful methods that can be used with components of any type. We've already used some of these in examples. Let `comp` be a variable that refers to any JComponent. Then the following methods are available (among many others):

> - `comp.getSize()` is a function that returns an object belonging to the class `Dimension`. This object contains two instance variables, `comp.getSize().width` and `comp.getSize().height`, that give the current size of the component. You can also get the height and width more directly by calling `comp.getHeight()` and `comp.getWidth()`. One warning: When a component is first created, its size is zero. The size will be set later, probably by a layout manager. A common mistake is to check the size of a component before that size has been set, such as in a constructor.
> - `comp.setEnabled(true)` and `comp.setEnabled(false)` can be used to enable and disable the component. When a component is disabled, its appearance changes, and the user cannot do anything with it. There is a boolean-valued function, `comp.getEnabled()` that you can call to discover whether the component is enabled.
> - `comp.setVisible(true)` and `comp.setVisible(false)` can be called to hide or show the component.
> - `comp.setBackground(color)` and `comp.setForeground(color)` set the background and foreground colors for the component. If no colors are set for a component, the colors are determined by the look-and-feel.
> - `comp.setOpaque(true)` tells the component that the area occupied by the component should be filled with the component's background color before the content of the component is painted. In the default look-and-feel, only `JLabels` are non-opaque. A non-opaque, or "transparent", component ignores its background color and simply paints its content over the content of its container. This usually means that it inherits the background color from its container.
> - `comp.setFont(font)` sets the font that is used for text displayed on the component. The parameter is an object of type `java.awt.Font`.
> - `comp.setToolTipText(string)` sets the specified string as a "tool tip" for the component. The tool tip is displayed if mouse cursor is in the component and the mouse is not moved for a few seconds. The tool tip should give some information about the meaning of the component or how to use it.
> - `comp.setCursor(cursor)` sets the cursor image that represents the mouse position when the mouse cursor is inside this component. The parameter is an object belonging to the class `java.awt.Cursor`. Generally, this parameter takes the form `Cursor.getPredefinedCursor(id)` where `id` is one of several constants defined in the `Cursor` class. The most useful values are probably `Cursor.HAND_CURSOR`, `Cursor.CROSSHAIR_CURSOR`, `Cursor.WAIT_CURSOR`, and `Cursor.DEFAULT_CURSOR`. For example, if you would like the cursor to appear as a little pointing hand when the mouse is in the component `comp`, you can use: `comp.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));`
> - `comp.setPreferredSize(size)` sets the size at which the component should be displayed, if possible. The parameter is of type `Dimension`, and a call to this method usually looks something like "`setPreferredSize(new Dimension(100,50))`". The preferred size is used as a hint by layout managers, but will not be respected in all cases. In a BorderLayout, for example, the preferred size of the Center component is irrelevant, but the preferred sizes of the North, South, East, and West components are used by the layout manager to decide how much space to allow for those components. Standard components generally compute a correct preferred size automatically, but it can be useful to set it in some cases. For example, if you use a `JPanel` as a drawing surface, it might be a good idea to set a preferred size for it.
> - `comp.getParent()` is a function that returns a value of type `java.awt.Container`. The return value is the container that directly contains the component, if any. For a top-level component such as a `JApplet`, the value will be null.
> - `comp.getLocation()` is a function that returns the location of the top-left corner of the component. The location is specified in the coordinate system of the component's parent. The returned value is an object of type `Point`. An object of type `Point` contains two instance variables, `x` and `y`.

> For the rest of this section, we'll look at subclasses of `JComponent` that represent common GUI components. Remember that using any component is a multi-step process. The component object must be created with a constructor. It must be added to a container. In many cases, a listener must be registered to respond to events from the component. And in some cases, a reference to the component must be saved in an instance variable so that the component can be manipulated by the program after it has been created.

> ### The JButton Class

> An object of class `JButton` is a push button. You've already seen buttons used in the previous chapter, but we can use a review of `JButtons` as a reminder of what's involved in using components, events, and listeners. (Some of the methods described here are new.)

> - Constructors: The `JButton` class has a constructor that takes a string as a parameter. This string becomes the text displayed on the button. For example: `stopGoButton = new JButton("Go")`
> - Events: When the user clicks on a button, the button generates an event of type `ActionEvent`. This event is sent to any listener that has been registered with the button.
> - Listeners: An object that wants to handle events generated by buttons must implement the `ActionListener` interface. This interface defines just one method, "`pubic void actionPerformed(ActionEvent evt)`", which is called to notify the object of an action event.
> - Registration of Listeners: In order to actually receive notification of an event from a button, an `ActionListener` must be registered with the button. This is done with the button's `addActionListener()` method. For example: `stopGoButton.addActionListener(buttonHandler);`
> - Event methods: When `actionPerformed(evt)` is called by the button, the parameter, `evt`, contains information about the event. This information can be retrieved by calling methods in the `ActionEvent` class. In particular, `evt.getActionCommand()` returns a `String` giving the command associated with the button. By default, this command is the text that is displayed on the button. The method `evt.getSource()` returns a reference to the `Object` that produced the event, that is, to the `JButton` that was pressed. The return value is of type `Object`, not `JButton`, because other types of components can also produce `ActionEvents`.
> - Component methods: There are several useful methods in the `JButton` class. For example, `stopGoButton.setText("Stop")` changes the text displayed on the button to "Stop". And `stopGoButton.setActionCommand("sgb")` changes the action command associated to this button for action events.

> Of course, `JButtons` also have all the general `Component` methods, such as `setEnabled()` and `setFont()`. The `setEnabled()` and `setText()` methods of a button are particularly useful for giving the user information about what is going on in the program. A disabled button is better than a button that gives an obnoxious error message such as "Sorry, you can't click on me now!"

> By the way, it's possible for a `JButton` to display an icon instead of or in addition to the text that it displays. An icon is simply a small image. Several other components can also display icons. However, I will not cover this aspect of Swing in this book. Consult a Java reference if you are interested.

> ### The JLabel Class

> `JLabels` are certainly the simplest type of component. An object of type `JLabel` is just a single line of text. The text cannot be edited by the user, although it can be changed by your program. The constructor for a `JLabel` specifies the text to be displayed:

> `JLabel message = new JLabel("Hello World!");`

> There is another constructor that specifies where in the label the text is located, if there is extra space. The possible alignments are given by the constants `JLabel.LEFT`, `JLabel.CENTER`, and `JLabel.RIGHT`. For example,

> `JLabel message = new JLabel("Hello World!", JLabel.CENTER);`

> creates a label whose text is centered in the available space. You can change the text displayed in a label by calling the label's `setText()` method:

> `message.setText("Goodby World!");`

> Since the `JLabel` class is a subclass of `Component`, you can use methods such as `setForeground()` with labels. If you want the background color to have any effect, you should call `setOpaque(true)` on the label, since otherwise the `JLabel` might not fill in its background (depending on the look-and-feel). For example:

>           JLabel message = new JLabel("Hello World!");
>           message.setForeground(Color.red);   // Display red text...
>           message.setBackground(Color.black); //    on a black background...
>           message.setFont(new Font("Serif",Font.BOLD,18));  // in a bold font.
>           message.setOpaque(true);  // Make sure background is filled in.

> ### The JCheckBox Class

> A `JCheckBox` is a component that has two states: selected or unselected. The user can change the state of a check box by clicking on it. The state of a checkbox is represented by a `boolean` value that is `true` if the box is selected and `false` if the box is unselected. A checkbox has a label, which is specified when the box is constructed:

> `JCheckBox showTime = new JCheckBox("Show Current Time");`

> Usually, it's the user who sets the state of a `JCheckBox`, but you can also set the state in your program. The current state of a checkbox is set using its `setSelected(boolean)` method. For example, if you want the checkbox `showTime` to be checked, you would say "`showTime.setSelected(true);"`. To uncheck the box, say "`showTime.setSelected(false);"`. You can determine the current state of a checkbox by calling its `isSelected()` method, which returns a boolean value.

> In many cases, you don't need to worry about events from checkboxes. Your program can just check the state whenever it needs to know it by calling the `isSelected()` method. However, a checkbox does generate an event when its state changes, and you can detect this event and respond to it if you want something to happen at the moment the state changes. When the state of a checkbox is changed by the user, it generates an event of type `ActionEvent`. If you want something to happen when the user changes the state of a checkbox, you must register an `ActionListener` with the checkbox. (Note that if you change the state by calling the `setSelected()` method, no `ActionEvent` is generated. However, there is another method in the `JCheckBox` class, `doClick()`, which simulates a user click on the checkbox and does generate an `ActionEvent`.)

> When handling an `ActionEvent`, you can call `evt.getSource()` in the `actionPerformed()` method to find out which object generated the event. (Of course, if you are only listening for events from one component, you don't even have to do this.) The returned value is of type `Object`, but you can type-cast it to another type if you want. Once you know the object that generated the event, you can ask the object to tell you its current state. For example, if you know that the event had to come from one of two checkboxes, `cb1` or `cb2`, then your `actionPerformed()` method might look like this:

>               public void actionPerformed(ActionEvent evt) {
>                  Object source = evt.getSource();
>                  if (source == cb1) {
>                     boolean newState = ((JCheckBox)cb1).getSelected();
>                     ... // respond to the change of state
>                  }
>                  else if (source == cb2) {
>                     boolean newState = ((JCheckBox)cb2).getSelected();
>                     ... // respond to the change of state
>                  }
>               }

> Alternatively, you can use `evt.getActionCommand()` to retrieve the action command associated with the source. For a `JCheckBox`, the action command is, by default, the label of the checkbox.

> ### The JRadioButton and ButtonGroup Classes

> Closely related to checkboxes are radio buttons. Radio buttons occur in groups. At most one radio button in a group can be selected at any given time. In Java, a radio button is represented by an object of type `JRadioButton`. When used in isolation, a `JRadioButton` acts just like a `JCheckBox`, and it has the same methods and events. Ordinarily, however, a `JRadioButton` is used in a group. A group of radio buttons is represented by an object belonging to the class `ButtonGroup`. A `ButtonGroup` is not a component and does not itself have a visible representation on the screen. A `ButtonGroup` works behind the scenes to organize a group of radio buttons, so that at most one button in the group can be selected at any given time.

> To use a group of radio buttons, you must create a `JRadioButton` object for each button in the group, and you must create one object of type `ButtonGroup` to organize the individual buttons into a group. Each `JRadioButton` must be added individually to some container, so that it will appear on the screen. (A `ButtonGroup` plays no role in the placement of the buttons on the screen.) Each `JRadioButton` must also be added to the `ButtonGroup`, which has an `add()` method for this purpose. If you want one of the buttons to be selected at start-up, you can call `setSelected(true)` for that button. If you don't do this, then none of the buttons will be selected until the user clicks on one of them.

> As an example, here is how you could set up a set of radio buttons that can be used to select a color:

>               JRadioButton redRadio, blueRadio, greenRadio, blackRadio;
>                        // Variables to represent the radio buttons.
>                        // These should probably be instance variables, so
>                        // that they can be used throughout the program.

>               ButtonGroup colorGroup = new ButtonGroup();

>               redRadio = new JRadioButton("Red");  // Create a button.
>               colorGroup.add(redRadio);    // Add it to the group.

>               blueRadio = new JRadioButton("Blue");
>               colorGroup.add(blueRadio);

>               greenRadio = new JRadioButton("Green");
>               colorGroup.add(greenRadio);

>               blackRadio = new JRadioButton("Black");
>               colorGroup.add(blackRadio);

>               redRadio.setSelected(true);  // Make an initial selection.

> The individual buttons must still be added to a container if they are to appear on the screen. If you want to respond immediately when the user clicks on one of the radio buttons, you should register an `ActionListener` for each button. Here is an applet that demonstrates this. When you click one of the radio buttons, the background color of the label is changed:

> (Applet "RadioButtonDemo" would be displayed here
> if Java were available.)

> The source code for the applet is in the file RadioButtonDemo.java. Just as for checkboxes, it is not always necessary to register listeners for radio buttons. In many cases, you can simply check the state of each button when you need to know it, using the `isSelected()` method.

> ### The JComboBox Class

> The `JComboBox` class represents another way of letting the user select one option from a list of options. But in this case, the options are presented as a kind of pop-up menu, and only the currently selected option is visible on the screen. The painting applet at the end of Section 6.6 used a `JComboBox` for selecting a color.

> When a `JComboBox` object is first constructed, it initially contains no items. An item is added to the bottom of the menu by calling its instance method, `addItem(str)`, where `str` is a string that will be displayed. (In fact, you can add any type of object to a `JComboBox`. The `toString()` method of the object is called to determine what string to display.)

> For example, the following code will create an object of type `JComboBox` that contains the options Red, Blue, Green, and Black:

>               JComboBox colorChoice = new JComboBox();
>               colorChoice.addItem("Red");
>               colorChoice.addItem("Blue");
>               colorChoice.addItem("Green");
>               colorChoice.addItem("Black");

> You can call the `getSelectedIndex()` method of a `JComboBox` to find out which item is currently selected. This method returns an integer that gives the position of the selected item in the list, where the items are numbered starting from zero. Alternatively, you can call `getSelectedItem()` to get the selected item itself. (This method returns a value of type `Object`.) You can change the selection by calling the method `setSelectedIndex(n)`, where `n` is an integer giving the position of the item that you want to select.

> The most common way to use a `JComboBox` menu is to call its `getSelectedIndex()` method when you have a need to know which item is currently selected. However, like other components that we have seen, `JComboBox` components generate `ActionEvents`. You can register an `ActionListener` with the `JComboBox` if you want to respond to such events as they occur.

> `JComboBoxes` have a nifty feature, which is probably not all that useful in practice. You can make a `JComboBox` "editable" by calling its method `setEditable(true)`. If you do this, the user can edit the selection by clicking on the `JComboBox` and typing. This allows the user to make a selection that is not in the pre-configured list that you provide. (The "Combo" in the name "JComboBox" refers to the fact that it's a kind of combination of menu and text-input box.) If the user has edited the selection in this way, then the `getSelectedIndex()` method will return the value `-1`, and `getSelectedItem()` will return the string that the user typed. An `ActionEvent` is triggered if the user presses return in the `JComboBox`.

> ### The JSlider Class

> A `JSlider` provides a way for the user to select an integer value from a range of possible values. The user does this by dragging a "knob" along a bar. A slider can, optionally, be decorated with tick marks and with labels. This demonstration applet shows three sliders with different decorations and with different ranges of values:

> (Applet "SliderDemo" would be displayed here
> if Java were available.)

> In this applet, the second slider is decorated with ticks, and the third one is decorated with labels. It's possible for a single slider to have both types of decorations.

> The most commonly used constructor for `JSliders` specifies the start and end of the range of values for the slider and its initial value when it first appears on the screen:

>                 JSlider(int minimum, int maximum, int value)

> If the parameters are omitted, the values 0, 100, and 50 are used. By default, a slider is horizontal, but you can make it vertical by calling its method `setOrientation(JSlider.VERTICAL)`. The current value of a `JSlider` can be read at any time with its `getValue()` method. This method returns a value of type `int`. If you want to change the value, you can do so with the method `setValue(n)`, which takes a parameter of type `int`.

> If you want to respond immediately when the user changes the value of a slider, you can register a listener with the slider. `JSliders`, unlike other components we have seen, do not generate `ActionEvents`. Instead, they generate events of type `ChangeEvent`. `ChangeEvent` and related classes are defined in the package `javax.swing.event` rather than `java.awt.event`, so if you want to use `ChangeEvents`, you should `import javax.swing.event.*` at the beginning of your program. You must also define some object to implement the `ChangeListener` interface, and you must register the change listener with the slider by calling its `addChangeListener()` method. A `ChangeListener` must provide a definition for the method:

>                 void stateChanged(ChangeEvent evt)

> This method will be called whenever the value of the slider changes. (Note that it will be called when you change the value with the `setValue()` method, as well as when the user changes the value.) In the `stateChanged()` method, you can call `evt.getSource()` to find out which object generated the event.

> Using tick marks on a slider is a two-step process: Specify the interval between the tick marks, and tell the slider that the tick marks should be displayed. There are actually two types of tick marks, "major" tick marks and "minor" tick marks. You can have one or the other or both. Major tick marks are a bit longer than minor tick marks. The method `setMinorTickSpacing(i)` indicates that there should be a minor tick mark every `i` units along the slider. The parameter is an integer. (The spacing is in terms of values on the slider, not pixels.) For the major tick marks, there is a similar command, `setMajorTickSpacing(i)`. Calling these methods is not enough to make the tick marks appear. You also have to call `setPaintTicks(true)`. For example, the second slider in the above applet was created and configured using the commands:

>                 slider2 = new JSlider();
>                 slider2.addChangeListener(this);
>                 slider2.setMajorTickSpacing(25);
>                 slider2.setMinorTickSpacing(5);
>                 slider2.setPaintTicks(true);
>                 getContentPane().add(slider2);

> Labels on a slider are handled similarly. You have to specify the labels and tell the slider to paint them. Specifying labels is a tricky business, but the `JSlider` class has a method to simplify it. Create a set of labels and add them to a slider named `sldr` with the command:

>               sldr.setLabelTable( sldr.createStandardLabels(i) );

> where `i` is an integer giving the spacing between the labels. To arrange for the labels to be displayed, call `setPaintLabels(true)`. For example, the third slider in the above applet was created and configured with the commands:

>                 slider3 = new JSlider(2000,2100,2002);
>                 slider3.addChangeListener(this);
>                 slider3.setLabelTable(slider3.createStandardLabels(50));
>                 slider3.setPaintLabels(true);
>                 getContentPane().add(slider3);

> ### JScrollBar and JScrollPane

> A `JScrollBar`, like a `JSlider`, allows the user to select an integer value from a range of values. A scroll bar, however, is generally used to control the scrolling of another component such as the text in a text editor. A scroll bar can be either horizontal or vertical. It has five parts:

> The position of the tab specifies the currently selected value. The user can move the tab by dragging it or by clicking on any of the other parts of the scroll bar. The size of the tab tells what portion of a scrolling region is currently visible. It is actually the position of the bottom or left edge of the tab that represents the currently selected value.

> A scroll bar has four associated integer values:

> - `min`, which specifies the starting point of the range of values represented by the scrollbar, corresponding to the left or bottom edge of the bar
> - `max`, which specifies the end point of the range of values, corresponding to the right or top edge of the bar
> - `visible`, which specifies the size of the tab
> - `value`, which gives the currently selected value, somewhere in the range between `min` and `(max - visible)`.

> Note that the largest possible value is `(max - visible)`, not `max`, since the `value` represents the position of the left or bottom edge of the tab. The largest possible value allows space for the tab, whose size is given by `visible`.

> The four values can be specified when the scroll bar is created. The constructor takes the form

>          JScrollbar(int orientation, int value, int visible, int min, int max);

> The `orientation`, which specifies whether the scroll bar is horizontal or vertical, must be one of the constants `JScrollbar.HORIZONTAL` or `JScrollbar.VERTICAL`. The value must be between `min` and `(max - visible)`. You can leave out all the `int` parameters to get a scroll bar with default values. You can set the `value` of the scroll bar at any time with the method `setValue(int)`. Similarly, the other values can be set with `setMinimum(int)`, `setMaximum(int)`, and `setVisibleAmount(int)`. You can also set all four values at once by calling:

>            void setValues(int value, int visible, int min, int max);

> Methods `getValue()`, `getVisibleAmount()`, `getMinimum()` and `getMaximum()` are provided for reading the current values of each of these parameters.

> The user can drag the tab or click elsewhere on the scroll bar. How far does the tab move when the user clicks on the up-arrow or down-arrow or in the page-up or page-down region of a scrollbar? The amount by which the `value` changes when the user clicks on the up-arrow or down-arrow is called the unit increment. The amount by which it changes when the user clicks in the page-up or page-down region is called the block increment. By default, both of these values are 1. They can be set using the methods:

>              void setUnitIncrement(int unitIncrement);
>              void setBlockIncrement(int blockIncrement);

> Let's look at an example. Suppose that you want to use a very large drawing area, which is too large to fit on the screen. You might decide to display only part of the `JPanel` and to provide scroll bars to allow the user to scroll through the entire panel. Let's say that the actual panel is 1000 by 1000 pixels, and that you will show a 200-by-200 region of the panel at any one time. Let's look at how you would set up the vertical scroll bar. The horizontal bar would be essentially the same.

> The `visible` of the scroll bar would be 200, since that is how many pixels would actually be displayed. The `value` of the scroll bar would represent the vertical coordinate of the pixel that is at the top of the display. (Whenever the `value` changes, you have to redraw the display.) The `min` would be 0, and the `max` would be 1000. The range of values that can be set on the scroll bar is from 0 to 800. (Remember that the largest possible value is the maximum minus the visible amount.)

> The page increment for the scroll bar could be set to some value a little less than 200, say 190 or 175. Then, when the user clicks in the page-up or page-down region, the display will scroll by an amount almost equal to its size. The line increment could be left at 1, but it is likely that this would be too small since it represents a scrolling increment of just one pixel. A line increment of 15 would be better, since then the display would scroll by a more reasonable 15 pixels when the user clicks the up-arrow or down-arrow. (Of course, all these values would have to be reset if the display area is resized.)

> A scroll bar generates an event of type `AdjustmentEvent` whenever the user changes the value of the scroll bar. The associated `AdjustmentListener` interface defines one method, "`adjustmentValueChanged(AdjustmentEvent evt)`", which is called by the scroll bar to notify the listener that the value on the scroll bar has been changed. This method should repaint the display or make whatever other change is appropriate for the new value. The method `evt.getValue()` returns the current value on the scroll bar. If you are using more than one scroll bar and need to determine which scroll bar generated the event, use `evt.getSource()` to determine the source of the event.

> Scrolling is complicated. Fortunately, Swing provides a class that can take care of many of the details. A `JScrollPane` is is a component that provides scrolling for another component. That component is specified as a parameter to the constructor:

>                 JScrollPane(Component content)

> The content component appears in the center of the scroll pane. If it is too large to be displayed entirely, then horizontal and/or vertical scroll bars will appear that can be used for scrolling the content. You have to add the scroll pane to a container to make both the scroll pane and its content appear on the screen. This makes scrolling very easy, and makes it unusual to work with scroll bars directly.

> A `JScrollPane` can use any component as content, but several Swing components, including the `JTextArea` that will be discussed below, are designed specifically to work with `JScrollPane`.

> ### The JTextField and JTextArea Classes

> `JTextFields` and `JTextAreas` are boxes where the user can type in and edit text. The difference between them is that a `JTextField` contains a single line of editable text, while a `JTextArea` can display multiple lines. It is also possible to set a `JTextField` or `JTextArea` to be read-only so that the user can read the text that it contains but cannot edit the text.

> Both `JTextField` and `JTextArea` are subclasses of `javax.swing.text.JTextComponent`, which defines their common behavior. The `JTextComponent` class supports the idea of a selection. A selection is a subset of the characters in the `JTextComponent`, including all the characters from some starting position to some ending position. The selection is hilited on the screen. The user selects text by dragging the mouse over it. Some useful methods in class `JTextComponent` include the following. They can, of course, be used for both `JTextFields` and `JTextAreas`.

>             void setText(String newText);  // substitute newText
>                                            //   for current contents
>             String getText();  // return a copy of the current contents
>             String getSelectedText();  // return the selected text
>             void select(int start, int end);  // change the selection;
>                // characters in the range  start <= pos < end  are
>                // selected; characters are numbered starting from zero
>             void selectAll();  // select the entire text
>             int getSelectionStart();  // get starting point of selection
>             int getSelectionEnd();  // get end point of selection
>             void setEditable(boolean canBeEdited);
>               // specify whether or not the text in the component
>               // can be edited by the user

> The `requestFocus()` method, inherited from `JComponent`, is also useful for text components. The constructor for a `JTextField` takes the form

>              JTextField(int columns);

> where `columns` specifies the number of characters that should be visible in the text field. This is used to determine the preferred width of the text field. (Because characters can be of different sizes, the number of characters visible in the text field might not be exactly equal to `columns`.) You don't have to specify the number of columns; for example, you might use the text field in a context where it will expand to the maximum size available. In that case, you can use the constructor `JTextField()`, with no parameters. You can also use the following constructors, which specify the initial contents of the text field:

>              JTextField(String contents);
>              JTextField(String contents, int columns);

> `JTextField` has a subclass, `JPasswordField`, which is identical except that it does not reveal the text that it contains. The characters in a `JPasswordField` are all displayed as asterisks (or some other fixed character). A password field is, obviously, designed to let the user enter a password without showing that password on the screen.

> The constructors for a `JTextArea` are

>              JTextArea();
>              JTextArea(int lines, int columns);
>              JTextArea(String contents);
>              JTextArea(String contents, int lines, int columns);

> The parameter `lines` specifies how many lines of text should be visible in the text area. This determines the preferred height of the text area. (The text area can actually contain any number of lines; the text area can be scrolled to reveal lines that are not currently visible.) It is common to use a `JTextArea` as the Center component of a BorderLayout. In that case, it isn't useful to specify the number of lines and columns, since the TextArea will expand to fill all the space available in the center area of the container.

> The `JTextArea` class adds a few useful procedures to those inherited from `JTextComponent`:

>              void append(String text);
>                    // add the specified text at the end of the current
>                    // contents; line breaks can be inserted by using the
>                    // special character \n
>              void insert(String text, int pos);
>                    // insert the text, starting at specified position
>              void replaceRange(String text, int start, int end);
>                    // delete the text from position start to position end
>                    //    and then insert the specified text in its place
>              void setLineWrap(boolean wrap);
>                    // If wrap is true, then a line that is too long to be
>                    // displayed in the text area will be "wrapped" onto
>                    // the next line.  The default value is false.

> A `JTextField` generates an `ActionEvent` when the user presses return while typing in the `JTextField`. The `JTextField` class includes an `addActionListener()` method that can be used to register a listener with a `JTextField`. In the `actionPerformed()` method, the `evt.getActionCommand()` method will return a copy of the text from the `JTextField`. It is also common to use a `JTextField` by checking its contents, when needed, with the `getText()` method. `JTextAreas` do not generate action events.

> A `JTextArea` does not have scroll bars, but scroll bars can be added easily by putting the text area in a scroll pane:

>                 JTextArea inputArea = new JTextArea();
>                 JScrollPane scroller = new JScrollPane( inputArea );

> The scroll bars will appear only when needed. Remember to add the scroll pane, not the text area, to a container.

> ### Other Components

> This section has introduced many, but not all, Swing components. We will look at menus and menu bars in Section 5. Some Swing components will not be covered at all. These include:

> - JList -- displays a list of items to the user, and allows the user to select one or several items from the list.
> - JTable -- displays a two-dimensional table of items, and possibly allows the user to edit them.
> - JTree -- displays hierarchical data in a tree-like structure.
> - JToolBar -- holds a row of tools, such as icons and buttons. The user can drag the tool bar away from the window that contains it, and it becomes a separate, floating tool window.
> - JSplitPane -- a container that displays two components. The user can drag the dividing line between the components to adjust their relative sizes.
> - JTabbedPane -- a container that displays one of a set of panels. The user selects which panel is visible by clicking on a "tab" at the top of the pane.

[ Next Section | Previous Section | Chapter Index | Main Index ]