home | O'Reilly's CD bookshelfs | FreeBSD | Linux | Cisco | Cisco Exam    

Book Home Java Enterprise in a Nutshell Search this book

Chapter 9. The java.awt Package

The java.awt package is the main package of the AWT, or Abstract Windowing Toolkit. It contains classes for graphics, including the Java 2D graphics capabilities introduced in the Java 2 platform, and also defines the basic graphical user interface (GUI) framework for Java. java.awt also includes a number of heavyweight GUI objects, many of which have been superseded by the javax.swing package. java.awt also has a number of important subpackages.

The most important graphics classes in java.awt are Graphics and its Java 2D extension, Graphics2D. These classes represent a drawing surface, maintain a set of drawing attributes, and define methods for drawing and filling lines, shapes, and text. Classes that represent graphics attributes include Color, Font, Paint, Stroke, and Composite. The Image class and Shape interface represent things that you can draw using a Graphics object and the various graphics attributes. Figure 9-1 shows the graphics classes of this package.

figure

Figure 9-1. Graphics classes of the java.awt package

The most important class for GUIs is Component, which represents a single graphical element in a GUI. Container is a kind of component that can contain other components. The LayoutManager interface and its various implementations are used to position components within their containers. Figure 9-2 shows the GUI classes of this package, and Figure 9-3 shows the event, exception, and security classes.

figure

Figure 9-2. GUI classes of the java.awt package

figure

Figure 9-3. Event, exception, and security classes of the java.awt package

See Chapter 4, "Graphics with AWT and Java 2D", for an introduction to Java graphics with AWT and Java 2D and Chapter 2, "Swing and AWTArchitecture", for an introduction to the GUI framework defined by the java.awt package.

ActiveEventJava 1.2
java.awt

This interface is implemented by events that know how to dispatch themselves. When the event dispatch system encounters an ActiveEvent on the event queue, it simply invokes the dispatch() method of the event, instead of attempting to dispatch the event on its own. This interface is implemented by java.awt.event.InvocationEvent, which is used by the invokeLater() and invokeAndWait() methods of EventQueue.

public abstract interface ActiveEvent {
// Public Instance Methods
public abstract void dispatch ();
}

Implementations: java.awt.event.InvocationEvent

AdjustableJava 1.1
java.awtPJ1.1

This interface defines the methods that should be implemented by an object that maintains a user-adjustable numeric value. The adjustable value has specified minimum and maximum values, and it may be incremented or decremented either a unit at a time or a block at a time. An Adjustable object generates an AdjustmentEvent when it is adjusted and maintains a list of AdjustmentListener objects interested in being notified when such an event occurs.

This interface abstracts the essential functionality of the Scrollbar and javax.swing.JScrollBar components.

public abstract interface Adjustable {
// Public Constants
public static final int HORIZONTAL ; =0
public static final int VERTICAL ; =1
// Event Registration Methods (by event name)
public abstract void addAdjustmentListener (java.awt.event.AdjustmentListener l);
public abstract void removeAdjustmentListener (java.awt.event.AdjustmentListener l);
// Property Accessor Methods (by property name)
public abstract int getBlockIncrement ();
public abstract void setBlockIncrement (int b);
public abstract int getMaximum ();
public abstract void setMaximum (int max);
public abstract int getMinimum ();
public abstract void setMinimum (int min);
public abstract int getOrientation ();
public abstract int getUnitIncrement ();
public abstract void setUnitIncrement (int u);
public abstract int getValue ();
public abstract void setValue (int v);
public abstract int getVisibleAmount ();
public abstract void setVisibleAmount (int v);
}

Implementations: Scrollbar, javax.swing.JScrollBar

Passed To: java.awt.event.AdjustmentEvent.AdjustmentEvent(), java.awt.peer.ScrollPanePeer.{setUnitIncrement(), setValue()}

Returned By: ScrollPane.{getHAdjustable(), getVAdjustable()}, java.awt.event.AdjustmentEvent.getAdjustable()

AlphaCompositeJava 1.2
java.awt

This implementation of the Composite interface blends colors according to their levels of alpha transparency. AlphaComposite does not have a public constructor, but you can obtain a shared immutable instance by calling the static getInstance() method, specifying the desired compositing rule (one of the eight integer constants defined by the class), and specifying an alpha value. Alternatively, if you use an alpha value of 1.0, you can simply use one of the eight predefined AlphaComposite constants. Once you have obtained an AlphaComposite object, you use it by passing it to the setComposite() method of a Graphics2D object.

The most common way to use an AlphaComposite object is to specify the SRC_OVER compositing rule and an alpha value greater than 0 but less than 1. This causes the source colors you draw to be given the specified level of alpha transparency, so that they are blended with whatever colors already exist on the screen, making the destination colors appear to show through the translucent source colors. This technique allows you to achieve transparency effects using opaque colors when you are drawing onto a drawing surface, like a screen, that does not have an alpha channel.

The other compositing rules of AlphaComposite are best understood when both the source (your drawing) and the destination (the drawing surface) have alpha channels. For example, you can create translucent Color objects with the four-argument version of the Color() constructor, and you can create an off-screen image with an alpha channel by passing the constant TYPE_INT_ARGB to the java.awt.image.BufferedImage() constructor. (Once your compositing operation has been performed in an off-screen image with an alpha channel, you can view the results by copying the contents of the image to the screen, of course.) When your source and destination have alpha channels built in, you do not usually specify an alpha value for the AlphaComposite itself. If you do, however, the transparency values of the source colors are multiplied by this alpha value.

AlphaComposite supports the following compositing rules:

SRC

Replace the colors of the destination with the colors of the source, ignoring the destination colors and the transparency of the source.

SRC_OVER

Combine the source and destination colors combined based on the transparency of the source, so that the source appears to be drawn over the destination.

DST_OVER

Combine the source and destination colors based on the transparency of the destination, so that the source appears to be drawn underneath the destination.

SRC_IN

Draw the colors of the source using the transparency values of the destination, completely ignoring the colors of the destination.

SRC_OUT

Draw the colors of the source using the inverse transparency values of the destination.

DST_IN

Modify the colors of the destination using the alpha values of the source and ignoring the colors of the source.

DST_OUT

Modify the colors of the destination using the inverted alpha values of the source and ignoring the colors of the source.

CLEAR

Ignore the color and transparency of both the destination and the source. This clears the destination by making it a fully transparent black.

public final class AlphaComposite implements Composite {
// No Constructor
// Public Constants
public static final AlphaComposite Clear ;
public static final int CLEAR ; =1
public static final int DST_IN ; =6
public static final int DST_OUT ; =8
public static final int DST_OVER ; =4
public static final AlphaComposite DstIn ;
public static final AlphaComposite DstOut ;
public static final AlphaComposite DstOver ;
public static final AlphaComposite Src ;
public static final int SRC ; =2
public static final int SRC_IN ; =5
public static final int SRC_OUT ; =7
public static final int SRC_OVER ; =3
public static final AlphaComposite SrcIn ;
public static final AlphaComposite SrcOut ;
public static final AlphaComposite SrcOver ;
// Public Class Methods
public static AlphaComposite getInstance (int rule);
public static AlphaComposite getInstance (int rule, float alpha);
// Public Instance Methods
public float getAlpha ();
public int getRule ();
// Methods Implementing Composite
public CompositeContext createContext (java.awt.image.ColorModel srcColorModel, java.awt.image.ColorModel dstColorModel, RenderingHints hints);
// Public Methods Overriding Object
public boolean equals (Object obj);
public int hashCode ();
}

Hierarchy: Object-->AlphaComposite(Composite)

Returned By: AlphaComposite.getInstance()

Type Of: AlphaComposite.{Clear, DstIn, DstOut, DstOver, Src, SrcIn, SrcOut, SrcOver}

AWTErrorJava 1.0
java.awtserializable error PJ1.1

Signals that an error has occurred in the java.awt package.

public class AWTError extends Error {
// Public Constructors
public AWTError (String msg);
}

Hierarchy: Object-->Throwable(Serializable)-->Error-->AWTError

AWTEventJava 1.1
java.awtserializable event PJ1.1

This abstract class serves as the root event type for all AWT events in Java 1.1 and supersedes the Event class that was used in Java 1.0.

Each AWTEvent has a source object, as all EventObject objects do. You can query the source of an event with the inherited getSource() method. The AWTEvent class adds an event type, or ID, for every AWT event. Use getID() to query the type of an event. Subclasses of AWTEvent define various constants for this type field.

The various _MASK constants are used by applets and custom components that call the enableEvents() method of Component to receive various event types without having to register EventListener objects.

public abstract class AWTEvent extends java.util.EventObject {
// Public Constructors
public AWTEvent (Event event);
public AWTEvent (Object source, int id);
// Public Constants
public static final long ACTION_EVENT_MASK ; =128
public static final long ADJUSTMENT_EVENT_MASK ; =256
public static final long COMPONENT_EVENT_MASK ; =1
public static final long CONTAINER_EVENT_MASK ; =2
public static final long FOCUS_EVENT_MASK ; =4
1.2public static final long INPUT_METHOD_EVENT_MASK ; =2048
public static final long ITEM_EVENT_MASK ; =512
public static final long KEY_EVENT_MASK ; =8
public static final long MOUSE_EVENT_MASK ; =16
public static final long MOUSE_MOTION_EVENT_MASK ; =32
public static final int RESERVED_ID_MAX ; =1999
public static final long TEXT_EVENT_MASK ; =1024
public static final long WINDOW_EVENT_MASK ; =64
// Public Instance Methods
public int getID ();
public String paramString ();
// Public Methods Overriding EventObject
public String toString ();
// Protected Methods Overriding Object
1.2protected void finalize () throws Throwable;
// Protected Instance Methods
protected void consume ();
protected boolean isConsumed ();
// Protected Instance Fields
protected boolean consumed ;
protected int id ;
}

Hierarchy: Object-->java.util.EventObject(Serializable)-->AWTEvent

Subclasses: java.awt.event.ActionEvent, java.awt.event.AdjustmentEvent, java.awt.event.ComponentEvent, java.awt.event.InputMethodEvent, java.awt.event.InvocationEvent, java.awt.event.ItemEvent, java.awt.event.TextEvent, javax.swing.event.AncestorEvent, javax.swing.event.InternalFrameEvent

Passed To: Too many methods to list.

Returned By: Component.coalesceEvents(), EventQueue.{getNextEvent(), peekEvent()}

AWTEventMulticasterJava 1.1
java.awtPJ1.1

AWTEventMulticaster is a convenience class used when writing a custom AWT component. It provides an easy way to maintain a list of AWT EventListener objects and notify the listeners on that list when an event occurs.

AWTEventMulticaster implements each of the event listener interfaces defined in the java.awt.event package, which means that an AWTEventMulticaster object can serve as any desired type of event listener. (It also means that the class defines quite a few methods.) AWTEventMulticaster implements what amounts to a linked list of EventListener objects. When you invoke one of the EventListener methods of an AWTEventMulticaster, it invokes the same method on all of the EventListener objects in the linked list.

Rather than instantiate an AWTEventMulticaster object directly, you use the static add() and remove() methods of the class to add and remove EventListener objects from the linked list. Calling add() or remove() returns an AWTEventMulticaster with the appropriate EventListener object registered or deregistered. Using an AWTEventMulticaster is somewhat non-intuitive, so here is some example code that shows its use:

public class MyList extends Component {   // a class that sends ItemEvents
  // The head of a linked list of AWTEventMulticaster objects
  protected ItemListener listener = null;
  public void addItemListener(ItemListener l) {      // add a listener
    listener = AWTEventMulticaster.add(listener, l);
  }
  public void removeItemListener(ItemListener l) {   // remove a listener
    listener = AWTEventMulticaster.remove(listener, l);
  }
  protected void fireItemEvent(ItemEvent e) {        // notify all listeners
    if (listener != null) listener.itemStateChanged(e);
  }
  // The rest of the class goes here
}
public class AWTEventMulticaster implements java.awt.event.ActionListener, java.awt.event.AdjustmentListener, java.awt.event.ComponentListener, java.awt.event.ContainerListener, java.awt.event.FocusListener, java.awt.event.InputMethodListener, java.awt.event.ItemListener, java.awt.event.KeyListener, java.awt.event.MouseListener, java.awt.event.MouseMotionListener, java.awt.event.TextListener, java.awt.event.WindowListener {
// Protected Constructors
protected AWTEventMulticaster (java.util.EventListener a, java.util.EventListener b);
// Public Class Methods
public static java.awt.event.ActionListener add (java.awt.event.ActionListener a, java.awt.event.ActionListener b);
public static java.awt.event.AdjustmentListener add (java.awt.event.AdjustmentListener a, java.awt.event.AdjustmentListener b);
public static java.awt.event.ComponentListener add (java.awt.event.ComponentListener a, java.awt.event.ComponentListener b);
public static java.awt.event.ContainerListener add (java.awt.event.ContainerListener a, java.awt.event.ContainerListener b);
public static java.awt.event.FocusListener add (java.awt.event.FocusListener a, java.awt.event.FocusListener b);
1.2public static java.awt.event.InputMethodListener add (java.awt.event.InputMethodListener a, java.awt.event.InputMethodListener b);
public static java.awt.event.ItemListener add (java.awt.event.ItemListener a, java.awt.event.ItemListener b);
public static java.awt.event.KeyListener add (java.awt.event.KeyListener a, java.awt.event.KeyListener b);
public static java.awt.event.MouseListener add (java.awt.event.MouseListener a, java.awt.event.MouseListener b);
public static java.awt.event.MouseMotionListener add (java.awt.event.MouseMotionListener a, java.awt.event.MouseMotionListener b);
public static java.awt.event.TextListener add (java.awt.event.TextListener a, java.awt.event.TextListener b);
public static java.awt.event.WindowListener add (java.awt.event.WindowListener a, java.awt.event.WindowListener b);
public static java.awt.event.ActionListener remove (java.awt.event.ActionListener l, java.awt.event.ActionListener oldl);
public static java.awt.event.AdjustmentListener remove (java.awt.event.AdjustmentListener l, java.awt.event.AdjustmentListener oldl);
public static java.awt.event.ComponentListener remove (java.awt.event.ComponentListener l, java.awt.event.ComponentListener oldl);
public static java.awt.event.ContainerListener remove (java.awt.event.ContainerListener l, java.awt.event.ContainerListener oldl);
public static java.awt.event.FocusListener remove (java.awt.event.FocusListener l, java.awt.event.FocusListener oldl);
1.2public static java.awt.event.InputMethodListener remove (java.awt.event.InputMethodListener l, java.awt.event.InputMethodListener oldl);
public static java.awt.event.ItemListener remove (java.awt.event.ItemListener l, java.awt.event.ItemListener oldl);
public static java.awt.event.KeyListener remove (java.awt.event.KeyListener l, java.awt.event.KeyListener oldl);
public static java.awt.event.MouseListener remove (java.awt.event.MouseListener l, java.awt.event.MouseListener oldl);
public static java.awt.event.MouseMotionListener remove (java.awt.event.MouseMotionListener l, java.awt.event.MouseMotionListener oldl);
public static java.awt.event.TextListener remove (java.awt.event.TextListener l, java.awt.event.TextListener oldl);
public static java.awt.event.WindowListener remove (java.awt.event.WindowListener l, java.awt.event.WindowListener oldl);
// Protected Class Methods
protected static java.util.EventListener addInternal (java.util.EventListener a, java.util.EventListener b);
protected static java.util.EventListener removeInternal (java.util.EventListener l, java.util.EventListener oldl);
protected static void save (java.io.ObjectOutputStream s, String k, java.util.EventListener l) throws java.io.IOException;
// Methods Implementing ActionListener
public void actionPerformed (java.awt.event.ActionEvent e);
// Methods Implementing AdjustmentListener
public void adjustmentValueChanged (java.awt.event.AdjustmentEvent e);
// Methods Implementing ComponentListener
public void componentHidden (java.awt.event.ComponentEvent e);
public void componentMoved (java.awt.event.ComponentEvent e);
public void componentResized (java.awt.event.ComponentEvent e);
public void componentShown (java.awt.event.ComponentEvent e);
// Methods Implementing ContainerListener
public void componentAdded (java.awt.event.ContainerEvent e);
public void componentRemoved (java.awt.event.ContainerEvent e);
// Methods Implementing FocusListener
public void focusGained (java.awt.event.FocusEvent e);
public void focusLost (java.awt.event.FocusEvent e);
// Methods Implementing InputMethodListener
1.2public void caretPositionChanged (java.awt.event.InputMethodEvent e);
1.2public void inputMethodTextChanged (java.awt.event.InputMethodEvent e);
// Methods Implementing ItemListener
public void itemStateChanged (java.awt.event.ItemEvent e);
// Methods Implementing KeyListener
public void keyPressed (java.awt.event.KeyEvent e);
public void keyReleased (java.awt.event.KeyEvent e);
public void keyTyped (java.awt.event.KeyEvent e);
// Methods Implementing MouseListener
public void mouseClicked (java.awt.event.MouseEvent e);
public void mouseEntered (java.awt.event.MouseEvent e);
public void mouseExited (java.awt.event.MouseEvent e);
public void mousePressed (java.awt.event.MouseEvent e);
public void mouseReleased (java.awt.event.MouseEvent e);
// Methods Implementing MouseMotionListener
public void mouseDragged (java.awt.event.MouseEvent e);
public void mouseMoved (java.awt.event.MouseEvent e);
// Methods Implementing TextListener
public void textValueChanged (java.awt.event.TextEvent e);
// Methods Implementing WindowListener
public void windowActivated (java.awt.event.WindowEvent e);
public void windowClosed (java.awt.event.WindowEvent e);
public void windowClosing (java.awt.event.WindowEvent e);
public void windowDeactivated (java.awt.event.WindowEvent e);
public void windowDeiconified (java.awt.event.WindowEvent e);
public void windowIconified (java.awt.event.WindowEvent e);
public void windowOpened (java.awt.event.WindowEvent e);
// Protected Instance Methods
protected java.util.EventListener remove (java.util.EventListener oldl);
protected void saveInternal (java.io.ObjectOutputStream s, String k) throws java.io.IOException;
// Protected Instance Fields
protected final java.util.EventListener a ;
protected final java.util.EventListener b ;
}

Hierarchy: Object-->AWTEventMulticaster(java.awt.event.ActionListener(java.util.EventListener),java.awt.event.AdjustmentListener(java.util.EventListener),java.awt.event.ComponentListener(java.util.EventListener),java.awt.event.ContainerListener(java.util.EventListener),java.awt.event.FocusListener(java.util.EventListener),java.awt.event.InputMethodListener(java.util.EventListener),java.awt.event.ItemListener(java.util.EventListener),java.awt.event.KeyListener(java.util.EventListener),java.awt.event.MouseListener(java.util.EventListener),java.awt.event.MouseMotionListener(java.util.EventListener),java.awt.event.TextListener(java.util.EventListener),java.awt.event.WindowListener(java.util.EventListener))

AWTExceptionJava 1.0
java.awtserializable checked PJ1.1

Signals that an exception has occurred in the java.awt package.

public class AWTException extends Exception {
// Public Constructors
public AWTException (String msg);
}

Hierarchy: Object-->Throwable(Serializable)-->Exception-->AWTException

Thrown By: Cursor.getSystemCustomCursor()

AWTPermissionJava 1.2
java.awtserializable permission

This class encapsulates permissions for performing various AWT-related operations; applications do not typically use it. The name, or target, of a permission should be one of the following values: "accessClipboard", "accessEventQueue", "listenToAllAWTEvents", or "showWindowWithoutWarningBanner". Alternatively, a name of "*" implies all of these values. AWTPermission does not use actions, so the actions argument to the constructor should be null.

public final class AWTPermission extends java.security.BasicPermission {
// Public Constructors
public AWTPermission (String name);
public AWTPermission (String name, String actions);
}

Hierarchy: Object-->java.security.Permission(java.security.Guard,Serializable)-->java.security.BasicPermission(Serializable)-->AWTPermission

BasicStrokeJava 1.2
java.awt

This class defines properties that control how lines are drawn. By default, lines are one-pixel wide and solid. To change these attributes, pass a BasicStroke (or another implementation of Stroke) to the setStroke() method of a Graphics2D object. BasicStroke supports the following line attribute properties:

lineWidth

The thickness of the line.

endCap

The end cap style of the line. CAP_BUTT specifies that a line ends exactly at its end points, without caps. CAP_SQUARE causes a line to end with square caps that extend beyond the end points by a distance equal to one-half of the line width. CAP_ROUND specifies that a line ends with round caps with a radius of one-half of the line width.

lineJoin

The join style when two line segments meet at the vertex of a shape. JOIN_MITER specifies that the outside edges of the two line segments are extended as far as necessary until they intersect. JOIN_BEVEL causes the outside corners of the vertex to be joined with a straight line. JOIN_ROUND specifies that the vertex is rounded with a curve that has a radius of half the line width.

miterLimit

The maximum length of the miter used to connect two intersecting line segments. When two lines intersect at an acute angle and the line join style is JOIN_MITER, the length of the miter gets progressively longer as the angle between the lines gets smaller. This property imposes a maximum length on the miter; beyond this length, the miter is squared off.

dashArray

The pattern of dashes and spaces that make up a dashed line. This attribute is an array, where the first element and all the additional odd elements specify the lengths of dashes. The second element and all the additional even elements specify the lengths of the spaces. When the dash pattern is complete, it starts over at the beginning of the array, of course.

dashPhase

The distance into the dash pattern that line drawing begins. Note that this value is not an index into the dash array, but a distance. For example, if you've specified a dash of length 5 followed by a space of length 3 and want to begin your line with the space rather than the dash, you set this property to 5.

See Stroke for a discussion of how line drawing is performed in Java 2D.

public class BasicStroke implements Stroke {
// Public Constructors
public BasicStroke ();
public BasicStroke (float width);
public BasicStroke (float width, int cap, int join);
public BasicStroke (float width, int cap, int join, float miterlimit);
public BasicStroke (float width, int cap, int join, float miterlimit, float[ ] dash, float dash_phase);
// Public Constants
public static final int CAP_BUTT ; =0
public static final int CAP_ROUND ; =1
public static final int CAP_SQUARE ; =2
public static final int JOIN_BEVEL ; =2
public static final int JOIN_MITER ; =0
public static final int JOIN_ROUND ; =1
// Property Accessor Methods (by property name)
public float[ ] getDashArray (); default:null
public float getDashPhase (); default:0.0
public int getEndCap (); default:2
public int getLineJoin (); default:0
public float getLineWidth (); default:1.0
public float getMiterLimit (); default:10.0
// Methods Implementing Stroke
public Shape createStrokedShape (Shape s);
// Public Methods Overriding Object
public boolean equals (Object obj);
public int hashCode ();
}

Hierarchy: Object-->BasicStroke(Stroke)

BorderLayoutJava 1.0
java.awtserializable layout manager PJ1.1

A LayoutManager that arranges components that have been added to their Container (using the Container.add() method) with the names "North", "South", "East", "West", and "Center". These named components are arranged along the edges and in the center of the container. The hgap and vgap arguments to the BorderLayout constructor specify the desired horizontal and vertical spacing between adjacent components.

In Java 1.1, five constants were defined to represent these strings. In Java 1.2, an additional four constants have been added to represent the four sides of the container in a way that is independent of writing direction. For example, BEFORE_LINE_BEGINS is the same as WEST in locales where text is drawn from left to right, but is the same as EAST in locales where text is drawn from right to left.

Note that an application should never call the LayoutManager methods of this class directly; the Container for which the BorderLayout is registered does this.

In Java 1.1, five constants were defined to represent these strings. In Java 1.2, an additional four constants have been added to represent the four sides of the container in a way that is independent of writing direction. For example, BEFORE_LINE_BEGINS is the same as WEST in locales where text is drawn from left to right but is the same as EAST in locales where text is drawn right to left.

public class BorderLayout implements LayoutManager2, Serializable {
// Public Constructors
public BorderLayout ();
public BorderLayout (int hgap, int vgap);
// Public Constants
1.2public static final String AFTER_LAST_LINE ; ="Last"
1.2public static final String AFTER_LINE_ENDS ; ="After"
1.2public static final String BEFORE_FIRST_LINE ; ="First"
1.2public static final String BEFORE_LINE_BEGINS ; ="Before"
1.1public static final String CENTER ; ="Center"
1.1public static final String EAST ; ="East"
1.1public static final String NORTH ; ="North"
1.1public static final String SOUTH ; ="South"
1.1public static final String WEST ; ="West"
// Property Accessor Methods (by property name)
1.1public int getHgap (); default:0
1.1public void setHgap (int hgap);
1.1public int getVgap (); default:0
1.1public void setVgap (int vgap);
// Methods Implementing LayoutManager
public void layoutContainer (Container target);
public Dimension minimumLayoutSize (Container target);
public Dimension preferredLayoutSize (Container target);
public void removeLayoutComponent (Component comp);
// Methods Implementing LayoutManager2
1.1public void addLayoutComponent (Component comp, Object constraints);
1.1public float getLayoutAlignmentX (Container parent);
1.1public float getLayoutAlignmentY (Container parent);
1.1public void invalidateLayout (Container target); empty
1.1public Dimension maximumLayoutSize (Container target);
// Public Methods Overriding Object
public String toString ();
// Deprecated Public Methods
#public void addLayoutComponent (String name, Component comp); Implements:LayoutManager
}

Hierarchy: Object-->BorderLayout(LayoutManager2(LayoutManager),Serializable)

ButtonJava 1.0
java.awtserializable AWT component PJ1.1

This class represents a GUI push button that displays a specified textual label. Use setActionCommand() to specify an identifying string that is included in the ActionEvent events generated by the button.

public class Button extends Component {
// Public Constructors
public Button ();
public Button (String label);
// Event Registration Methods (by event name)
1.1public void addActionListener (java.awt.event.ActionListener l); synchronized
1.1public void removeActionListener (java.awt.event.ActionListener l); synchronized
// Property Accessor Methods (by property name)
1.1public String getActionCommand (); default:""
1.1public void setActionCommand (String command);
public String getLabel (); default:""
public void setLabel (String label);
// Public Methods Overriding Component
public void addNotify ();
// Protected Methods Overriding Component
protected String paramString ();
1.1protected void processEvent (AWTEvent e);
// Protected Instance Methods
1.1protected void processActionEvent (java.awt.event.ActionEvent e);
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Button

Passed To: Toolkit.createButton()

CanvasJava 1.0
java.awtserializable AWT component PJ1.1

A Component that does no default drawing or event handling on its own. You can subclass it to display any kind of drawing or image and handle any kind of user input event. Canvas inherits the event-handling methods of its superclass. In Java 1.1, you can also subclass Component directly to create a lightweight component, instead of having to subclass Canvas.

public class Canvas extends Component {
// Public Constructors
public Canvas ();
1.2public Canvas (GraphicsConfiguration config);
// Public Methods Overriding Component
public void addNotify ();
public void paint (Graphics g);
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Canvas

Passed To: Toolkit.createCanvas()

CardLayoutJava 1.0
java.awtserializable layout manager PJ1.1

A LayoutManager that makes each of the components it manages as large as the container and ensures that only one is visible at a time. The standard LayoutManager methods are called by the Container object and should not be called directly by applet or application code. first(), last(), next(), previous(), and show() make a particular Component in the Container visible. The names with which the components are added to the container are used only by the show() method.

public class CardLayout implements LayoutManager2, Serializable {
// Public Constructors
public CardLayout ();
public CardLayout (int hgap, int vgap);
// Property Accessor Methods (by property name)
1.1public int getHgap (); default:0
1.1public void setHgap (int hgap);
1.1public int getVgap (); default:0
1.1public void setVgap (int vgap);
// Public Instance Methods
public void first (Container parent);
public void last (Container parent);
public void next (Container parent);
public void previous (Container parent);
public void show (Container parent, String name);
// Methods Implementing LayoutManager
public void layoutContainer (Container parent);
public Dimension minimumLayoutSize (Container parent);
public Dimension preferredLayoutSize (Container parent);
public void removeLayoutComponent (Component comp);
// Methods Implementing LayoutManager2
1.1public void addLayoutComponent (Component comp, Object constraints);
1.1public float getLayoutAlignmentX (Container parent);
1.1public float getLayoutAlignmentY (Container parent);
1.1public void invalidateLayout (Container target); empty
1.1public Dimension maximumLayoutSize (Container target);
// Public Methods Overriding Object
public String toString ();
// Deprecated Public Methods
#public void addLayoutComponent (String name, Component comp); Implements:LayoutManager
}

Hierarchy: Object-->CardLayout(LayoutManager2(LayoutManager),Serializable)

CheckboxJava 1.0
java.awtserializable AWT component PJ1.1

This class represents a GUI checkbox with a textual label. The Checkbox maintains a boolean state--whether it is checked or not. The checkbox may optionally be part of a CheckboxGroup that enforces radio button behavior.

public class Checkbox extends Component implements ItemSelectable {
// Public Constructors
public Checkbox ();
public Checkbox (String label);
1.1public Checkbox (String label, boolean state);
public Checkbox (String label, CheckboxGroup group, boolean state);
1.1public Checkbox (String label, boolean state, CheckboxGroup group);
// Event Registration Methods (by event name)
1.1public void addItemListener (java.awt.event.ItemListener l); Implements:ItemSelectable synchronized
1.1public void removeItemListener (java.awt.event.ItemListener l); Implements:ItemSelectable synchronized
// Property Accessor Methods (by property name)
public CheckboxGroup getCheckboxGroup (); default:null
public void setCheckboxGroup (CheckboxGroup g);
public String getLabel (); default:""
public void setLabel (String label);
1.1public Object[ ] getSelectedObjects (); Implements:ItemSelectable default:null
public boolean getState (); default:false
public void setState (boolean state);
// Methods Implementing ItemSelectable
1.1public void addItemListener (java.awt.event.ItemListener l); synchronized
1.1public Object[ ] getSelectedObjects (); default:null
1.1public void removeItemListener (java.awt.event.ItemListener l); synchronized
// Public Methods Overriding Component
public void addNotify ();
// Protected Methods Overriding Component
protected String paramString ();
1.1protected void processEvent (AWTEvent e);
// Protected Instance Methods
1.1protected void processItemEvent (java.awt.event.ItemEvent e);
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Checkbox(ItemSelectable)

Passed To: CheckboxGroup.{setCurrent(), setSelectedCheckbox()}, Toolkit.createCheckbox()

Returned By: CheckboxGroup.{getCurrent(), getSelectedCheckbox()}

CheckboxGroupJava 1.0
java.awtserializable PJ1.1

A CheckboxGroup object enforces mutual exclusion (also known as radio button behavior) among any number of Checkbox buttons. A Checkbox component can specify a CheckboxGroup object when created or with its setCheckboxGroup() method. If a Checkbox within a CheckboxGroup object is selected, the CheckboxGroup ensures that the previously selected Checkbox becomes unselected.

public class CheckboxGroup implements Serializable {
// Public Constructors
public CheckboxGroup ();
// Property Accessor Methods (by property name)
1.1public Checkbox getSelectedCheckbox (); default:null
1.1public void setSelectedCheckbox (Checkbox box);
// Public Methods Overriding Object
public String toString ();
// Deprecated Public Methods
#public Checkbox getCurrent (); default:null
#public void setCurrent (Checkbox box); synchronized
}

Hierarchy: Object-->CheckboxGroup(Serializable)

Passed To: Checkbox.{Checkbox(), setCheckboxGroup()}, java.awt.peer.CheckboxPeer.setCheckboxGroup()

Returned By: Checkbox.getCheckboxGroup()

CheckboxMenuItemJava 1.0
java.awtserializable AWT component PJ1.1(opt)

This class represents a checkbox with a textual label in a GUI menu. It maintains a boolean state--whether it is checked or not. See also MenuItem.

public class CheckboxMenuItem extends MenuItem implements ItemSelectable {
// Public Constructors
1.1public CheckboxMenuItem ();
public CheckboxMenuItem (String label);
1.1public CheckboxMenuItem (String label, boolean state);
// Event Registration Methods (by event name)
1.1public void addItemListener (java.awt.event.ItemListener l); Implements:ItemSelectable synchronized
1.1public void removeItemListener (java.awt.event.ItemListener l); Implements:ItemSelectable synchronized
// Property Accessor Methods (by property name)
1.1public Object[ ] getSelectedObjects (); Implements:ItemSelectable synchronized default:null
public boolean getState (); default:false
public void setState (boolean b); synchronized
// Methods Implementing ItemSelectable
1.1public void addItemListener (java.awt.event.ItemListener l); synchronized
1.1public Object[ ] getSelectedObjects (); synchronized default:null
1.1public void removeItemListener (java.awt.event.ItemListener l); synchronized
// Public Methods Overriding MenuItem
public void addNotify ();
public String paramString ();
// Protected Methods Overriding MenuItem
1.1protected void processEvent (AWTEvent e);
// Protected Instance Methods
1.1protected void processItemEvent (java.awt.event.ItemEvent e);
}

Hierarchy: Object-->MenuComponent(Serializable)-->MenuItem-->CheckboxMenuItem(ItemSelectable)

Passed To: Toolkit.createCheckboxMenuItem()

ChoiceJava 1.0
java.awtserializable AWT component PJ1.1

This class represents an option menu or dropdown list. The addItem() method adds an item with the specified label to a Choice menu. getSelectedIndex() returns the numerical position of the selected item in the menu, while getSelectedItem() returns the label of the selected item.

public class Choice extends Component implements ItemSelectable {
// Public Constructors
public Choice ();
// Event Registration Methods (by event name)
1.1public void addItemListener (java.awt.event.ItemListener l); Implements:ItemSelectable synchronized
1.1public void removeItemListener (java.awt.event.ItemListener l); Implements:ItemSelectable synchronized
// Property Accessor Methods (by property name)
1.1public int getItemCount (); default:0
public int getSelectedIndex (); default:-1
public String getSelectedItem (); synchronized default:null
1.1public Object[ ] getSelectedObjects (); Implements:ItemSelectable synchronized default:null
// Public Instance Methods
1.1public void add (String item);
public void addItem (String item);
public String getItem (int index);
1.1public void insert (String item, int index);
1.1public void remove (String item);
1.1public void remove (int position);
1.1public void removeAll ();
public void select (String str); synchronized
public void select (int pos); synchronized
// Methods Implementing ItemSelectable
1.1public void addItemListener (java.awt.event.ItemListener l); synchronized
1.1public Object[ ] getSelectedObjects (); synchronized default:null
1.1public void removeItemListener (java.awt.event.ItemListener l); synchronized
// Public Methods Overriding Component
public void addNotify ();
// Protected Methods Overriding Component
protected String paramString ();
1.1protected void processEvent (AWTEvent e);
// Protected Instance Methods
1.1protected void processItemEvent (java.awt.event.ItemEvent e);
// Deprecated Public Methods
#public int countItems ();
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Choice(ItemSelectable)

Passed To: Toolkit.createChoice()

ColorJava 1.0
java.awtserializable PJ1.1

This class describes a color in terms of the individual components of that color. These components are either float values that range between 0 and 1 or 8-bit integers that range from 0 to 255. Prior to Java 1.2, only the RGB (red, green, blue) color space was supported. With the advent of Java 2D, the Color class has been extended to support alpha transparency and arbitrary java.awt.color.ColorSpace objects. In addition, the Java 1.2 Color class implements the Paint interface and is used to perform Java 2D drawing and filling operations that use solid colors.

Color objects can be obtained in a number of ways. The Color() constructors allow color components to be directly specified. The class also defines several color constants. The SystemColor subclass defines other useful Color constants that are related to standard colors used on the system desktop. The static methods HSBtoRGB() and RGBtoHSB() convert between the RGB color space and the HSB (hue, saturation, brightness) color space and can be used to create colors specified using the more intuitive HSB color components. brighter() and darker() return variants on the current color and are useful for creating shading effects.

An RGB color can be expressed as a 24-bit number, where the top 8 bits specifies the red component, the middle 8 bits specifies the green component, and the low 8 bits specifies the blue component. Colors are often represented using a string representation of this 24-bit number. It is particularly common to use a hexadecimal representation for a color, since it keeps the red, green, and blue components distinct. For example, the string "0xFF0000" represents a bright red color: the red component has a value of 255, and both the green and blue components are 0. The static decode() method converts color strings encoded in this way to Color objects. Each getColor() method looks up the specified key in the system properties list and then decodes the value and returns the resulting Color or the specified default color, if no color is found in the properties list.

getRGB() returns the red, green, and blue components of a color as a 24-bit number. getRed(), getBlue(), getGreen(), and getAlpha() return the individual components of a color as integers. getComponents() is a generalized method that returns the color and transparency components of a color in a float array, using an optionally specified ColorSpace. getColorComponents() is similar but returns only the color components, not the transparency component. getRGBComponents() returns the color and alpha components as float values using the RGB color space. getRGBColorComponents() does the same but does not return the alpha component. Each of these methods either fills in the elements of a float[] array you provide or allocates one of its own, if you pass null.

public class Color implements Paint, Serializable {
// Public Constructors
public Color (int rgb);
1.2public Color (int rgba, boolean hasalpha);
1.2public Color (java.awt.color.ColorSpace cspace, float[ ] components, float alpha);
public Color (float r, float g, float b);
public Color (int r, int g, int b);
1.2public Color (int r, int g, int b, int a);
1.2public Color (float r, float g, float b, float a);
// Public Constants
public static final Color black ;
public static final Color blue ;
public static final Color cyan ;
public static final Color darkGray ;
public static final Color gray ;
public static final Color green ;
public static final Color lightGray ;
public static final Color magenta ;
public static final Color orange ;
public static final Color pink ;
public static final Color red ;
public static final Color white ;
public static final Color yellow ;
// Public Class Methods
1.1public static Color decode (String nm) throws NumberFormatException;
public static Color getColor (String nm);
public static Color getColor (String nm, Color v);
public static Color getColor (String nm, int v);
public static Color getHSBColor (float h, float s, float b);
public static int HSBtoRGB (float hue, float saturation, float brightness);
public static float[ ] RGBtoHSB (int r, int g, int b, float[ ] hsbvals);
// Property Accessor Methods (by property name)
1.2public int getAlpha ();
public int getBlue ();
1.2public java.awt.color.ColorSpace getColorSpace ();
public int getGreen ();
public int getRed ();
public int getRGB ();
1.2public int getTransparency (); Implements:Transparency
// Public Instance Methods
public Color brighter ();
public Color darker ();
1.2public float[ ] getColorComponents (float[ ] compArray);
1.2public float[ ] getColorComponents (java.awt.color.ColorSpace cspace, float[ ] compArray);
1.2public float[ ] getComponents (float[ ] compArray);
1.2public float[ ] getComponents (java.awt.color.ColorSpace cspace, float[ ] compArray);
1.2public float[ ] getRGBColorComponents (float[ ] compArray);
1.2public float[ ] getRGBComponents (float[ ] compArray);
// Methods Implementing Paint
1.2public PaintContext createContext (java.awt.image.ColorModel cm, Rectangle r, java.awt.geom.Rectangle2D r2d, java.awt.geom.AffineTransform xform, RenderingHints hints); synchronized
// Methods Implementing Transparency
1.2public int getTransparency ();
// Public Methods Overriding Object
public boolean equals (Object obj);
public int hashCode ();
public String toString ();
}

Hierarchy: Object-->Color(Paint(Transparency),Serializable)

Subclasses: SystemColor, javax.swing.plaf.ColorUIResource

Passed To: Too many methods to list.

Returned By: Too many methods to list.

Type Of: Too many fields to list.

ComponentJava 1.0
java.awtserializable AWT component PJ1.1(mod)

Component is the superclass of all GUI components (except menu components) in the java.awt package. You cannot instantiate a Component directly; you must use a subclass.

Component defines many methods. Some of these are intended to be implemented by subclasses, including some that are for handling events. Other methods are used internally by the AWT. And many are useful utility methods for working with GUI components. getParent() returns the Container that contains a Component. setBackground(), setForeground(), and setFont() set the specified display attributes of a component. hide(), show(), enable(), and disable() perform the specified actions for a component. createImage() creates either an Image object from a specified ImageProducer or an off-screen image that can be drawn into and used for double-buffering during animation. Component also has quite a few deprecated methods, as a result of the Java 1.1 event model and the introduction of the JavaBeans method-naming conventions. The class defines numerous methods for handling many types of events, using the 1.0 and 1.1 event models, in both their high-level and low-level forms.

In Personal Java environments, the setCursor() method can be ignored. Also, the Personal Java API supports the isDoubleBuffered() method, even though it is not part of the Java 1.1 API from which Personal Java is derived.

public abstract class Component implements java.awt.image.ImageObserver, MenuContainer, Serializable {
// Protected Constructors
protected Component ();
// Public Constants
1.1public static final float BOTTOM_ALIGNMENT ; =1.0
1.1public static final float CENTER_ALIGNMENT ; =0.5
1.1public static final float LEFT_ALIGNMENT ; =0.0
1.1public static final float RIGHT_ALIGNMENT ; =1.0
1.1public static final float TOP_ALIGNMENT ; =0.0
// Event Registration Methods (by event name)
1.1public void addComponentListener (java.awt.event.ComponentListener l); synchronized
1.1public void removeComponentListener (java.awt.event.ComponentListener l); synchronized
1.1public void addFocusListener (java.awt.event.FocusListener l); synchronized
1.1public void removeFocusListener (java.awt.event.FocusListener l); synchronized
1.2public void addInputMethodListener (java.awt.event.InputMethodListener l); synchronized
1.2public void removeInputMethodListener (java.awt.event.InputMethodListener l); synchronized
1.1public void addKeyListener (java.awt.event.KeyListener l); synchronized
1.1public void removeKeyListener (java.awt.event.KeyListener l); synchronized
1.1public void addMouseListener (java.awt.event.MouseListener l); synchronized
1.1public void removeMouseListener (java.awt.event.MouseListener l); synchronized
1.1public void addMouseMotionListener (java.awt.event.MouseMotionListener l); synchronized
1.1public void removeMouseMotionListener (java.awt.event.MouseMotionListener l); synchronized
1.2public void addPropertyChangeListener (java.beans.PropertyChangeListener listener); synchronized
1.2public void removePropertyChangeListener (java.beans.PropertyChangeListener listener); synchronized
// Property Accessor Methods (by property name)
1.1public float getAlignmentX ();
1.1public float getAlignmentY ();
public Color getBackground ();
public void setBackground (Color c);
1.1public Rectangle getBounds ();
1.2public Rectangle getBounds (Rectangle rv);
1.1public void setBounds (Rectangle r);
1.1public void setBounds (int x, int y, int width, int height);
public java.awt.image.ColorModel getColorModel ();
1.2public ComponentOrientation getComponentOrientation ();
1.2public void setComponentOrientation (ComponentOrientation o);
1.1public Cursor getCursor ();
1.1public void setCursor (Cursor cursor); synchronized
1.2public boolean isDisplayable ();
1.2public boolean isDoubleBuffered (); constant
1.2public java.awt.dnd.DropTarget getDropTarget (); synchronized
1.2public void setDropTarget (java.awt.dnd.DropTarget dt); synchronized
public boolean isEnabled ();
1.1public void setEnabled (boolean b);
1.1public boolean isFocusTraversable ();
public Font getFont (); Implements:MenuContainer
public void setFont (Font f);
public Color getForeground ();
public void setForeground (Color c);
public Graphics getGraphics ();
1.2public int getHeight ();
1.2public java.awt.im.InputContext getInputContext ();
1.2public java.awt.im.InputMethodRequests getInputMethodRequests (); constant
1.2public boolean isLightweight ();
1.1public java.util.Locale getLocale ();
1.1public void setLocale (java.util.Locale l);
1.1public Point getLocation ();
1.2public Point getLocation (Point rv);
1.1public void setLocation (Point p);
1.1public void setLocation (int x, int y);
1.1public Point getLocationOnScreen ();
1.1public Dimension getMaximumSize ();
1.1public Dimension getMinimumSize ();
1.1public String getName ();
1.1public void setName (String name);
1.2public boolean isOpaque ();
public Container getParent ();
1.1public Dimension getPreferredSize ();
public boolean isShowing ();
1.1public Dimension getSize ();
1.2public Dimension getSize (Dimension rv);
1.1public void setSize (Dimension d);
1.1public void setSize (int width, int height);
public Toolkit getToolkit ();
1.1public final Object getTreeLock ();
public boolean isValid ();
public boolean isVisible ();
1.1public void setVisible (boolean b);
1.2public int getWidth ();
1.2public int getX ();
1.2public int getY ();
// Public Instance Methods
1.1public void add (PopupMenu popup); synchronized
public void addNotify ();
1.2public void addPropertyChangeListener (String propertyName, java.beans.PropertyChangeListener listener); synchronized
public int checkImage (Image image, java.awt.image.ImageObserver observer);
public int checkImage (Image image, int width, int height, java.awt.image.ImageObserver observer);
1.1public boolean contains (Point p);
1.1public boolean contains (int x, int y);
public Image createImage (java.awt.image.ImageProducer producer);
public Image createImage (int width, int height);
1.1public final void dispatchEvent (AWTEvent e);
1.1public void doLayout ();
1.2public void enableInputMethods (boolean enable);
1.1public Component getComponentAt (Point p);
1.1public Component getComponentAt (int x, int y);
public FontMetrics getFontMetrics (Font font);
1.2public boolean hasFocus ();
public void invalidate ();
public void list ();
1.1public void list (java.io.PrintWriter out);
public void list (java.io.PrintStream out);
1.1public void list (java.io.PrintWriter out, int indent);
public void list (java.io.PrintStream out, int indent);
public void paint (Graphics g); empty
public void paintAll (Graphics g);
public boolean prepareImage (Image image, java.awt.image.ImageObserver observer);
public boolean prepareImage (Image image, int width, int height, java.awt.image.ImageObserver observer);
public void print (Graphics g);
public void printAll (Graphics g);
public void removeNotify ();
1.2public void removePropertyChangeListener (String propertyName, java.beans.PropertyChangeListener listener); synchronized
public void repaint ();
public void repaint (long tm);
public void repaint (int x, int y, int width, int height);
public void repaint (long tm, int x, int y, int width, int height);
public void requestFocus ();
1.1public void transferFocus ();
public void update (Graphics g);
public void validate ();
// Methods Implementing ImageObserver
public boolean imageUpdate (Image img, int flags, int x, int y, int w, int h);
// Methods Implementing MenuContainer
public Font getFont ();
1.1public void remove (MenuComponent popup); synchronized
// Public Methods Overriding Object
public String toString ();
// Protected Instance Methods
1.2protected AWTEvent coalesceEvents (AWTEvent existingEvent, AWTEvent newEvent);
1.1protected final void disableEvents (long eventsToDisable);
1.1protected final void enableEvents (long eventsToEnable);
1.2protected void firePropertyChange (String propertyName, Object oldValue, Object newValue);
protected String paramString ();
1.1protected void processComponentEvent (java.awt.event.ComponentEvent e);
1.1protected void processEvent (AWTEvent e);
1.1protected void processFocusEvent (java.awt.event.FocusEvent e);
1.2protected void processInputMethodEvent (java.awt.event.InputMethodEvent e);
1.1protected void processKeyEvent (java.awt.event.KeyEvent e);
1.1protected void processMouseEvent (java.awt.event.MouseEvent e);
1.1protected void processMouseMotionEvent (java.awt.event.MouseEvent e);
// Deprecated Public Methods
#public boolean action (Event evt, Object what); constant
#public Rectangle bounds ();
#public void deliverEvent (Event e);
#public void disable ();
#public void enable ();
#public void enable (boolean b);
#public java.awt.peer.ComponentPeer getPeer ();
#public boolean gotFocus (Event evt, Object what); constant
#public boolean handleEvent (Event evt);
#public void hide ();
#public boolean inside (int x, int y);
#public boolean keyDown (Event evt, int key); constant
#public boolean keyUp (Event evt, int key); constant
#public void layout (); empty
#public Component locate (int x, int y);
#public Point location ();
#public boolean lostFocus (Event evt, Object what); constant
#public Dimension minimumSize ();
#public boolean mouseDown (Event evt, int x, int y); constant
#public boolean mouseDrag (Event evt, int x, int y); constant
#public boolean mouseEnter (Event evt, int x, int y); constant
#public boolean mouseExit (Event evt, int x, int y); constant
#public boolean mouseMove (Event evt, int x, int y); constant
#public boolean mouseUp (Event evt, int x, int y); constant
#public void move (int x, int y);
#public void nextFocus ();
#public boolean postEvent (Event e); Implements:MenuContainer
#public Dimension preferredSize ();
#public void reshape (int x, int y, int width, int height);
#public void resize (Dimension d);
#public void resize (int width, int height);
#public void show ();
#public void show (boolean b);
#public Dimension size ();
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)

Subclasses: Button, Canvas, Checkbox, Choice, Container, Label, java.awt.List, Scrollbar, TextComponent, javax.swing.Box.Filler

Passed To: Too many methods to list.

Returned By: Too many methods to list.

Type Of: Too many fields to list.

ComponentOrientationJava 1.2
java.awtserializable

This class encapsulates differences in the way characters in GUI components are arranged into lines and the way lines are grouped into blocks. In western languages like English, characters are arranged left to right and lines are arranged top to bottom, but this is not true throughout the world. In Hebrew, for example, characters are arranged from right to left, and in traditional Chinese, characters are arranged from top to bottom.

The isHorizontal() and isLeftToRight() methods specify the necessary orientation information. The class defines two constants for commonly used orientation types. Authors of AWT, Swing, and JavaBeans components may want to take orientation into account when developing their components (see the getComponentOrientation() method of Component). Applications that use these components should typically not have to worry about this class.

You can query the default orientation for a given java.util.Locale by calling the static getOrientation() method. Set the componentOrientation property of all components in a window by passing a ResourceBundle object to the applyResourceBundle() method of a Window. This looks up the "Orientation" resource in the bundle and, if it is not found, uses the default orientation for the locale of the bundle.

public final class ComponentOrientation implements Serializable {
// No Constructor
// Public Constants
public static final ComponentOrientation LEFT_TO_RIGHT ;
public static final ComponentOrientation RIGHT_TO_LEFT ;
public static final ComponentOrientation UNKNOWN ;
// Public Class Methods
public static ComponentOrientation getOrientation (java.util.ResourceBundle bdl);
public static ComponentOrientation getOrientation (java.util.Locale locale);
// Public Instance Methods
public boolean isHorizontal ();
public boolean isLeftToRight ();
}

Hierarchy: Object-->ComponentOrientation(Serializable)

Passed To: Component.setComponentOrientation()

Returned By: Component.getComponentOrientation(), ComponentOrientation.getOrientation()

Type Of: ComponentOrientation.{LEFT_TO_RIGHT, RIGHT_TO_LEFT, UNKNOWN}

CompositeJava 1.2
java.awt

This interface defines how two colors are combined to yield a composite color. When Java 2D performs a drawing operation, it uses a Composite object to combine the colors it wants to draw with the colors that already exist on the screen or in the off-screen image.

The default compositing operation is to draw the new color on top of the color already on the screen. If the new color is fully opaque, the existing color is ignored. If the new color is partially transparent, however, it is combined with the color already on the screen to produce a composite color. To specify a different compositing operation, pass a Composite object to the setComposite() method of a Graphics2D object.

AlphaComposite is a commonly used implementation of Composite; it combines colors in a number of possible ways based on their alpha-transparency levels. AlphaComposite is suitable for most uses; very few applications should have to define a custom implementation of Composite.

Note that the only method of Composite, createContext(), does not perform compositing itself. Instead, it returns a CompositeContext object suitable for compositing colors encoded using the specified color models and rendering hints. It is the CompositeContext object that performs the actual work of combining colors.

public abstract interface Composite {
// Public Instance Methods
public abstract CompositeContext createContext (java.awt.image.ColorModel srcColorModel, java.awt.image.ColorModel dstColorModel, RenderingHints hints);
}

Implementations: AlphaComposite

Passed To: Graphics2D.setComposite()

Returned By: Graphics2D.getComposite()

CompositeContextJava 1.2
java.awt

This interface defines the methods that do the actual work of compositing colors. The CompositeContext interface is used internally by Java 2D; applications never need to call CompositeContext methods. And only applications that implement a custom Composite class need to implement this interface.

A CompositeContext object holds the state for a particular compositing operation (in multi-threaded programs, there may be several compositing operations in progress at once). A Graphics2D object creates CompositeContext objects as needed by calling the createContext() method of its Composite object.

Once a CompositeContext object has been created, its compose() method is responsible for combining the colors of the first two Raster objects passed to it and storing the resulting colors in the specified WriteableRaster. (This WriteableRaster is usually the same object as one of the first two arguments.) The dispose() method should free any resources held by the CompositeContext. It is called when the Graphics2D no longer requires the CompositeContext.

public abstract interface CompositeContext {
// Public Instance Methods
public abstract void compose (java.awt.image.Raster src, java.awt.image.Raster dstIn, java.awt.image.WritableRaster dstOut);
public abstract void dispose ();
}

Returned By: AlphaComposite.createContext(), Composite.createContext()

ContainerJava 1.0
java.awtserializable AWT component PJ1.1

This class implements a component that can contain other components. You cannot instantiate Container directly but must use one of its subclasses, such as Panel, Frame, or Dialog. Once a Container is created, you can set its LayoutManager with setLayout(), add components to it with add(), and remove them with remove(). getComponents() returns an array of the components contained in a Container. locate() determines within which contained component a specified point falls. list() produces helpful debugging output.

public class Container extends Component {
// Public Constructors
public Container ();
// Event Registration Methods (by event name)
1.1public void addContainerListener (java.awt.event.ContainerListener l); synchronized
1.1public void removeContainerListener (java.awt.event.ContainerListener l); synchronized
// Property Accessor Methods (by property name)
1.1public float getAlignmentX (); Overrides:Component default:0.5
1.1public float getAlignmentY (); Overrides:Component default:0.5
1.1public int getComponentCount (); default:0
public Component[ ] getComponents ();
1.2public void setCursor (Cursor cursor); Overrides:Component synchronized
1.2public void setFont (Font f); Overrides:Component
1.1public Insets getInsets ();
public LayoutManager getLayout (); default:null
public void setLayout (LayoutManager mgr);
1.1public Dimension getMaximumSize (); Overrides:Component
1.1public Dimension getMinimumSize (); Overrides:Component
1.1public Dimension getPreferredSize (); Overrides:Component
// Public Instance Methods
public Component add (Component comp);
1.1public void add (Component comp, Object constraints);
public Component add (String name, Component comp);
public Component add (Component comp, int index);
1.1public void add (Component comp, Object constraints, int index);
1.2public Component findComponentAt (Point p);
1.2public Component findComponentAt (int x, int y);
public Component getComponent (int n);
1.1public boolean isAncestorOf (Component c);
public void paintComponents (Graphics g);
public void printComponents (Graphics g);
public void remove (Component comp);
1.1public void remove (int index);
public void removeAll ();
// Public Methods Overriding Component
public void addNotify ();
1.1public void doLayout ();
1.1public Component getComponentAt (Point p);
1.1public Component getComponentAt (int x, int y);
1.1public void invalidate ();
1.1public void list (java.io.PrintWriter out, int indent);
public void list (java.io.PrintStream out, int indent);
1.1public void paint (Graphics g);
1.1public void print (Graphics g);
public void removeNotify ();
1.1public void update (Graphics g);
public void validate ();
// Protected Methods Overriding Component
protected String paramString ();
1.1protected void processEvent (AWTEvent e);
// Protected Instance Methods
1.1protected void addImpl (Component comp, Object constraints, int index);
1.1protected void processContainerEvent (java.awt.event.ContainerEvent e);
1.1protected void validateTree ();
// Deprecated Public Methods
#public int countComponents ();
#public void deliverEvent (Event e); Overrides:Component
#public Insets insets ();
#public void layout (); Overrides:Component
#public Component locate (int x, int y); Overrides:Component
#public Dimension minimumSize (); Overrides:Component
#public Dimension preferredSize (); Overrides:Component
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Container

Subclasses: Panel, ScrollPane, Window, javax.swing.Box, javax.swing.CellRendererPane, javax.swing.JComponent, javax.swing.tree.DefaultTreeCellEditor.EditorContainer

Passed To: Too many methods to list.

Returned By: Too many methods to list.

Type Of: javax.swing.JRootPane.contentPane, javax.swing.tree.DefaultTreeCellEditor.editingContainer

CursorJava 1.1
java.awtserializable PJ1.1

This class represents a mouse cursor. It defines a number of constants, which represent the 14 predefined cursors provided by Java 1.0 and Java 1.1. You can pass one of these constants to the constructor to create a cursor of the specified type. Call getType() to determine the type of an existing Cursor object. Since there are only a fixed number of available cursors, the static method getPredefinedCursor() is more efficient than the Cursor() constructor--it maintains a cache of Cursor objects that can be reused. The static getDefaultCursor() method returns the default cursor for the underlying system.

In Java 1.2, the Cursor class has a new getSystemCustomCursor() method that returns a named cursor defined by a system administrator in a systemwide cursors.properties file. Since there is no way to query the list of system-specific custom cursors, however, this method is rarely used. Instead, you can create your own custom cursor by calling the createCustomCursor() method of the Toolkit object. You should first check whether custom cursors are supported by calling the getBestCursorSize() method of Toolkit. If this method indicates a width or height of 0, custom cursors are not supported (by either the Java implementation or the underlying windowing system).

public class Cursor implements Serializable {
// Public Constructors
public Cursor (int type);
// Protected Constructors
1.2protected Cursor (String name);
// Public Constants
public static final int CROSSHAIR_CURSOR ; =1
1.2public static final int CUSTOM_CURSOR ; =-1
public static final int DEFAULT_CURSOR ; =0
public static final int E_RESIZE_CURSOR ; =11
public static final int HAND_CURSOR ; =12
public static final int MOVE_CURSOR ; =13
public static final int N_RESIZE_CURSOR ; =8
public static final int NE_RESIZE_CURSOR ; =7
public static final int NW_RESIZE_CURSOR ; =6
public static final int S_RESIZE_CURSOR ; =9
public static final int SE_RESIZE_CURSOR ; =5
public static final int SW_RESIZE_CURSOR ; =4
public static final int TEXT_CURSOR ; =2
public static final int W_RESIZE_CURSOR ; =10
public static final int WAIT_CURSOR ; =3
// Public Class Methods
public static Cursor getDefaultCursor ();
public static Cursor getPredefinedCursor (int type);
1.2public static Cursor getSystemCustomCursor (String name) throws AWTException;
// Public Instance Methods
1.2public String getName ();
public int getType ();
// Public Methods Overriding Object
1.2public String toString ();
// Protected Class Fields
protected static Cursor[ ] predefined ;
// Protected Instance Fields
1.2protected String name ;
}

Hierarchy: Object-->Cursor(Serializable)

Passed To: Too many methods to list.

Returned By: Too many methods to list.

Type Of: Cursor.predefined, java.awt.dnd.DragSource.{DefaultCopyDrop, DefaultCopyNoDrop, DefaultLinkDrop, DefaultLinkNoDrop, DefaultMoveDrop, DefaultMoveNoDrop}

DialogJava 1.0
java.awtserializable AWT component PJ1.1(mod)

This class represents a dialog box window. A Dialog can be modal, so that it blocks user input to all other windows until dismissed. It is optional whether a dialog has a title and whether it is resizable. A Dialog object is a Container, so you can add Component objects to it in the normal way with the add() method. The default LayoutManager for Dialog is BorderLayout. You can specify a different LayoutManager object with setLayout(). Call the pack() method of Window to initiate layout management of the dialog and set its initial size appropriately. Call show() to pop a dialog up and setVisible(false) to pop it down. For modal dialogs, show() blocks until the dialog is dismissed. Event handling continues while show() is blocked, using a new event dispatcher thread. In Java 1.0, show() is inherited from Window. Call the Window.dispose() method when the Dialog is no longer needed so that its window system resources may be reused.

In Personal Java environments, support for modeless dialogs is optional, and the Dialog() constructors can throw an exception if you attempt to create a modeless dialog. Also, the setResizable() method is optional, and calls to it can be ignored.

public class Dialog extends Window {
// Public Constructors
1.1public Dialog (Frame owner);
1.2public Dialog (Dialog owner);
1.2public Dialog (Dialog owner, String title);
1.1public Dialog (Frame owner, String title);
public Dialog (Frame owner, boolean modal);
public Dialog (Frame owner, String title, boolean modal);
1.2public Dialog (Dialog owner, String title, boolean modal);
// Property Accessor Methods (by property name)
public boolean isModal ();
1.1public void setModal (boolean b);
public boolean isResizable ();
public void setResizable (boolean resizable);
public String getTitle ();
public void setTitle (String title); synchronized
// Public Methods Overriding Window
public void addNotify ();
1.2public void dispose ();
1.2public void hide ();
1.1public void show ();
// Protected Methods Overriding Container
protected String paramString ();
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Container-->Window-->Dialog

Subclasses: FileDialog, javax.swing.JDialog

Passed To: Dialog.Dialog(), Toolkit.createDialog(), javax.swing.JDialog.JDialog()

DimensionJava 1.0
java.awtcloneable serializable PJ1.1

This class contains two integer fields that describe a width and a height of something. The fields are public and can be manipulated directly.

In Java 1.0 and Java 1.1, Dimension is a subclass of Object. In Java 1.2, with the introduction of Java 2D, it has become a concrete subclass of java.awt.geom.Dimension2D. Contrast Dimension with Dimension2D,which represents the width and height with double values.

public class Dimension extends java.awt.geom.Dimension2D implements Serializable {
// Public Constructors
public Dimension ();
public Dimension (Dimension d);
public Dimension (int width, int height);
// Public Instance Methods
1.1public Dimension getSize ();
1.1public void setSize (Dimension d);
1.1public void setSize (int width, int height);
// Public Methods Overriding Dimension2D
1.2public double getHeight (); default:0.0
1.2public double getWidth (); default:0.0
1.2public void setSize (double width, double height);
// Public Methods Overriding Object
1.1public boolean equals (Object obj);
public String toString ();
// Public Instance Fields
public int height ;
public int width ;
}

Hierarchy: Object-->java.awt.geom.Dimension2D(Cloneable)-->Dimension(Serializable)

Subclasses: javax.swing.plaf.DimensionUIResource

Passed To: Too many methods to list.

Returned By: Too many methods to list.

Type Of: javax.swing.JTable.preferredViewportSize

EventJava 1.0
java.awtserializable PJ1.1

This class contains public instance variables that describe some kind of GUI event. In Java 1.1, this class has been superseded by AWTEvent and the java.awt.event package.

The class contains a large number of constants. Some of the constants specify the event type and are values for the id variable. Other constants are values for keys, such as the function keys, that do not have ASCII (Latin-1) values and are set on the key field. Other constants are mask values that are ORed into the modifiers field to describe the state of the modifier keys on the keyboard. The target field is very important--it is the object for which the event occurred. The when field specifies when the event occurred. The x and y fields specify the mouse coordinates at which it occurred. Finally, the arg field is a value specific to the type of the event. Not all fields have valid values for all types of events.

public class Event implements Serializable {
// Public Constructors
public Event (Object target, int id, Object arg);
public Event (Object target, long when, int id, int x, int y, int key, int modifiers);
public Event (Object target, long when, int id, int x, int y, int key, int modifiers, Object arg);
// Public Constants
public static final int ACTION_EVENT ; =1001
public static final int ALT_MASK ; =8
1.1public static final int BACK_SPACE ; =8
1.1public static final int CAPS_LOCK ; =1022
public static final int CTRL_MASK ; =2
1.1public static final int DELETE ; =127
public static final int DOWN ; =1005
public static final int END ; =1001
1.1public static final int ENTER ; =10
1.1public static final int ESCAPE ; =27
public static final int F1 ; =1008
public static final int F10 ; =1017
public static final int F11 ; =1018
public static final int F12 ; =1019
public static final int F2 ; =1009
public static final int F3 ; =1010
public static final int F4 ; =1011
public static final int F5 ; =1012
public static final int F6 ; =1013
public static final int F7 ; =1014
public static final int F8 ; =1015
public static final int F9 ; =1016
public static final int GOT_FOCUS ; =1004
public static final int HOME ; =1000
1.1public static final int INSERT ; =1025
public static final int KEY_ACTION ; =403
public static final int KEY_ACTION_RELEASE ; =404
public static final int KEY_PRESS ; =401
public static final int KEY_RELEASE ; =402
public static final int LEFT ; =1006
public static final int LIST_DESELECT ; =702
public static final int LIST_SELECT ; =701
public static final int LOAD_FILE ; =1002
public static final int LOST_FOCUS ; =1005
public static final int META_MASK ; =4
public static final int MOUSE_DOWN ; =501
public static final int MOUSE_DRAG ; =506
public static final int MOUSE_ENTER ; =504
public static final int MOUSE_EXIT ; =505
public static final int MOUSE_MOVE ; =503
public static final int MOUSE_UP ; =502
1.1public static final int NUM_LOCK ; =1023
1.1public static final int PAUSE ; =1024
public static final int PGDN ; =1003
public static final int PGUP ; =1002
1.1public static final int PRINT_SCREEN ; =1020
public static final int RIGHT ; =1007
public static final int SAVE_FILE ; =1003
public static final int SCROLL_ABSOLUTE ; =605
1.1public static final int SCROLL_BEGIN ; =606
1.1public static final int SCROLL_END ; =607
public static final int SCROLL_LINE_DOWN ; =602
public static final int SCROLL_LINE_UP ; =601
1.1public static final int SCROLL_LOCK ; =1021
public static final int SCROLL_PAGE_DOWN ; =604
public static final int SCROLL_PAGE_UP ; =603
public static final int SHIFT_MASK ; =1
1.1public static final int TAB ; =9
public static final int UP ; =1004
public static final int WINDOW_DEICONIFY ; =204
public static final int WINDOW_DESTROY ; =201
public static final int WINDOW_EXPOSE ; =202
public static final int WINDOW_ICONIFY ; =203
public static final int WINDOW_MOVED ; =205
// Public Instance Methods
public boolean controlDown ();
public boolean metaDown ();
public boolean shiftDown ();
public void translate (int x, int y);
// Public Methods Overriding Object
public String toString ();
// Protected Instance Methods
protected String paramString ();
// Public Instance Fields
public Object arg ;
public int clickCount ;
public Event evt ;
public int id ;
public int key ;
public int modifiers ;
public Object target ;
public long when ;
public int x ;
public int y ;
}

Hierarchy: Object-->Event(Serializable)

Passed To: Too many methods to list.

Type Of: Event.evt

EventQueueJava 1.1
java.awtPJ1.1

This class implements an event queue for AWT events in Java 1.1. When an EventQueue is created, a new thread is automatically created and started to remove events from the front of the queue and dispatch them to the appropriate component. It is this thread, created by the EventQueue, that notifies event listeners and executes most of the code in a typical GUI-driven application.

An application can create and use its own private EventQueue, but all AWT events are placed on and dispatched from a single system EventQueue. Use the getSystemEventQueue() method of the Toolkit class to get the system EventQueue object.

getNextEvent() removes and returns the event at the front of the queue. It blocks if there are no events in the queue. peekEvent() returns the event at the front of the queue without removing it from the queue. Passed an optional AWTEventid field, it returns the first event of the specified type. Finally, postEvent() places a new event on the end of the event queue.

In Java 1.2, EventQueue defines three useful static methods. isDispatchThread() returns true if the calling thread is the AWT event dispatch thread. To avoid thread-safety issues, all modifications to AWT and Swing components should be done from this dispatch thread. If another thread needs to operate on a component, it should wrap the desired operation in a Runnable object and pass that object to invokeLater() or invokeAndWait(). These methods bundle the Runnable object into an ActiveEvent that is placed on the queue. When the ActiveEvent reaches the head of the queue, the Runnable code is invoked by the event dispatch thread and can safely modify any AWT and Swing components. invokeLater() returns immediately, while invokeAndWait() blocks until the Runnable code has been run. It is an error to call invokeAndWait() from the event dispatch thread itself. See also ActiveEvent and javax.swing.SwingUtilities. Except for these useful static methods, most applications do not need to use the EventQueue class at all; they can simply rely on the system to dispatch events automatically.

public class EventQueue {
// Public Constructors
public EventQueue ();
// Public Class Methods
1.2public static void invokeAndWait (Runnable runnable) throws InterruptedException, java.lang.reflect.InvocationTargetException;
1.2public static void invokeLater (Runnable runnable);
1.2public static boolean isDispatchThread ();
// Public Instance Methods
public AWTEvent getNextEvent () throws InterruptedException; synchronized
public AWTEvent peekEvent (); synchronized
public AWTEvent peekEvent (int id); synchronized
public void postEvent (AWTEvent theEvent);
1.2public void push (EventQueue newEventQueue); synchronized
// Protected Instance Methods
1.2protected void dispatchEvent (AWTEvent event);
1.2protected void pop () throws java.util.EmptyStackException;
}

Passed To: EventQueue.push()

Returned By: Toolkit.{getSystemEventQueue(), getSystemEventQueueImpl()}

FileDialogJava 1.0
java.awtserializable AWT component PJ1.1(opt)

This class represents a file selection dialog box. The constants LOAD and SAVE are values of an optional constructor argument that specifies whether the dialog should be an Open File dialog or a Save As dialog. You may specify a FilenameFilter object to control the files that are displayed in the dialog.

The inherited show() method pops the dialog up. For dialogs of this type, show() blocks, not returning until the user has selected a file and dismissed the dialog (which pops down automatically--you don't have to call hide()). Once show() has returned, use getFile() to get the name of the file the user selected.

public class FileDialog extends Dialog {
// Public Constructors
1.1public FileDialog (Frame parent);
public FileDialog (Frame parent, String title);
public FileDialog (Frame parent, String title, int mode);
// Public Constants
public static final int LOAD ; =0
public static final int SAVE ; =1
// Property Accessor Methods (by property name)
public String getDirectory ();
public void setDirectory (String dir);
public String getFile ();
public void setFile (String file);
public java.io.FilenameFilter getFilenameFilter ();
public void setFilenameFilter (java.io.FilenameFilter filter); synchronized
public int getMode ();
1.1public void setMode (int mode);
// Public Methods Overriding Dialog
public void addNotify ();
// Protected Methods Overriding Dialog
protected String paramString ();
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Container-->Window-->Dialog-->FileDialog

Passed To: Toolkit.createFileDialog()

FlowLayoutJava 1.0
java.awtserializable layout manager PJ1.1

A LayoutManager that arranges components in a container likes words on a page: from left to right and top to bottom. It fits as many components as it can in a row before moving on to the next row. The constructor allows you to specify one of five constants as an alignment value for the rows. LEFT, CENTER, and RIGHT specify left, center, and right alignment, obviously. LEADING and TRAILING alignment are the same as LEFT and RIGHT alignment in locales where writing is done left to right, but they have the opposite meaning in locales where writing is done primarily right to left. You can also specify the horizontal spacing between components and the vertical spacing between rows.

Applications should never call the LayoutManager methods of this class directly; the Container for which the FlowLayout is registered does this.

public class FlowLayout implements LayoutManager, Serializable {
// Public Constructors
public FlowLayout ();
public FlowLayout (int align);
public FlowLayout (int align, int hgap, int vgap);
// Public Constants
public static final int CENTER ; =1
1.2public static final int LEADING ; =3
public static final int LEFT ; =0
public static final int RIGHT ; =2
1.2public static final int TRAILING ; =4
// Property Accessor Methods (by property name)
1.1public int getAlignment (); default:1
1.1public void setAlignment (int align);
1.1public int getHgap (); default:5
1.1public void setHgap (int hgap);
1.1public int getVgap (); default:5
1.1public void setVgap (int vgap);
// Methods Implementing LayoutManager
public void addLayoutComponent (String name, Component comp); empty
public void layoutContainer (Container target);
public Dimension minimumLayoutSize (Container target);
public Dimension preferredLayoutSize (Container target);
public void removeLayoutComponent (Component comp); empty
// Public Methods Overriding Object
public String toString ();
}

Hierarchy: Object-->FlowLayout(LayoutManager,Serializable)

FontJava 1.0
java.awtserializable PJ1.1

This class represents a font. The Font() constructor is passed a name, a style, and a point size. The style should be one of the constants PLAIN, BOLD, or ITALIC or the sum BOLD+ITALIC.

The allowed font names have changed with each release of Java. In Java 1.0, the supported font names are "TimesRoman", "Helvetica", "Courier", "Dialog", "DialogInput", and "Symbol". In Java 1.1, "serif", "sansserif", and "monospaced" should be used in preference to the first three names.

With the introduction of Java 2D, you may continue to use these logical names, but you are not limited to them. In Java 1.2, you may specify the name of any font family available on the system. These are names such as "Times New Roman," "Arial," "New Century Schoolbook," "Bookman," and so on. You can obtain a list of available font families by calling the getAvailableFontFamilyNames() method of GraphicsEnvironment. You may also pass the name of a specific font face to the Font() constructor. These are names such as "Copperplate DemiBold Oblique." When you specify the name of a specific font face, you typically specify a font style of PLAIN, since the style you want is implicit in the name.

With Java 1.2, you can also create a font by passing a Map object that contains attribute names and values to either the Font() constructor or the static getFont() method. The attribute names and values are defined by java.awt.font.TextAttribute. The TextAttribute constants FAMILY, WEIGHT, POSTURE, and SIZE identify the attributes of interest.

In Java 1.2, new fonts can be derived from old fonts in a variety of ways, using the deriveFont() methods. Most generally, the glyphs of a font may all be transformed with the specified AffineTransform.

If you need to know the height or width (or other metrics) of characters or strings drawn using a Font, call the getFontMetrics() method of a Graphics object to obtain a FontMetrics object. The methods of this object return font measurement information as integer values. In Java 1.2, you can obtain higher-precision floating-point font measurements with the getLineMetrics(), getMaxCharBounds(), and getStringBounds() methods of a Font. These methods require a FontRenderContext, which is obtained by calling the getFontRenderContext() method of Graphics2D.

The canDisplay() method tests whether a Font can display a given character (i.e., whether the font contains a glyph for that character). canDisplayUpTo() tests whether the Font can display all the characters in a string and returns the index of the first character it cannot display.

public class Font implements Serializable {
// Public Constructors
1.2public Font (java.util.Map attributes);
public Font (String name, int style, int size);
// Public Constants
public static final int BOLD ; =1
1.2public static final int CENTER_BASELINE ; =1
1.2public static final int HANGING_BASELINE ; =2
public static final int ITALIC ; =2
public static final int PLAIN ; =0
1.2public static final int ROMAN_BASELINE ; =0
// Public Class Methods
1.1public static Font decode (String str);
1.2public static Font getFont (java.util.Map attributes);
public static Font getFont (String nm);
public static Font getFont (String nm, Font font);
// Property Accessor Methods (by property name)
1.2public java.util.Map getAttributes ();
1.2public java.text.AttributedCharacterIterator.Attribute[ ] getAvailableAttributes ();
public boolean isBold ();
public String getFamily ();
1.2public String getFamily (java.util.Locale l);
1.2public String getFontName ();
1.2public String getFontName (java.util.Locale l);
public boolean isItalic ();
1.2public float getItalicAngle ();
1.2public int getMissingGlyphCode ();
public String getName ();
1.2public int getNumGlyphs ();
public boolean isPlain ();
1.2public String getPSName ();
public int getSize ();
1.2public float getSize2D ();
public int getStyle ();
1.2public java.awt.geom.AffineTransform getTransform ();
// Public Instance Methods
1.2public boolean canDisplay (char c);
1.2public int canDisplayUpTo (String str);
1.2public int canDisplayUpTo (char[ ] text, int start, int limit);
1.2public int canDisplayUpTo (java.text.CharacterIterator iter, int start, int limit);
1.2public java.awt.font.GlyphVector createGlyphVector (java.awt.font.FontRenderContext frc, java.text.CharacterIterator ci);
1.2public java.awt.font.GlyphVector createGlyphVector (java.awt.font.FontRenderContext frc, char[ ] chars);
1.2public java.awt.font.GlyphVector createGlyphVector (java.awt.font.FontRenderContext frc, int[ ] glyphCodes);
1.2public java.awt.font.GlyphVector createGlyphVector (java.awt.font.FontRenderContext frc, String str);
1.2public Font deriveFont (float size);
1.2public Font deriveFont (int style);
1.2public Font deriveFont (java.awt.geom.AffineTransform trans);
1.2public Font deriveFont (java.util.Map attributes);
1.2public Font deriveFont (int style, java.awt.geom.AffineTransform trans);
1.2public Font deriveFont (int style, float size);
1.2public byte getBaselineFor (char c);
1.2public java.awt.font.LineMetrics getLineMetrics (String str, java.awt.font.FontRenderContext frc);
1.2public java.awt.font.LineMetrics getLineMetrics (char[ ] chars, int beginIndex, int limit, java.awt.font.FontRenderContext frc);
1.2public java.awt.font.LineMetrics getLineMetrics (java.text.CharacterIterator ci, int beginIndex, int limit, java.awt.font.FontRenderContext frc);
1.2public java.awt.font.LineMetrics getLineMetrics (String str, int beginIndex, int limit, java.awt.font.FontRenderContext frc);
1.2public java.awt.geom.Rectangle2D getMaxCharBounds (java.awt.font.FontRenderContext frc);
1.2public java.awt.geom.Rectangle2D getStringBounds (String str, java.awt.font.FontRenderContext frc);
1.2public java.awt.geom.Rectangle2D getStringBounds (char[ ] chars, int beginIndex, int limit, java.awt.font.FontRenderContext frc);
1.2public java.awt.geom.Rectangle2D getStringBounds (java.text.CharacterIterator ci, int beginIndex, int limit, java.awt.font.FontRenderContext frc);
1.2public java.awt.geom.Rectangle2D getStringBounds (String str, int beginIndex, int limit, java.awt.font.FontRenderContext frc);
1.2public boolean hasUniformLineMetrics (); constant
// Public Methods Overriding Object
public boolean equals (Object obj);
public int hashCode ();
public String toString ();
// Protected Methods Overriding Object
1.2protected void finalize () throws Throwable;
// Protected Instance Fields
protected String name ;
1.2protected float pointSize ;
protected int size ;
protected int style ;
// Deprecated Public Methods
1.1#public java.awt.peer.FontPeer getPeer ();
}

Hierarchy: Object-->Font(Serializable)

Subclasses: javax.swing.plaf.FontUIResource

Passed To: Too many methods to list.

Returned By: Too many methods to list.

Type Of: FontMetrics.font, javax.swing.border.TitledBorder.titleFont, javax.swing.tree.DefaultTreeCellEditor.font

FontMetricsJava 1.0
java.awtserializable PJ1.1

This class represents font metrics for a specified Font. The methods allow you to determine the overall metrics for the font (ascent, descent, and so on) and compute the width of strings that are to be displayed in a particular font. The FontMetrics() constructor is protected; you can obtain a FontMetrics object for a font with the getFontMetrics() method of Component, Graphics, or Toolkit.

In Java 1.2, with the introduction of Java 2D, you can obtain more precise (floating-point) metrics using the getLineMetrics(), getMaxCharBounds(), and getStringBounds() methods of FontMetrics or a Font object itself. See also java.awt.font.LineMetrics.

public abstract class FontMetrics implements Serializable {
// Protected Constructors
protected FontMetrics (Font font);
// Property Accessor Methods (by property name)
public int getAscent ();
public int getDescent (); constant
public Font getFont ();
public int getHeight ();
public int getLeading (); constant
public int getMaxAdvance (); constant
public int getMaxAscent ();
public int getMaxDescent ();
public int[ ] getWidths ();
// Public Instance Methods
public int bytesWidth (byte[ ] data, int off, int len);
public int charsWidth (char[ ] data, int off, int len);
public int charWidth (int ch);
public int charWidth (char ch);
1.2public java.awt.font.LineMetrics getLineMetrics (String str, Graphics context);
1.2public java.awt.font.LineMetrics getLineMetrics (char[ ] chars, int beginIndex, int limit, Graphics context);
1.2public java.awt.font.LineMetrics getLineMetrics (java.text.CharacterIterator ci, int beginIndex, int limit, Graphics context);
1.2public java.awt.font.LineMetrics getLineMetrics (String str, int beginIndex, int limit, Graphics context);
1.2public java.awt.geom.Rectangle2D getMaxCharBounds (Graphics context);
1.2public java.awt.geom.Rectangle2D getStringBounds (String str, Graphics context);
1.2public java.awt.geom.Rectangle2D getStringBounds (char[ ] chars, int beginIndex, int limit, Graphics context);
1.2public java.awt.geom.Rectangle2D getStringBounds (java.text.CharacterIterator ci, int beginIndex, int limit, Graphics context);
1.2public java.awt.geom.Rectangle2D getStringBounds (String str, int beginIndex, int limit, Graphics context);
1.2public boolean hasUniformLineMetrics ();
public int stringWidth (String str);
// Public Methods Overriding Object
public String toString ();
// Protected Instance Fields
protected Font font ;
// Deprecated Public Methods
#public int getMaxDecent ();
}

Hierarchy: Object-->FontMetrics(Serializable)

Passed To: javax.swing.SwingUtilities.{computeStringWidth(), layoutCompoundLabel()}, javax.swing.text.Utilities.{getBreakLocation(), getTabbedTextOffset(), getTabbedTextWidth()}

Returned By: Too many methods to list.

Type Of: javax.swing.text.PlainView.metrics

FrameJava 1.0
java.awtserializable AWT component PJ1.1(mod)

This class represents an optionally resizable top-level application window with a titlebar and other platform-dependent window decorations. setTitle() specifies a title, setMenuBar() specifies a menu bar, setCursor() specifies a cursor, and setIconImage() specifies an icon for the window. Call the pack() method of Window to initiate layout management of the window and set its initial size appropriately. Call the show() method of Window to make the window appear and be brought to the top of the window stack. Call setVisible(false) to make the window disappear. Call setState(Frame.ICONIFIED) to iconify the window, and call setState(Frame.NORMAL) to deiconify it. Use getState() to determine whether the window is iconified or not. Call the static getFrames() method to obtain an array of all Frame objects that have been created by the application or applet. Call the dispose() method when the Frame is no longer needed, so that it can release its window system resources for reuse.

The constants defined by this class specify various cursor types. As of Java 1.1, these constants and the cursor methods of Frame are deprecated in favor of the Cursor class and cursor methods of Component.

Personal Java environments can support only a single Frame object, and any calls to the Frame() constructor after the first can throw an exception.

public class Frame extends Window implements MenuContainer {
// Public Constructors
public Frame ();
public Frame (String title);
// Public Constants
1.2public static final int ICONIFIED ; =1
1.2public static final int NORMAL ; =0
// Public Class Methods
1.2public static Frame[ ] getFrames ();
// Property Accessor Methods (by property name)
public Image getIconImage (); default:null
public void setIconImage (Image image); synchronized
public MenuBar getMenuBar (); default:null
public void setMenuBar (MenuBar mb);
public boolean isResizable (); default:true
public void setResizable (boolean resizable);
1.2public int getState (); synchronized default:0
1.2public void setState (int state); synchronized
public String getTitle (); default:""
public void setTitle (String title); synchronized
// Methods Implementing MenuContainer
public void remove (MenuComponent m);
// Public Methods Overriding Window
public void addNotify ();
// Protected Methods Overriding Window
1.2protected void finalize () throws Throwable;
// Public Methods Overriding Container
1.2public void removeNotify ();
// Protected Methods Overriding Container
protected String paramString ();
// Deprecated Public Methods
#public int getCursorType (); default:0
#public void setCursor (int cursorType); synchronized
// Deprecated Public Fields
#public static final int CROSSHAIR_CURSOR ; =1
#public static final int DEFAULT_CURSOR ; =0
#public static final int E_RESIZE_CURSOR ; =11
#public static final int HAND_CURSOR ; =12
#public static final int MOVE_CURSOR ; =13
#public static final int N_RESIZE_CURSOR ; =8
#public static final int NE_RESIZE_CURSOR ; =7
#public static final int NW_RESIZE_CURSOR ; =6
#public static final int S_RESIZE_CURSOR ; =9
#public static final int SE_RESIZE_CURSOR ; =5
#public static final int SW_RESIZE_CURSOR ; =4
#public static final int TEXT_CURSOR ; =2
#public static final int W_RESIZE_CURSOR ; =10
#public static final int WAIT_CURSOR ; =3
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Container-->Window-->Frame(MenuContainer)

Subclasses: javax.swing.JFrame

Passed To: Too many methods to list.

Returned By: Frame.getFrames(), javax.swing.JOptionPane.{getFrameForComponent(), getRootFrame()}

GradientPaintJava 1.2
java.awt

This implementation of Paint fills shapes with a color gradient. To use a GradientPaint object for filling shapes, pass it to the setPaint() method of a Graphics2D object.

The color of the fill varies linearly between a color C1 and another color C2. The orientation of the color gradient is defined by a line between points P1 and P2. For example, if these points define a horizontal line, the color of the fill varies from left to right. If P1 is at the upper left of a rectangle and P2 is at the lower right, the fill color varies from upper left to lower right.

Color C1 is always used at point P1 and color C2 is used at P2. If the area to be filled includes points outside of the fill region defined by P1 and P2, these points can be filled in one of two ways. If the GradientPaint object is created with the cyclic constructor argument set to true, colors repeatedly cycle from C1 to C2 and back to C1 again. If cyclic is specified as false or if this argument is omitted, the gradient does not repeat. When an acyclic GradientPaint object is used, all points beyond P1 are given the color C1, and all points beyond C2 are given the color P2.

public class GradientPaint implements Paint {
// Public Constructors
public GradientPaint (java.awt.geom.Point2D pt1, Color color1, java.awt.geom.Point2D pt2, Color color2);
public GradientPaint (java.awt.geom.Point2D pt1, Color color1, java.awt.geom.Point2D pt2, Color color2, boolean cyclic);
public GradientPaint (float x1, float y1, Color color1, float x2, float y2, Color color2);
public GradientPaint (float x1, float y1, Color color1, float x2, float y2, Color color2, boolean cyclic);
// Property Accessor Methods (by property name)
public Color getColor1 ();
public Color getColor2 ();
public boolean isCyclic ();
public java.awt.geom.Point2D getPoint1 ();
public java.awt.geom.Point2D getPoint2 ();
public int getTransparency (); Implements:Transparency
// Methods Implementing Paint
public PaintContext createContext (java.awt.image.ColorModel cm, Rectangle deviceBounds, java.awt.geom.Rectangle2D userBounds, java.awt.geom.AffineTransform xform, RenderingHints hints);
// Methods Implementing Transparency
public int getTransparency ();
}

Hierarchy: Object-->GradientPaint(Paint(Transparency))

GraphicsJava 1.0
java.awtPJ1.1(mod)

This abstract class defines a device-independent interface to graphics. It specifies methods for drawing lines, filling areas, painting images, copying areas, and clipping graphics output. Specific subclasses of Graphics are implemented for different platforms and different graphics output devices. A Graphics object cannot be created directly through a constructor--it must either be obtained with the getGraphics() method of a Component or an Image or copied from an existing Graphics object with create(). When a Graphics object is no longer needed, you should call dispose() to free up the window system resources it uses.

In Personal Java environments, the setXORMode() method may be unsupported.

public abstract class Graphics {
// Protected Constructors
protected Graphics ();
// Property Accessor Methods (by property name)
1.1public abstract Shape getClip ();
1.1public abstract void setClip (Shape clip);
1.1public abstract void setClip (int x, int y, int width, int height);
1.1public abstract Rectangle getClipBounds ();
1.2public Rectangle getClipBounds (Rectangle r);
public abstract Color getColor ();
public abstract void setColor (Color c);
public abstract Font getFont ();
public abstract void setFont (Font font);
public FontMetrics getFontMetrics ();
public abstract FontMetrics getFontMetrics (Font f);
// Public Instance Methods
public abstract void clearRect (int x, int y, int width, int height);
public abstract void clipRect (int x, int y, int width, int height);
public abstract void copyArea (int x, int y, int width, int height, int dx, int dy);
public abstract Graphics create ();
public Graphics create (int x, int y, int width, int height);
public abstract void dispose ();
public void draw3DRect (int x, int y, int width, int height, boolean raised);
public abstract void drawArc (int x, int y, int width, int height, int startAngle, int arcAngle);
public void drawBytes (byte[ ] data, int offset, int length, int x, int y);
public void drawChars (char[ ] data, int offset, int length, int x, int y);
public abstract boolean drawImage (Image img, int x, int y, java.awt.image.ImageObserver observer);
public abstract boolean drawImage (Image img, int x, int y, Color bgcolor, java.awt.image.ImageObserver observer);
public abstract boolean drawImage (Image img, int x, int y, int width, int height, java.awt.image.ImageObserver observer);
public abstract boolean drawImage (Image img, int x, int y, int width, int height, Color bgcolor, java.awt.image.ImageObserver observer);
1.1public abstract boolean drawImage (Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, java.awt.image.ImageObserver observer);
1.1public abstract boolean drawImage (Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgcolor, java.awt.image.ImageObserver observer);
public abstract void drawLine (int x1, int y1, int x2, int y2);
public abstract void drawOval (int x, int y, int width, int height);
public void drawPolygon (Polygon p);
public abstract void drawPolygon (int[ ] xPoints, int[ ] yPoints, int nPoints);
1.1public abstract void drawPolyline (int[ ] xPoints, int[ ] yPoints, int nPoints);
public void drawRect (int x, int y, int width, int height);
public abstract void drawRoundRect (int x, int y, int width, int height, int arcWidth, int arcHeight);
1.2public abstract void drawString (java.text.AttributedCharacterIterator iterator, int x, int y);
public abstract void drawString (String str, int x, int y);
public void fill3DRect (int x, int y, int width, int height, boolean raised);
public abstract void fillArc (int x, int y, int width, int height, int startAngle, int arcAngle);
public abstract void fillOval (int x, int y, int width, int height);
public void fillPolygon (Polygon p);
public abstract void fillPolygon (int[ ] xPoints, int[ ] yPoints, int nPoints);
public abstract void fillRect (int x, int y, int width, int height);
public abstract void fillRoundRect (int x, int y, int width, int height, int arcWidth, int arcHeight);
1.2public boolean hitClip (int x, int y, int width, int height);
public abstract void setPaintMode ();
public abstract void setXORMode (Color c1);
public abstract void translate (int x, int y);
// Public Methods Overriding Object
public void finalize ();
public String toString ();
// Deprecated Public Methods
#public Rectangle getClipRect ();
}

Subclasses: Graphics2D, javax.swing.DebugGraphics

Passed To: Too many methods to list.

Returned By: Component.getGraphics(), Graphics.create(), Image.getGraphics(), PrintJob.getGraphics(), java.awt.image.BufferedImage.getGraphics(), java.awt.peer.ComponentPeer.getGraphics(), javax.swing.DebugGraphics.create(), javax.swing.JComponent.{getComponentGraphics(), getGraphics()}

Graphics2DJava 1.2
java.awt

This class is the Java 2D graphics context that encapsulates all drawing and filling operations. It generalizes and extends the Graphics class. A number of attributes control how the Graphics2D object performs drawing and filling operations. You can set these attributes with the following methods:

setBackground()

Specifies the background color used by the clearRect() method of the Graphics object. Prior to Java 2D, the background color could not be set.

setClip()

Sets the clipping region, outside of which no drawing is done. This method is inherited from the Graphics object. Use setClip() to establish an initial clipping region and then use clip() to narrow that region by intersecting it with other regions.

setComposite()

Specifies a Composite object (typically an instance of AlphaComposite) that should be used to combine drawing colors with the colors that are already present on the drawing surface.

setFont()

Sets the default Font object used to draw text. This is a Graphics method, inherited by Graphics2D.

setPaint()

Specifies the Paint object that controls the color or pattern used for drawing. See Color, GradientPaint, and TexturePaint.

setRenderingHints()

Sets hints about how drawing should be done. This method allows you to turn antialiasing and color dithering on and off, for example. You can also set hints with addRenderingHints() and setRenderingHint().

setStroke()

Specifies the Stroke object (typically an instance of BasicStroke) used to trace the outline of shapes that are drawn. The Stroke object effectively defines the pen that is used for drawing operations.

setTransform()

Sets the AffineTransform object used to convert from user coordinates to device coordinates. Note that you do not usually call setTransform() directly, but instead modify the current transform with transform() or the more specific rotate(), scale(), shear(), and translate() methods.

Once you have used these methods to configure a Graphics2D object as desired, you can proceed to draw with it. The following methods are commonly used:

draw()

Draw the outline of a Shape, using the line style specified by the current Stroke object and the color or pattern specified by the current Paint object. The java.awt.geom package contains a number of commonly used implementations of the Shape interface.

fill()

Fill the interior of a Shape, using the color or pattern specified by the current Paint object.

drawString()

Draw the specified text using the specified Font object and Paint object. drawGlyphVector() is similar. See also the drawString() methods inherited from Graphics.

drawImage()

Draw an Image with an optional filtering operation and/or an optional transformation. Also drawRenderableImage() and drawRenderedImage(). See also the drawImage() methods inherited from Graphics.

public abstract class Graphics2D extends Graphics {
// Protected Constructors
protected Graphics2D ();
// Property Accessor Methods (by property name)
public abstract Color getBackground ();
public abstract void setBackground (Color color);
public abstract Composite getComposite ();
public abstract void setComposite (Composite comp);
public abstract GraphicsConfiguration getDeviceConfiguration ();
public abstract java.awt.font.FontRenderContext getFontRenderContext ();
public abstract Paint getPaint ();
public abstract void setPaint (Paint paint);
public abstract RenderingHints getRenderingHints ();
public abstract void setRenderingHints (java.util.Map hints);
public abstract Stroke getStroke ();
public abstract void setStroke (Stroke s);
public abstract java.awt.geom.AffineTransform getTransform ();
public abstract void setTransform (java.awt.geom.AffineTransform Tx);
// Public Instance Methods
public abstract void addRenderingHints (java.util.Map hints);
public abstract void clip (Shape s);
public abstract void draw (Shape s);
public abstract void drawGlyphVector (java.awt.font.GlyphVector g, float x, float y);
public abstract boolean drawImage (Image img, java.awt.geom.AffineTransform xform, java.awt.image.ImageObserver obs);
public abstract void drawImage (java.awt.image.BufferedImage img, java.awt.image.BufferedImageOp op, int x, int y);
public abstract void drawRenderableImage (java.awt.image.renderable.RenderableImage img, java.awt.geom.AffineTransform xform);
public abstract void drawRenderedImage (java.awt.image.RenderedImage img, java.awt.geom.AffineTransform xform);
public abstract void drawString (java.text.AttributedCharacterIterator iterator, float x, float y);
public abstract void drawString (String s, float x, float y);
public abstract void fill (Shape s);
public abstract Object getRenderingHint (RenderingHints.Key hintKey);
public abstract boolean hit (Rectangle rect, Shape s, boolean onStroke);
public abstract void rotate (double theta);
public abstract void rotate (double theta, double x, double y);
public abstract void scale (double sx, double sy);
public abstract void setRenderingHint (RenderingHints.Key hintKey, Object hintValue);
public abstract void shear (double shx, double shy);
public abstract void transform (java.awt.geom.AffineTransform Tx);
public abstract void translate (double tx, double ty);
// Public Methods Overriding Graphics
public void draw3DRect (int x, int y, int width, int height, boolean raised);
public abstract void drawString (java.text.AttributedCharacterIterator iterator, int x, int y);
public abstract void drawString (String str, int x, int y);
public void fill3DRect (int x, int y, int width, int height, boolean raised);
public abstract void translate (int x, int y);
}

Hierarchy: Object-->Graphics-->Graphics2D

Passed To: java.awt.font.GraphicAttribute.draw(), java.awt.font.ImageGraphicAttribute.draw(), java.awt.font.ShapeGraphicAttribute.draw(), java.awt.font.TextLayout.draw()

Returned By: GraphicsEnvironment.createGraphics(), java.awt.image.BufferedImage.createGraphics()

GraphicsConfigTemplateJava 1.2
java.awtserializable

This abstract class is designed to support a matching operation that selects the best configuration from an array of GraphicsConfiguration objects. The best configuration is defined as the one that most closely matches the desired criteria. GraphicsConfigTemplate does not define what those criteria might be, however: the criteria and the matching algorithm are left entirely to the concrete subclass that provides definitions of the abstract methods.

This class in not commonly used. There are not any implementations of GraphicsConfigTemplate built into Java 1.2. On many platforms, such as Windows, a screen has only one available GraphicsConfiguration, so there is never a need to try to find the best one.

public abstract class GraphicsConfigTemplate implements Serializable {
// Public Constructors
public GraphicsConfigTemplate ();
// Public Constants
public static final int PREFERRED ; =2
public static final int REQUIRED ; =1
public static final int UNNECESSARY ; =3
// Public Instance Methods
public abstract GraphicsConfiguration getBestConfiguration (GraphicsConfiguration[ ] gc);
public abstract boolean isGraphicsConfigSupported (GraphicsConfiguration gc);
}

Hierarchy: Object-->GraphicsConfigTemplate(Serializable)

Passed To: GraphicsDevice.getBestConfiguration()

GraphicsConfigurationJava 1.2
java.awt

This class describes a configuration of a graphics device. It stores information about the available resolution and colors of the device.

Resolution information is stored in the form of AffineTransform objects. getDefaultTransform() returns the default transform used to map user coordinates to device coordinates. For screen devices, this is usually an identity transform: by default, user coordinates are measured in screen pixels. For printers, the default transform is such that 72 units in user space maps to one inch on the printed page. getNormalizingTransform() returns an AffineTransform that, when concatenated to the default transform, yields a coordinate system in which 72 units of user space equal one inch on the screen or on a printed piece of paper. (For printers, this normalizing transform is obviously the identity transform, since the default transform is already 72 units to the inch.)

Color information about the device is returned by getColorModel(), in the form of a java.awt.image.ColorModel object. A ColorModel maps pixel values to their individual color components. The zero-argument form of getColorModel() returns the default color model for the configuration. If you pass one of the constants defined by the Transparency interface, the method returns a ColorModel object suitable for the configuration and the specified level of transparency.

createCompatibleImage() creates an off-screen BufferedImage object with the specified size and transparency that is compatible with the device color model. However, that most applications create off-screen images using a higher-level method, such as the createImage() method of Component.

See also GraphicsDevice and GraphicsEnvironment.

public abstract class GraphicsConfiguration {
// Protected Constructors
protected GraphicsConfiguration ();
// Property Accessor Methods (by property name)
public abstract java.awt.image.ColorModel getColorModel ();
public abstract java.awt.image.ColorModel getColorModel (int transparency);
public abstract java.awt.geom.AffineTransform getDefaultTransform ();
public abstract GraphicsDevice getDevice ();
public abstract java.awt.geom.AffineTransform getNormalizingTransform ();
// Public Instance Methods
public abstract java.awt.image.BufferedImage createCompatibleImage (int width, int height);
public abstract java.awt.image.BufferedImage createCompatibleImage (int width, int height, int transparency);
}

Passed To: Canvas.Canvas(), GraphicsConfigTemplate.{getBestConfiguration(), isGraphicsConfigSupported()}

Returned By: Graphics2D.getDeviceConfiguration(), GraphicsConfigTemplate.getBestConfiguration(), GraphicsDevice.{getBestConfiguration(), getConfigurations(), getDefaultConfiguration()}

GraphicsDeviceJava 1.2
java.awt

The GraphicsDevice class represents a device capable of displaying graphics, such as a computer monitor, a printer, or an off-screen image.

A GraphicsDevice object stores the type of the device (getType()) and an identifying string (getIDString()). More importantly, it contains a list of possible configurations of the device. For example, a screen may be configured at different resolutions and color depths. This configuration information is stored by the GraphicsDevice as GraphicsConfiguration objects.

GraphicsDevice does not have a public constructor. Instances that represent screen devices can be obtained by calling the getDefaultScreenDevice() method of GraphicsEnvironment. More generally, the GraphicsDevice used by any Graphics2D object can be obtained by calling getDeviceConfiguration() on that object to obtain a GraphicsConfiguration, and then calling getDevice() on that object to get its GraphicsDevice.

public abstract class GraphicsDevice {
// Protected Constructors
protected GraphicsDevice ();
// Public Constants
public static final int TYPE_IMAGE_BUFFER ; =2
public static final int TYPE_PRINTER ; =1
public static final int TYPE_RASTER_SCREEN ; =0
// Property Accessor Methods (by property name)
public abstract GraphicsConfiguration[ ] getConfigurations ();
public abstract GraphicsConfiguration getDefaultConfiguration ();
public abstract String getIDstring ();
public abstract int getType ();
// Public Instance Methods
public GraphicsConfiguration getBestConfiguration (GraphicsConfigTemplate gct);
}

Returned By: GraphicsConfiguration.getDevice(), GraphicsEnvironment.{getDefaultScreenDevice(), getScreenDevices()}

GraphicsEnvironmentJava 1.2
java.awt

This class describes a Java 2D graphics environment. This class does not have a public constructor; use getLocalGraphicsEnvironment() to obtain the GraphicsEnvironment object that represents the environment available to the Java VM.

A graphics environment consists of a list of available screens and a list of available fonts. The screens are represented by GraphicsDevice objects. Use getDefaultScreenDevice() to obtain information about the default screen. Although the GraphicsDevice class can also describe printers and off-screen images, the methods of GraphicsEnvironment return only screen devices. Therefore, it is not possible to use the GraphicsEnvironment class to query the available printers.

getAllFonts() returns a list of all fonts available on the system. Use caution when calling this method, however, because on some systems it can take a long time to enumerate all installed fonts. Note that the fonts returned by this method all have a size of 1 unit; a font must be scaled to the desired size by calling deriveFont() on the Font. When possible, it is usually better to call getAvailableFontFamilyNames() to list available font families, then create only the individual Font objects desired.

See also GraphicsDevice and GraphicsConfiguration.

public abstract class GraphicsEnvironment {
// Protected Constructors
protected GraphicsEnvironment ();
// Public Class Methods
public static GraphicsEnvironment getLocalGraphicsEnvironment ();
// Property Accessor Methods (by property name)
public abstract Font[ ] getAllFonts ();
public abstract String[ ] getAvailableFontFamilyNames ();
public abstract String[ ] getAvailableFontFamilyNames (java.util.Locale l);
public abstract GraphicsDevice getDefaultScreenDevice ();
public abstract GraphicsDevice[ ] getScreenDevices ();
// Public Instance Methods
public abstract Graphics2D createGraphics (java.awt.image.BufferedImage img);
}

Returned By: GraphicsEnvironment.getLocalGraphicsEnvironment()

GridBagConstraintsJava 1.0
java.awtcloneable serializable PJ1.1

This class encapsulates the instance variables that tell a GridBagLayout how to position a given Component within its Container:

gridx, gridy

The grid position of the component. The RELATIVE constant specifies a position to the right of or below the previous component.

gridwidth, gridheight

The height and width of the component in grid cells. The constant REMAINDER specifies that the component is the last one and should get all remaining cells.

fill

The dimensions of a component that should grow when the space available for it is larger than its default size. Legal values are the constants NONE, BOTH, HORIZONTAL, and VERTICAL.

ipadx, ipady

Internal padding to add on each side of the component in each dimension. This padding increases the size of the component beyond its default minimum size.

insets

An Insets object that specifies margins to appear on all sides of the component.

anchor

How the component should be displayed within its grid cells when it is smaller than those cells. The CENTER constant and the compass-point constants are legal values.

weightx, weighty

How extra space in the container should be distributed among its components in the X and Y dimensions. Larger weights specify that a component should receive a proportionally larger amount of extra space. A 0 weight indicates that the component should not receive any extra space. These weights specify the resizing behavior of the component and its container.

See also GridBagLayout.

public class GridBagConstraints implements Cloneable, Serializable {
// Public Constructors
public GridBagConstraints ();
1.2public GridBagConstraints (int gridx, int gridy, int gridwidth, int gridheight, double weightx, double weighty, int anchor, int fill, Insets insets, int ipadx, int ipady);
// Public Constants
public static final int BOTH ; =1
public static final int CENTER ; =10
public static final int EAST ; =13
public static final int HORIZONTAL ; =2
public static final int NONE ; =0
public static final int NORTH ; =11
public static final int NORTHEAST ; =12
public static final int NORTHWEST ; =18
public static final int RELATIVE ; =-1
public static final int REMAINDER ; =0
public static final int SOUTH ; =15
public static final int SOUTHEAST ; =14
public static final int SOUTHWEST ; =16
public static final int VERTICAL ; =3
public static final int WEST ; =17
// Public Methods Overriding Object
public Object clone ();
// Public Instance Fields
public int anchor ;
public int fill ;
public int gridheight ;
public int gridwidth ;
public int gridx ;
public int gridy ;
public Insets insets ;
public int ipadx ;
public int ipady ;
public double weightx ;
public double weighty ;
}

Hierarchy: Object-->GridBagConstraints(Cloneable,Serializable)

Passed To: GridBagLayout.{AdjustForGravity(), setConstraints()}

Returned By: GridBagLayout.{getConstraints(), lookupConstraints()}

Type Of: GridBagLayout.defaultConstraints

GridBagLayoutJava 1.0
java.awtserializable layout manager PJ1.1

The most complicated and most powerful LayoutManager in the java.awt package. GridBagLayout divides a container into a grid of rows and columns (that need not have the same width and height) and places the components into this grid, adjusting the size of the grid cells as necessary to ensure that components do not overlap. Each component controls how it is positioned within this grid by specifying a number of variables (or constraints) in a GridBagConstraints object. Do not confuse this class with the much simpler GridLayout, which arranges components in a grid of equally sized cells.

Use setConstraints() to specify a GridBagConstraints object for each of the components in the container. Or, as of Java 1.1, specify the GridBagConstraints object when adding the component to the container with add(). The variables in this object specify the position of the component in the grid and the number of horizontal and vertical grid cells that the component occupies and also control other important aspects of component layout. See GridBagConstraints for more information on these constraint variables. setConstraints() makes a copy of the constraints object, so you may reuse a single object in your code.

Applications should never call the LayoutManager methods of this class directly; the Container for which the GridBagLayout is registered does this.

public class GridBagLayout implements LayoutManager2, Serializable {
// Public Constructors
public GridBagLayout ();
// Protected Constants
protected static final int MAXGRIDSIZE ; =512
protected static final int MINSIZE ; =1
protected static final int PREFERREDSIZE ; =2
// Property Accessor Methods (by property name)
public int[ ][ ] getLayoutDimensions ();
public Point getLayoutOrigin ();
public double[ ][ ] getLayoutWeights ();
// Public Instance Methods
public GridBagConstraints getConstraints (Component comp);
public Point location (int x, int y);
public void setConstraints (Component comp, GridBagConstraints constraints);
// Methods Implementing LayoutManager
public void addLayoutComponent (String name, Component comp); empty
public void layoutContainer (Container parent);
public Dimension minimumLayoutSize (Container parent);
public Dimension preferredLayoutSize (Container parent);
public void removeLayoutComponent (Component comp);
// Methods Implementing LayoutManager2
1.1public void addLayoutComponent (Component comp, Object constraints);
1.1public float getLayoutAlignmentX (Container parent);
1.1public float getLayoutAlignmentY (Container parent);
1.1public void invalidateLayout (Container target); empty
1.1public Dimension maximumLayoutSize (Container target);
// Public Methods Overriding Object
public String toString ();
// Protected Instance Methods
protected void AdjustForGravity (GridBagConstraints constraints, Rectangle r);
protected void ArrangeGrid (Container parent);
protected GridBagLayoutInfo GetLayoutInfo (Container parent, int sizeflag);
protected Dimension GetMinSize (Container parent, GridBagLayoutInfo info);
protected GridBagConstraints lookupConstraints (Component comp);
// Public Instance Fields
public double[ ] columnWeights ;
public int[ ] columnWidths ;
public int[ ] rowHeights ;
public double[ ] rowWeights ;
// Protected Instance Fields
protected java.util.Hashtable comptable ;
protected GridBagConstraints defaultConstraints ;
protected GridBagLayoutInfo layoutInfo ;
}

Hierarchy: Object-->GridBagLayout(LayoutManager2(LayoutManager),Serializable)

GridLayoutJava 1.0
java.awtserializable layout manager PJ1.1

A LayoutManager that divides a Container into a specified number of equally sized rows and columns and arranges the components in those rows and columns, left to right and top to bottom. If either the number of rows or the number of columns is set to 0, its value is computed from the other dimension and the total number of components. Do not confuse this class with the more flexible and complicated GridBagLayout.

Applications should never call the LayoutManager methods of this class directly; the Container for which the GridLayout is registered does this.

public class GridLayout implements LayoutManager, Serializable {
// Public Constructors
1.1public GridLayout ();
public GridLayout (int rows, int cols);
public GridLayout (int rows, int cols, int hgap, int vgap);
// Property Accessor Methods (by property name)
1.1public int getColumns (); default:0
1.1public void setColumns (int cols);
1.1public int getHgap (); default:0
1.1public void setHgap (int hgap);
1.1public int getRows (); default:1
1.1public void setRows (int rows);
1.1public int getVgap (); default:0
1.1public void setVgap (int vgap);
// Methods Implementing LayoutManager
public void addLayoutComponent (String name, Component comp); empty
public void layoutContainer (Container parent);
public Dimension minimumLayoutSize (Container parent);
public Dimension preferredLayoutSize (Container parent);
public void removeLayoutComponent (Component comp); empty
// Public Methods Overriding Object
public String toString ();
}

Hierarchy: Object-->GridLayout(LayoutManager,Serializable)

IllegalComponentStateExceptionJava 1.1
java.awtserializable unchecked PJ1.1

Signals that an AWT component is not in the appropriate state for some requested operation (e.g., it hasn't been added to a container yet or is currently hidden).

public class IllegalComponentStateException extends java.lang.IllegalStateException {
// Public Constructors
public IllegalComponentStateException ();
public IllegalComponentStateException (String s);
}

Hierarchy: Object-->Throwable(Serializable)-->Exception-->RuntimeException-->java.lang.IllegalStateException-->IllegalComponentStateException

Thrown By: AccessibleContext.getLocale()

ImageJava 1.0
java.awtPJ1.1

This abstract class represents a displayable image in a platform-independent way. An Image object cannot be instantiated directly through a constructor; it must be obtained through a method like the getImage() method of Applet or the createImage() method of Component. getSource() method returns the ImageProducer object that produces the image data. getGraphics() returns a Graphics object that can be used for drawing into off-screen images (but not images that are downloaded or generated by an ImageProducer).

public abstract class Image {
// Public Constructors
public Image ();
// Public Constants
1.1public static final int SCALE_AREA_AVERAGING ; =16
1.1public static final int SCALE_DEFAULT ; =1
1.1public static final int SCALE_FAST ; =2
1.1public static final int SCALE_REPLICATE ; =8
1.1public static final int SCALE_SMOOTH ; =4
public static final Object UndefinedProperty ;
// Property Accessor Methods (by property name)
public abstract Graphics getGraphics ();
public abstract java.awt.image.ImageProducer getSource ();
// Public Instance Methods
public abstract void flush ();
public abstract int getHeight (java.awt.image.ImageObserver observer);
public abstract Object getProperty (String name, java.awt.image.ImageObserver observer);
1.1public Image getScaledInstance (int width, int height, int hints);
public abstract int getWidth (java.awt.image.ImageObserver observer);
}

Subclasses: java.awt.image.BufferedImage

Passed To: Too many methods to list.

Returned By: Too many methods to list.

Type Of: javax.swing.JViewport.backingStoreImage

InsetsJava 1.0
java.awtcloneable serializable PJ1.1

This class holds four values that represent the top, left, bottom, and right margins, in pixels, of a Container or other Component. An object of this type can be specified in a GridBagConstraints layout object and is returned by Container.insets(), which queries the margins of a container.

public class Insets implements Cloneable, Serializable {
// Public Constructors
public Insets (int top, int left, int bottom, int right);
// Public Methods Overriding Object
public Object clone ();
1.1public boolean equals (Object obj);
public String toString ();
// Public Instance Fields
public int bottom ;
public int left ;
public int right ;
public int top ;
}

Hierarchy: Object-->Insets(Cloneable,Serializable)

Subclasses: javax.swing.plaf.InsetsUIResource

Passed To: Too many methods to list.

Returned By: Too many methods to list.

Type Of: GridBagConstraints.insets

ItemSelectableJava 1.1
java.awtPJ1.1

This interface abstracts the functionality of an AWT component that presents one or more items to the user and allows the user to select none, one, or several of them. It is implemented by several components in the AWT and Swing.

getSelectedObjects() returns an array of selected objects or null, if none are selected. addItemListener() and removeItemListener() are standard methods for adding and removing ItemListener objects to be notified when an item is selected.

public abstract interface ItemSelectable {
// Event Registration Methods (by event name)
public abstract void addItemListener (java.awt.event.ItemListener l);
public abstract void removeItemListener (java.awt.event.ItemListener l);
// Public Instance Methods
public abstract Object[ ] getSelectedObjects ();
}

Implementations: Checkbox, CheckboxMenuItem, Choice, java.awt.List, javax.swing.AbstractButton, javax.swing.ButtonModel, javax.swing.JComboBox

Passed To: java.awt.event.ItemEvent.ItemEvent()

Returned By: java.awt.event.ItemEvent.getItemSelectable()

LabelJava 1.0
java.awtserializable AWT component PJ1.1

This class is a Component that displays a single specified line of read-only text. The constant values specify the text alignment within the component and can be specified in a call to the constructor or used with setAlignment().

public class Label extends Component {
// Public Constructors
public Label ();
public Label (String text);
public Label (String text, int alignment);
// Public Constants
public static final int CENTER ; =1
public static final int LEFT ; =0
public static final int RIGHT ; =2
// Property Accessor Methods (by property name)
public int getAlignment (); default:0
public void setAlignment (int alignment); synchronized
public String getText (); default:""
public void setText (String text);
// Public Methods Overriding Component
public void addNotify ();
// Protected Methods Overriding Component
protected String paramString ();
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Label

Passed To: Toolkit.createLabel()

LayoutManagerJava 1.0
java.awtlayout manager PJ1.1

This interface defines the methods necessary for a class to be able to arrange Component objects within a Container object. Most programs use one of the existing classes that implement this interface: BorderLayout, CardLayout, FlowLayout, GridBagConstraints, GridBagLayout, or GridLayout.

To define a new class that lays out components, you must implement each of the methods defined by this interface. addLayoutComponent() is called when a component is added to the container. removeLayoutComponent() is called when a component is removed. layoutContainer() should perform the actual positioning of components by setting the size and position of each component in the specified container. minimumLayoutSize() should return the minimum container width and height that the LayoutManager needs in order to lay out its components. preferredLayoutSize() should return the optimal container width and height for the LayoutManager to lay out its components.

As of Java 1.1, layout managers should implement the LayoutManager2 interface, which is an extension of this one. A Java applet or application never directly calls any of these LayoutManager methods--the Container object for which the LayoutManager is registered does that.

public abstract interface LayoutManager {
// Public Instance Methods
public abstract void addLayoutComponent (String name, Component comp);
public abstract void layoutContainer (Container parent);
public abstract Dimension minimumLayoutSize (Container parent);
public abstract Dimension preferredLayoutSize (Container parent);
public abstract void removeLayoutComponent (Component comp);
}

Implementations: FlowLayout, GridLayout, LayoutManager2, javax.swing.ScrollPaneLayout, javax.swing.ViewportLayout

Passed To: Container.setLayout(), Panel.Panel(), ScrollPane.setLayout(), javax.swing.Box.setLayout(), javax.swing.JApplet.setLayout(), javax.swing.JDialog.setLayout(), javax.swing.JFrame.setLayout(), javax.swing.JInternalFrame.setLayout(), javax.swing.JPanel.JPanel(), javax.swing.JScrollPane.setLayout(), javax.swing.JWindow.setLayout()

Returned By: Container.getLayout(), javax.swing.JRootPane.createRootLayout(), javax.swing.JViewport.createLayoutManager()

LayoutManager2Java 1.1
java.awtlayout manager PJ1.1

This interface is an extension of the LayoutManager interface. It defines additional layout management methods for layout managers that perform constraint-based layout. GridBagLayout is an example of a constraint-based layout manager--each component added to the layout is associated with a GridBagConstraints object that specifies the constraints on how the component is to be laid out.

Java programs do not directly invoke the methods of this interface--they are used by the Container object for which the layout manager is registered.

public abstract interface LayoutManager2 extends LayoutManager {
// Public Instance Methods
public abstract void addLayoutComponent (Component comp, Object constraints);
public abstract float getLayoutAlignmentX (Container target);
public abstract float getLayoutAlignmentY (Container target);
public abstract void invalidateLayout (Container target);
public abstract Dimension maximumLayoutSize (Container target);
}

Hierarchy: (LayoutManager2(LayoutManager))

Implementations: BorderLayout, CardLayout, GridBagLayout, javax.swing.BoxLayout, javax.swing.JRootPane.RootLayout, javax.swing.OverlayLayout

ListJava 1.0
java.awtserializable AWT component PJ1.1

This class is a Component that graphically displays a list of strings. The list is scrollable if necessary. The constructor takes optional arguments that specify the number of visible rows in the list and whether selection of more than one item is allowed. The various instance methods allow strings to be added and removed from the List and allow the selected item or items to be queried.

public class List extends Component implements ItemSelectable {
// Public Constructors
public List ();
1.1public List (int rows);
public List (int rows, boolean multipleMode);
// Event Registration Methods (by event name)
1.1public void addActionListener (java.awt.event.ActionListener l); synchronized
1.1public void removeActionListener (java.awt.event.ActionListener l); synchronized
1.1public void addItemListener (java.awt.event.ItemListener l); Implements:ItemSelectable synchronized
1.1public void removeItemListener (java.awt.event.ItemListener l); Implements:ItemSelectable synchronized
// Property Accessor Methods (by property name)
1.1public int getItemCount (); default:0
1.1public String[ ] getItems (); synchronized
1.1public Dimension getMinimumSize (); Overrides:Component
1.1public Dimension getMinimumSize (int rows);
1.1public boolean isMultipleMode (); default:false
1.1public void setMultipleMode (boolean b);
1.1public Dimension getPreferredSize (); Overrides:Component
1.1public Dimension getPreferredSize (int rows);
public int getRows (); default:4
public int getSelectedIndex (); synchronized default:-1
public int[ ] getSelectedIndexes (); synchronized
public String getSelectedItem (); synchronized default:null
public String[ ] getSelectedItems (); synchronized
1.1public Object[ ] getSelectedObjects (); Implements:ItemSelectable
public int getVisibleIndex (); default:-1
// Public Instance Methods
1.1public void add (String item);
1.1public void add (String item, int index);
public void deselect (int index); synchronized
public String getItem (int index);
1.1public boolean isIndexSelected (int index);
public void makeVisible (int index); synchronized
1.1public void remove (String item); synchronized
1.1public void remove (int position);
1.1public void removeAll ();
public void replaceItem (String newValue, int index); synchronized
public void select (int index);
// Methods Implementing ItemSelectable
1.1public void addItemListener (java.awt.event.ItemListener l); synchronized
1.1public Object[ ] getSelectedObjects ();
1.1public void removeItemListener (java.awt.event.ItemListener l); synchronized
// Public Methods Overriding Component
public void addNotify ();
public void removeNotify ();
// Protected Methods Overriding Component
protected String paramString ();
1.1protected void processEvent (AWTEvent e);
// Protected Instance Methods
1.1protected void processActionEvent (java.awt.event.ActionEvent e);
1.1protected void processItemEvent (java.awt.event.ItemEvent e);
// Deprecated Public Methods
#public void addItem (String item);
#public void addItem (String item, int index); synchronized
#public boolean allowsMultipleSelections ();
#public void clear (); synchronized
#public int countItems ();
#public void delItem (int position);
#public void delItems (int start, int end); synchronized
#public boolean isSelected (int index);
#public Dimension minimumSize (); Overrides:Component
#public Dimension minimumSize (int rows);
#public Dimension preferredSize (); Overrides:Component
#public Dimension preferredSize (int rows);
#public void setMultipleSelections (boolean b); synchronized
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->java.awt.List(ItemSelectable)

Passed To: Toolkit.createList()

MediaTrackerJava 1.0
java.awtserializable PJ1.1

This class provides a convenient way to asynchronously load and keep track of the status of any number of Image objects. You can use it to load one or more images and then wait until those images have been completely loaded and are ready to be used.

The addImage() method registers an image to be loaded and tracked, assigning it a specified identifier value. waitForID() loads all the images that have been assigned the specified identifier and returns when they have all finished loading or it receives an error. isErrorAny() and isErrorID() check whether any errors have occurred while loading images. statusAll() and statusID() return the status of all images and of all images with the specified identifier, respectively. The return value of each of these methods is one of the defined constants.

public class MediaTracker implements Serializable {
// Public Constructors
public MediaTracker (Component comp);
// Public Constants
public static final int ABORTED ; =2
public static final int COMPLETE ; =8
public static final int ERRORED ; =4
public static final int LOADING ; =1
// Public Instance Methods
public void addImage (Image image, int id);
public void addImage (Image image, int id, int w, int h); synchronized
public boolean checkAll ();
public boolean checkAll (boolean load);
public boolean checkID (int id);
public boolean checkID (int id, boolean load);
public Object[ ] getErrorsAny (); synchronized
public Object[ ] getErrorsID (int id); synchronized
public boolean isErrorAny (); synchronized
public boolean isErrorID (int id); synchronized
1.1public void removeImage (Image image); synchronized
1.1public void removeImage (Image image, int id); synchronized
1.1public void removeImage (Image image, int id, int width, int height); synchronized
public int statusAll (boolean load);
public int statusID (int id, boolean load);
public void waitForAll () throws InterruptedException;
public boolean waitForAll (long ms) throws InterruptedException; synchronized
public void waitForID (int id) throws InterruptedException;
public boolean waitForID (int id, long ms) throws InterruptedException; synchronized
}

Hierarchy: Object-->MediaTracker(Serializable)

Type Of: javax.swing.ImageIcon.tracker

MenuJava 1.0
java.awtserializable AWT component PJ1.1(opt)

This class represents a pulldown menu pane that appears within a MenuBar. Each Menu has a label that appears in the MenuBar and can optionally be a tear-off menu. The add() and addSeparator() methods add individual items to a Menu.

public class Menu extends MenuItem implements MenuContainer {
// Public Constructors
1.1public Menu ();
public Menu (String label);
public Menu (String label, boolean tearOff);
// Property Accessor Methods (by property name)
1.1public int getItemCount (); default:0
public boolean isTearOff (); default:false
// Public Instance Methods
public void add (String label);
public MenuItem add (MenuItem mi);
public void addSeparator ();
public MenuItem getItem (int index);
1.1public void insert (String label, int index);
1.1public void insert (MenuItem menuitem, int index);
1.1public void insertSeparator (int index);
public void remove (int index);
1.1public void removeAll ();
// Methods Implementing MenuContainer
public void remove (MenuComponent item);
// Public Methods Overriding MenuItem
public void addNotify ();
1.1public String paramString ();
// Public Methods Overriding MenuComponent
public void removeNotify ();
// Deprecated Public Methods
#public int countItems ();
}

Hierarchy: Object-->MenuComponent(Serializable)-->MenuItem-->Menu(MenuContainer)

Subclasses: PopupMenu

Passed To: MenuBar.{add(), setHelpMenu()}, Toolkit.createMenu(), java.awt.peer.MenuBarPeer.{addHelpMenu(), addMenu()}

Returned By: MenuBar.{add(), getHelpMenu(), getMenu()}

MenuBarJava 1.0
java.awtserializable AWT component PJ1.1(opt)

This class represents a menu bar. add() adds Menu objects to the menu bar, and setHelpMenu() adds a Help menu in a reserved location of the menu bar. A MenuBar object may be displayed within a Frame by passing it to the setMenuBar() of the Frame.

public class MenuBar extends MenuComponent implements MenuContainer {
// Public Constructors
public MenuBar ();
// Property Accessor Methods (by property name)
public Menu getHelpMenu (); default:null
public void setHelpMenu (Menu m);
1.1public int getMenuCount (); default:0
// Public Instance Methods
public Menu add (Menu m);
public void addNotify ();
1.1public void deleteShortcut (MenuShortcut s);
public Menu getMenu (int i);
1.1public MenuItem getShortcutMenuItem (MenuShortcut s);
public void remove (int index);
1.1public java.util.Enumeration shortcuts (); synchronized
// Methods Implementing MenuContainer
public void remove (MenuComponent m);
// Public Methods Overriding MenuComponent
public void removeNotify ();
// Deprecated Public Methods
#public int countMenus ();
}

Hierarchy: Object-->MenuComponent(Serializable)-->MenuBar(MenuContainer)

Passed To: Frame.setMenuBar(), Toolkit.createMenuBar(), java.awt.peer.FramePeer.setMenuBar()

Returned By: Frame.getMenuBar()

MenuComponentJava 1.0
java.awtserializable AWT component PJ1.1

This class is the superclass of all menu-related classes: You never need to instantiate a MenuComponent directly. setFont() specifies the font to be used for all text within the menu component.

public abstract class MenuComponent implements Serializable {
// Public Constructors
public MenuComponent ();
// Property Accessor Methods (by property name)
public Font getFont ();
public void setFont (Font f);
1.1public String getName ();
1.1public void setName (String name);
public MenuContainer getParent ();
// Public Instance Methods
1.1public final void dispatchEvent (AWTEvent e);
public void removeNotify ();
// Public Methods Overriding Object
public String toString ();
// Protected Instance Methods
1.1protected final Object getTreeLock ();
protected String paramString ();
1.1protected void processEvent (AWTEvent e); empty
// Deprecated Public Methods
#public java.awt.peer.MenuComponentPeer getPeer ();
#public boolean postEvent (Event evt);
}

Hierarchy: Object-->MenuComponent(Serializable)

Subclasses: MenuBar, MenuItem

Passed To: Component.remove(), Frame.remove(), Menu.remove(), MenuBar.remove(), MenuContainer.remove()

MenuContainerJava 1.0
java.awtPJ1.1

This interface defines the methods necessary for MenuContainer types, such as Menu, Frame, and MenuBar objects. Unless you implement new menulike components, you never need to use it.

public abstract interface MenuContainer {
// Public Instance Methods
public abstract Font getFont ();
public abstract void remove (MenuComponent comp);
// Deprecated Public Methods
#public abstract boolean postEvent (Event evt);
}

Implementations: Component, Frame, Menu, MenuBar

Returned By: MenuComponent.getParent()

MenuItemJava 1.0
java.awtserializable AWT component PJ1.1

This class encapsulates a menu item with a specified textual label. A MenuItem can be added to a menu pane with the add() method of Menu. The disable() method makes an item nonselectable; you might use it to gray out a menu item when the command it represents is not valid in the current context. The enable() method makes an item selectable again. In Java 1.1, use setActionCommand() to specify an identifying string that is included in ActionEvent events generated by the menu item.

public class MenuItem extends MenuComponent {
// Public Constructors
1.1public MenuItem ();
public MenuItem (String label);
1.1public MenuItem (String label, MenuShortcut s);
// Event Registration Methods (by event name)
1.1public void addActionListener (java.awt.event.ActionListener l); synchronized
1.1public void removeActionListener (java.awt.event.ActionListener l); synchronized
// Property Accessor Methods (by property name)
1.1public String getActionCommand (); default:""
1.1public void setActionCommand (String command);
public boolean isEnabled (); default:true
1.1public void setEnabled (boolean b); synchronized
public String getLabel (); default:""
public void setLabel (String label); synchronized
1.1public MenuShortcut getShortcut (); default:null
1.1public void setShortcut (MenuShortcut s);
// Public Instance Methods
public void addNotify ();
1.1public void deleteShortcut ();
// Public Methods Overriding MenuComponent
public String paramString ();
// Protected Methods Overriding MenuComponent
1.1protected void processEvent (AWTEvent e);
// Protected Instance Methods
1.1protected final void disableEvents (long eventsToDisable);
1.1protected final void enableEvents (long eventsToEnable);
1.1protected void processActionEvent (java.awt.event.ActionEvent e);
// Deprecated Public Methods
#public void disable (); synchronized
#public void enable (); synchronized
#public void enable (boolean b);
}

Hierarchy: Object-->MenuComponent(Serializable)-->MenuItem

Subclasses: CheckboxMenuItem, Menu

Passed To: Menu.{add(), insert()}, Toolkit.createMenuItem(), java.awt.peer.MenuPeer.addItem()

Returned By: Menu.{add(), getItem()}, MenuBar.getShortcutMenuItem()

MenuShortcutJava 1.1
java.awtserializable PJ1.1(opt)

This class represents a keystroke used to select a MenuItem without actually pulling down the menu. A MenuShortcut object can be specified for a MenuItem when the MenuItem is created or by calling the item's setShortcut() method. The keystroke sequence for the menu shortcut automatically appears in the label for the menu item, so you do not need to add this information yourself.

When you create a MenuShortcut, you specify the keycode of the shortcut--this is one of the VK_ constants defined by java.awt.event.KeyEvent and is not always the same as a corresponding character code. You may optionally specify a boolean value that, if true, indicates that the MenuShortcut requires the Shift key to be held down.

Note that menu shortcuts are triggered in a platform-dependent way. When you create a shortcut, you specify only the keycode and an optional Shift modifier. The shortcut is not triggered, however, unless an additional modifier key is held down. On Windows platforms, for example, the Ctrl key is used for menu shortcuts. You can query the platform-specific menu shortcut key with the getMenuShortcutKeyMask() method of Toolkit.

public class MenuShortcut implements Serializable {
// Public Constructors
public MenuShortcut (int key);
public MenuShortcut (int key, boolean useShiftModifier);
// Public Instance Methods
public boolean equals (MenuShortcut s);
public int getKey ();
public boolean usesShiftModifier ();
// Public Methods Overriding Object
1.2public boolean equals (Object obj);
1.2public int hashCode ();
public String toString ();
// Protected Instance Methods
protected String paramString ();
}

Hierarchy: Object-->MenuShortcut(Serializable)

Passed To: MenuBar.{deleteShortcut(), getShortcutMenuItem()}, MenuItem.{MenuItem(), setShortcut()}, MenuShortcut.equals()

Returned By: MenuItem.getShortcut()

PaintJava 1.2
java.awt

This interface defines a color or pattern used by Java 2D in drawing and filling operations. Color is the simplest implementation: it performs drawing and filling using a solid color. GradientPaint and TexturePaint are two other commonly used implementations. Most applications can simply use these predefined Paint implementations and do not need to implement this interface themselves.

Because a single Paint object may be used by different threads with different Graphics2D objects, the Paint object does not perform painting operations itself. Instead, it defines a createContext() method that returns a PaintContext object that is capable of performing painting in a particular context. See PaintContext for details.

public abstract interface Paint extends Transparency {
// Public Instance Methods
public abstract PaintContext createContext (java.awt.image.ColorModel cm, Rectangle deviceBounds, java.awt.geom.Rectangle2D userBounds, java.awt.geom.AffineTransform xform, RenderingHints hints);
}

Hierarchy: (Paint(Transparency))

Implementations: Color, GradientPaint, TexturePaint

Passed To: Graphics2D.setPaint()

Returned By: Graphics2D.getPaint()

PaintContextJava 1.2
java.awt

This interface defines the methods that do the actual work of computing the colors to be used in Java 2D drawing and filling operations. PaintContext is used internally by Java 2D; applications never need to call any of its methods. Only applications that implement custom Paint objects need to implement this interface.

A Graphics2D object creates a PaintContext object by calling the createContext() method of its Paint object. The getRaster() method of the PaintContext is called to perform the actual painting; this method must return a java.awt.image.Raster object that contains the appropriate colors for the specified rectangle. The Graphics2D object calls dispose() when the PaintContext is no longer needed. The dispose() method should release any system resources held by the PaintContext.

public abstract interface PaintContext {
// Public Instance Methods
public abstract void dispose ();
public abstract java.awt.image.ColorModel getColorModel ();
public abstract java.awt.image.Raster getRaster (int x, int y, int w, int h);
}

Returned By: Color.createContext(), GradientPaint.createContext(), Paint.createContext(), SystemColor.createContext(), TexturePaint.createContext()

PanelJava 1.0
java.awtserializable AWT component PJ1.1

This class is a Container that is itself contained within a container. Unlike Frame and Dialog, Panel is a container that does not create a separate window of its own. Panel is suitable for holding portions of a larger interface within a parent Frame or Dialog or within another Panel. (Because Applet is a subclass of Panel, applets are displayed in a Panel that is contained within a web browser or applet viewer.) The default LayoutManager for a Panel is FlowLayout.

public class Panel extends Container {
// Public Constructors
public Panel ();
1.1public Panel (LayoutManager layout);
// Public Methods Overriding Container
public void addNotify ();
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Container-->Panel

Subclasses: java.applet.Applet

Passed To: Toolkit.createPanel()

PointJava 1.0
java.awtcloneable serializable PJ1.1

This class holds the integer X and Y coordinates of a two-dimensional point. The move() and setLocation() methods set the coordinates, and the translate() method adds specified values to the coordinates. Also, the x and y fields are public and may be manipulated directly.

In Java 1.0 and Java 1.1, Point is a subclass of Object. In Java 1.2, with the introduction of Java 2D, Point has become a concrete subclass of java.awt.geom.Point2D. Contrast Point with Point2D.Float and Point2D.Double, which use float and double fields to represent the coordinates of the point.

public class Point extends java.awt.geom.Point2D implements Serializable {
// Public Constructors
1.1public Point ();
1.1public Point (Point p);
public Point (int x, int y);
// Public Instance Methods
1.1public Point getLocation ();
public void move (int x, int y);
1.1public void setLocation (Point p);
1.1public void setLocation (int x, int y);
public void translate (int x, int y);
// Public Methods Overriding Point2D
public boolean equals (Object obj);
1.2public double getX (); default:0.0
1.2public double getY (); default:0.0
1.2public void setLocation (double x, double y);
// Public Methods Overriding Object
public String toString ();
// Public Instance Fields
public int x ;
public int y ;
}

Hierarchy: Object-->java.awt.geom.Point2D(Cloneable)-->Point(Serializable)

Passed To: Too many methods to list.

Returned By: Too many methods to list.

Type Of: javax.swing.JViewport.lastPaintPosition

PolygonJava 1.0
java.awtserializable shape PJ1.1

This class defines a polygon as an array of points. The points of the polygon can be passed to the constructor or specified with addPoint(). getBoundingBox() returns the smallest Rectangle that contains the polygon, and inside() tests whether a specified point is within the Polygon. Note that the arrays of X and Y points and the number of points in the polygon (not necessarily the same as the array size) are defined as public variables. Polygon objects are used when drawing polygons with the drawPolygon() and fillPolygon() methods of Graphics. In Java 2, Polygon has become part of the Java 2D API. It implements the Shape interface and can be passed to the draw() and fill() method of a Graphics2D object.

public class Polygon implements Serializable, Shape {
// Public Constructors
public Polygon ();
public Polygon (int[ ] xpoints, int[ ] ypoints, int npoints);
// Public Instance Methods
public void addPoint (int x, int y);
1.1public boolean contains (Point p);
1.1public boolean contains (int x, int y);
1.1public void translate (int deltaX, int deltaY);
// Methods Implementing Shape
1.2public boolean contains (java.awt.geom.Rectangle2D r);
1.2public boolean contains (java.awt.geom.Point2D p);
1.2public boolean contains (double x, double y);
1.2public boolean contains (double x, double y, double w, double h);
1.1public Rectangle getBounds ();
1.2public java.awt.geom.Rectangle2D getBounds2D (); default:Rectangle2D.Float
1.2public java.awt.geom.PathIterator getPathIterator (java.awt.geom.AffineTransform at);
1.2public java.awt.geom.PathIterator getPathIterator (java.awt.geom.AffineTransform at, double flatness);
1.2public boolean intersects (java.awt.geom.Rectangle2D r);
1.2public boolean intersects (double x, double y, double w, double h);
// Public Instance Fields
public int npoints ;
public int[ ] xpoints ;
public int[ ] ypoints ;
// Protected Instance Fields
protected Rectangle bounds ;
// Deprecated Public Methods
#public Rectangle getBoundingBox ();
#public boolean inside (int x, int y);
}

Hierarchy: Object-->Polygon(Serializable,Shape)

Passed To: Graphics.{drawPolygon(), fillPolygon()}

PopupMenuJava 1.1
java.awtserializable AWT component PJ1.1(mod)

PopupMenu is a simple subclass of Menu that represents a popup menu rather than a pulldown menu. You create a PopupMenu just as you would create a Menu object. The main difference is that a popup menu must be popped up in response to a user event by calling its show() method. Another difference is that, unlike a Menu, which can only appear within a MenuBar or another Menu, a PopupMenu can be associated with any component in a graphical user interface. A PopupMenu is associated with a component by calling the add() method of the component.

Popup menus are popped up by the user in different ways on different platforms. In order to hide this platform dependency, the MouseEvent class defines the isPopupTrigger() method. If this method returns true, the specified MouseEvent represents the platform-specific popup menu trigger event, and you should use the show() method to display your PopupMenu. Note that the X and Y coordinates passed to show() should be in the coordinate system of the specified Component.

Support for nested popup menus is optional in Personal Java environments, and the inherited add() method may throw an exception if you attempt to add a Menu child to a PopupMenu.

public class PopupMenu extends Menu {
// Public Constructors
public PopupMenu ();
public PopupMenu (String label);
// Public Instance Methods
public void show (Component origin, int x, int y);
// Public Methods Overriding Menu
public void addNotify ();
}

Hierarchy: Object-->MenuComponent(Serializable)-->MenuItem-->Menu(MenuContainer)-->PopupMenu

Passed To: Component.add(), Toolkit.createPopupMenu()

PrintGraphicsJava 1.1
java.awtPJ1.1

The Graphics object returned by the getGraphics() method of PrintJob always implements this PrintGraphics interface. You can use this fact to distinguish a Graphics object that draws to the screen from one that generates hardcopy. This is a useful thing to do in a paint() method, when you want to generate hardcopy that differs somewhat from what is being displayed on-screen.

The getPrintJob() method defined by this interface can be used to return the PrintJob with which the PrintGraphics object is associated.

public abstract interface PrintGraphics {
// Public Instance Methods
public abstract PrintJob getPrintJob ();
}
PrintJobJava 1.1
java.awtPJ1.1

A PrintJob object represents a single printing session, or job. The job may consist of one or more individual pages.

PrintJob is abstract, so it cannot be instantiated directly. Instead, you must call the getPrintJob() method of the Toolkit object. Calling this method posts an appropriate print dialog box to request information from the user, such as which printer should be used. An application has no control over this process, but may pass a Properties object in which the dialog stores the user's printing preferences. This Properties object can then be reused when initiating subsequent print jobs.

Once a PrintJob object has been obtained from the Toolkit object, you call the getGraphics() method of PrintJob to obtain a Graphics object. Any drawing done with this Graphics object is printed, instead of displayed on-screen. The object returned by getGraphics() implements the PrintGraphics interface. Do not make any assumptions about the initial state of the Graphics object; in particular, note that you must specify a font before you can draw any text.

When you are done drawing all the desired output on a page, call the dispose() method of the Graphics object to force the current page to be printed. You can call getGraphics() and dispose() repeatedly to print any number of pages required by your application. However, if the lastPageFirst() method returns true, the user has requested that pages be printed in reverse order. It is up to your application to implement this feature.

The getPageDimension() method returns the size of the page in pixels. getPageResolution() returns the resolution of the page in pixels per inch. This resolution is closer to a screen resolution (70 to 100 pixels per inch) than a typical printer resolution (300 to 600 pixels per inch). This means that on-screen drawings can be drawn directly to the printer without scaling. It also means, however, that you cannot take full advantage of the extra resolution provided by printers.

When you are done with a PrintJob and have called dispose() on the Graphics object returned by getGraphics(), you should call end() to terminate the job.

As of Java 1.2, the PrintJob class has been superseded by a more complete printing API provided in the java.awt.print package.

public abstract class PrintJob {
// Public Constructors
public PrintJob ();
// Property Accessor Methods (by property name)
public abstract Graphics getGraphics ();
public abstract Dimension getPageDimension ();
public abstract int getPageResolution ();
// Public Instance Methods
public abstract void end ();
public abstract boolean lastPageFirst ();
// Public Methods Overriding Object
public void finalize ();
}

Returned By: PrintGraphics.getPrintJob(), Toolkit.getPrintJob()

RectangleJava 1.0
java.awtcloneable serializable shape PJ1.1

This class defines a rectangle using four integer values: the X and Y coordinates of its upper-left corner and its width and height. The instance methods perform various tests and transformations on the rectangle. The x, y, width, and height methods are public and may thus be manipulated directly. Rectangle is used for a variety of purposes throughout java.awt and related packages.

In Java 1.0 and Java 1.1, Rectangle is a subclass of Object. In Java 2, with the introduction of Java 2D, Rectangle has become a concrete subclass of java.awt.geom.Rectangle2D. Contrast Rectangle with Rectangle2D.Float and Rectangle2D.Double, which use float and double fields to represent the coordinates of the rectangle.

public class Rectangle extends java.awt.geom.Rectangle2D implements Serializable, Shape {
// Public Constructors
public Rectangle ();
1.1public Rectangle (Rectangle r);
public Rectangle (Dimension d);
public Rectangle (Point p);
public Rectangle (int width, int height);
public Rectangle (Point p, Dimension d);
public Rectangle (int x, int y, int width, int height);
// Property Accessor Methods (by property name)
1.1public Rectangle getBounds (); Implements:Shape
1.1public void setBounds (Rectangle r);
1.1public void setBounds (int x, int y, int width, int height);
1.2public java.awt.geom.Rectangle2D getBounds2D (); Implements:Shape default:Rectangle
public boolean isEmpty (); Overrides:RectangularShape default:true
1.2public double getHeight (); Overrides:RectangularShape default:0.0
1.1public Point getLocation ();
1.1public void setLocation (Point p);
1.1public void setLocation (int x, int y);
1.1public Dimension getSize ();
1.1public void setSize (Dimension d);
1.1public void setSize (int width, int height);
1.2public double getWidth (); Overrides:RectangularShape default:0.0
1.2public double getX (); Overrides:RectangularShape default:0.0
1.2public double getY (); Overrides:RectangularShape default:0.0
// Public Instance Methods
public void add (Rectangle r);
public void add (Point pt);
public void add (int newx, int newy);
1.2public boolean contains (Rectangle r);
1.1public boolean contains (Point p);
1.1public boolean contains (int x, int y);
1.2public boolean contains (int X, int Y, int W, int H);
public void grow (int h, int v);
public Rectangle intersection (Rectangle r);
public boolean intersects (Rectangle r);
public void translate (int x, int y);
public Rectangle union (Rectangle r);
// Methods Implementing Shape
1.1public Rectangle getBounds ();
1.2public java.awt.geom.Rectangle2D getBounds2D (); default:Rectangle
// Public Methods Overriding Rectangle2D
1.2public java.awt.geom.Rectangle2D createIntersection (java.awt.geom.Rectangle2D r);
1.2public java.awt.geom.Rectangle2D createUnion (java.awt.geom.Rectangle2D r);
public boolean equals (Object obj);
1.2public int outcode (double x, double y);
1.2public void setRect (double x, double y, double width, double height);
// Public Methods Overriding Object
public String toString ();
// Public Instance Fields
public int height ;
public int width ;
public int x ;
public int y ;
// Deprecated Public Methods
#public boolean inside (int x, int y);
#public void move (int x, int y);
#public void reshape (int x, int y, int width, int height);
#public void resize (int width, int height);
}

Hierarchy: Object-->java.awt.geom.RectangularShape(Cloneable,Shape)-->java.awt.geom.Rectangle2D-->Rectangle(Serializable,Shape)

Subclasses: javax.swing.text.DefaultCaret

Passed To: Too many methods to list.

Returned By: Too many methods to list.

Type Of: Polygon.bounds

RenderingHintsJava 1.2
java.awtcloneable collection

This class contains a set of key-to-value mappings that provide hints to Java 2D about the speed-versus-quality trade-offs it should make. The constants that begin with KEY_ are the hints, while the constants that begin with VALUE_ are the values that may be specified for those hints. Use put() to add a hint to the RenderingHints object. Once you have specified all desired hints, pass the RenderingHints object to the setRenderingHints() or addRenderingHints() method of a Graphics2D object. If you want to set only a single rendering hint, you don't need to create a RenderingHints object at all; you can simply pass a key and value to the setRenderingHint() method of Graphics2D.

public class RenderingHints implements Cloneable, java.util.Map {
// Public Constructors
public RenderingHints (java.util.Map init);
public RenderingHints (RenderingHints.Key key, Object value);
// Public Constants
public static final RenderingHints.Key KEY_ALPHA_INTERPOLATION ;
public static final RenderingHints.Key KEY_ANTIALIASING ;
public static final RenderingHints.Key KEY_COLOR_RENDERING ;
public static final RenderingHints.Key KEY_DITHERING ;
public static final RenderingHints.Key KEY_FRACTIONALMETRICS ;
public static final RenderingHints.Key KEY_INTERPOLATION ;
public static final RenderingHints.Key KEY_RENDERING ;
public static final RenderingHints.Key KEY_TEXT_ANTIALIASING ;
public static final Object VALUE_ALPHA_INTERPOLATION_DEFAULT ;
public static final Object VALUE_ALPHA_INTERPOLATION_QUALITY ;
public static final Object VALUE_ALPHA_INTERPOLATION_SPEED ;
public static final Object VALUE_ANTIALIAS_DEFAULT ;
public static final Object VALUE_ANTIALIAS_OFF ;
public static final Object VALUE_ANTIALIAS_ON ;
public static final Object VALUE_COLOR_RENDER_DEFAULT ;
public static final Object VALUE_COLOR_RENDER_QUALITY ;
public static final Object VALUE_COLOR_RENDER_SPEED ;
public static final Object VALUE_DITHER_DEFAULT ;
public static final Object VALUE_DITHER_DISABLE ;
public static final Object VALUE_DITHER_ENABLE ;
public static final Object VALUE_FRACTIONALMETRICS_DEFAULT ;
public static final Object VALUE_FRACTIONALMETRICS_OFF ;
public static final Object VALUE_FRACTIONALMETRICS_ON ;
public static final Object VALUE_INTERPOLATION_BICUBIC ;
public static final Object VALUE_INTERPOLATION_BILINEAR ;
public static final Object VALUE_INTERPOLATION_NEAREST_NEIGHBOR ;
public static final Object VALUE_RENDER_DEFAULT ;
public static final Object VALUE_RENDER_QUALITY ;
public static final Object VALUE_RENDER_SPEED ;
public static final Object VALUE_TEXT_ANTIALIAS_DEFAULT ;
public static final Object VALUE_TEXT_ANTIALIAS_OFF ;
public static final Object VALUE_TEXT_ANTIALIAS_ON ;
// Inner Classes
;
// Public Instance Methods
public void add (RenderingHints hints);
// Methods Implementing Map
public void clear ();
public boolean containsKey (Object key);
public boolean containsValue (Object value);
public java.util.Set entrySet ();
public boolean equals (Object o);
public Object get (Object key);
public int hashCode ();
public boolean isEmpty ();
public java.util.Set keySet ();
public Object put (Object key, Object value);
public void putAll (java.util.Map m);
public Object remove (Object key);
public int size ();
public java.util.Collection values ();
// Public Methods Overriding Object
public Object clone ();
public String toString ();
}

Hierarchy: Object-->RenderingHints(Cloneable,java.util.Map)

Passed To: Too many methods to list.

Returned By: Graphics2D.getRenderingHints(), java.awt.image.AffineTransformOp.getRenderingHints(), java.awt.image.BandCombineOp.getRenderingHints(), java.awt.image.BufferedImageOp.getRenderingHints(), java.awt.image.ColorConvertOp.getRenderingHints(), java.awt.image.ConvolveOp.getRenderingHints(), java.awt.image.LookupOp.getRenderingHints(), java.awt.image.RasterOp.getRenderingHints(), java.awt.image.RescaleOp.getRenderingHints(), java.awt.image.renderable.RenderContext.getRenderingHints()

RenderingHints.KeyJava 1.2
java.awt

This class is the type of the KEY_ constants defined by RenderingHints.

public abstract static class RenderingHints.Key {
// Protected Constructors
protected Key (int privatekey);
// Public Instance Methods
public abstract boolean isCompatibleValue (Object val);
// Public Methods Overriding Object
public final boolean equals (Object o);
public final int hashCode ();
// Protected Instance Methods
protected final int intKey ();
}

Passed To: Graphics2D.{getRenderingHint(), setRenderingHint()}, RenderingHints.RenderingHints()

Type Of: RenderingHints.{KEY_ALPHA_INTERPOLATION, KEY_ANTIALIASING, KEY_COLOR_RENDERING, KEY_DITHERING, KEY_FRACTIONALMETRICS, KEY_INTERPOLATION, KEY_RENDERING, KEY_TEXT_ANTIALIASING}

ScrollbarJava 1.0
java.awtserializable AWT component PJ1.1(opt)

This Component represents a graphical scrollbar. setValue() sets the displayed value of the scrollbar. setValues() sets the displayed value, the page size, and the minimum and maximum values. The constants HORIZONTAL and VERTICAL are legal values for the scrollbar orientation.

public class Scrollbar extends Component implements Adjustable {
// Public Constructors
public Scrollbar ();
public Scrollbar (int orientation);
public Scrollbar (int orientation, int value, int visible, int minimum, int maximum);
// Public Constants
public static final int HORIZONTAL ; =0
public static final int VERTICAL ; =1
// Event Registration Methods (by event name)
1.1public void addAdjustmentListener (java.awt.event.AdjustmentListener l); Implements:Adjustable synchronized
1.1public void removeAdjustmentListener (java.awt.event.AdjustmentListener l); Implements:Adjustable synchronized
// Property Accessor Methods (by property name)
1.1public int getBlockIncrement (); Implements:Adjustable default:10
1.1public void setBlockIncrement (int v); Implements:Adjustable
public int getMaximum (); Implements:Adjustable default:100
1.1public void setMaximum (int newMaximum); Implements:Adjustable
public int getMinimum (); Implements:Adjustable default:0
1.1public void setMinimum (int newMinimum); Implements:Adjustable
public int getOrientation (); Implements:Adjustable default:1
1.1public void setOrientation (int orientation);
1.1public int getUnitIncrement (); Implements:Adjustable default:1
1.1public void setUnitIncrement (int v); Implements:Adjustable
public int getValue (); Implements:Adjustable default:0
public void setValue (int newValue); Implements:Adjustable
1.1public int getVisibleAmount (); Implements:Adjustable default:10
1.1public void setVisibleAmount (int newAmount); Implements:Adjustable
// Public Instance Methods
public void setValues (int value, int visible, int minimum, int maximum); synchronized
// Public Methods Overriding Component
public void addNotify ();
// Protected Methods Overriding Component
protected String paramString ();
1.1protected void processEvent (AWTEvent e);
// Protected Instance Methods
1.1protected void processAdjustmentEvent (java.awt.event.AdjustmentEvent e);
// Deprecated Public Methods
#public int getLineIncrement (); default:1
#public int getPageIncrement (); default:10
#public int getVisible (); default:10
#public void setLineIncrement (int v); synchronized
#public void setPageIncrement (int v); synchronized
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Scrollbar(Adjustable)

Passed To: Toolkit.createScrollbar()

ScrollPaneJava 1.1
java.awtserializable AWT component PJ1.1(mod)

This Container class creates horizontal and vertical scrollbars surrounding a viewport and allows a single child component to be displayed and scrolled within this viewport. Typically, the child of the ScrollPane is larger than the ScrollPane itself, so scrollbars allow the user to select the currently visible portion.

When you call the ScrollPane() constructor, you may optionally specify a scrollbar display policy, which should be one of the three constants defined by this class. If you do not specify a policy, ScrollPane uses the SCROLLBARS_AS_NEEDED policy. Personal Java environments may provide a scrolling mechanism other than scrollbars. In this case, the scrollbar display policy may be ignored.

A program can programmatically scroll the child within the viewport by calling setScrollPosition(). getHAdjustable() and getVAdjustable() return the horizontal and vertical Adjustable objects that control scrolling (typically these are not actually instances of Scrollbar). You can use these Adjustable objects to specify the unit and block increment values for the scrollbars. You can also directly set the Adjustable value as an alternative to calling setScrollPosition(), but you should not set other values of an Adjustable object.

Use setSize() to set the size of the ScrollPane container. You may want to take the size of the scrollbars into account when computing the overall container size--use getHScrollbarHeight() and getVScrollbarWidth() to obtain these values.

ScrollPane overrides the printComponents() method of Container, so that when a ScrollPane is printed, the entire child component, rather than only the currently visible portion, is printed.

public class ScrollPane extends Container {
// Public Constructors
public ScrollPane ();
public ScrollPane (int scrollbarDisplayPolicy);
// Public Constants
public static final int SCROLLBARS_ALWAYS ; =1
public static final int SCROLLBARS_AS_NEEDED ; =0
public static final int SCROLLBARS_NEVER ; =2
// Property Accessor Methods (by property name)
public Adjustable getHAdjustable ();
public int getHScrollbarHeight (); default:0
public final void setLayout (LayoutManager mgr); Overrides:Container
public int getScrollbarDisplayPolicy (); default:0
public Point getScrollPosition ();
public void setScrollPosition (Point p);
public void setScrollPosition (int x, int y);
public Adjustable getVAdjustable ();
public Dimension getViewportSize ();
public int getVScrollbarWidth (); default:0
// Public Methods Overriding Container
public void addNotify ();
public void doLayout ();
public String paramString ();
public void printComponents (Graphics g);
// Protected Methods Overriding Container
protected final void addImpl (Component comp, Object constraints, int index);
// Deprecated Public Methods
#public void layout (); Overrides:Container
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Container-->ScrollPane

Passed To: Toolkit.createScrollPane()

ShapeJava 1.1
java.awtshape PJ1.1

This interface is one of the most important in all of Java 2D. It defines methods necessary for generalized operations on shapes, such as drawing, filling, and insideness testing. The package java.awt.geom contains a number of useful implementations of this interface, including GeneralPath, which can be used to describe arbitrary shapes composed of line and curve segments. java.awt.Polygon and java.awt.Rectangle are also important implementations of Shape. Most applications can rely on these predefined implementations and do not need to implement this interface themselves.

getBounds() and getBounds2D() return rectangular bounding boxes that completely enclose a Shape. contains() and intersects() test whether the shape contains or intersects a specified point or rectangle. The most important method of the Shape interface, however, is getPathIterator(). This method returns a java.awt.geom.PathIterator object that traces the outline of the shape using line and curve segments. The two-argument version of this method returns a PathIterator that is guaranteed to trace the outline using only straight line segments and no curves. The flatness argument is a measure of how closely the line segments must approximate the actual outline. Smaller values of flatness require increasingly accurate approximations.

The Shape interface was first defined in Java 1.1. In that version of the language it contained only the getBounds() method. The interface is so central to Java 2D and has grown so much since the Java 1.1 version, however, that it should generally be considered to be new in Java 1.2.

public abstract interface Shape {
// Public Instance Methods
1.2public abstract boolean contains (java.awt.geom.Point2D p);
1.2public abstract boolean contains (java.awt.geom.Rectangle2D r);
1.2public abstract boolean contains (double x, double y);
1.2public abstract boolean contains (double x, double y, double w, double h);
public abstract Rectangle getBounds ();
1.2public abstract java.awt.geom.Rectangle2D getBounds2D ();
1.2public abstract java.awt.geom.PathIterator getPathIterator (java.awt.geom.AffineTransform at);
1.2public abstract java.awt.geom.PathIterator getPathIterator (java.awt.geom.AffineTransform at, double flatness);
1.2public abstract boolean intersects (java.awt.geom.Rectangle2D r);
1.2public abstract boolean intersects (double x, double y, double w, double h);
}

Implementations: Polygon, Rectangle, java.awt.geom.Area, java.awt.geom.CubicCurve2D, java.awt.geom.GeneralPath, java.awt.geom.Line2D, java.awt.geom.QuadCurve2D, java.awt.geom.RectangularShape

Passed To: Too many methods to list.

Returned By: Too many methods to list.

StrokeJava 1.2
java.awt

This interface defines how Java 2D draws the outline of a shape. It is responsible for graphical attributes such as line width and dash pattern. However, the Stroke is not responsible for the color or texture of the outline--those are the responsibility of the Paint interface. By default, lines are solid and are one pixel wide. To specify a different line style, pass a Stroke object to the setStroke() method of a Graphics2D object.

Mathematically, the outline of a shape is an infinitely thin line. Because it has no thickness, it cannot be drawn. The Stroke interface is responsible for defining how such infinitely thin outlines are drawn. The createStrokedShape() method is passed the Shape that is to be drawn. It returns a new Shape that places a finite width around the infinitely thin boundaries of the specified shape. The outline of the original shape can then be drawn by filling the interior of the returned shape.

BasicStroke implements Stroke and is the only implementation needed by most programs. Some programs may define their own implementations to achieve special effects not possible with BasicStroke, however.

public abstract interface Stroke {
// Public Instance Methods
public abstract Shape createStrokedShape (Shape p);
}

Implementations: BasicStroke

Passed To: Graphics2D.setStroke()

Returned By: Graphics2D.getStroke()

SystemColorJava 1.1
java.awtserializable PJ1.1

Instances of the SystemColor class represent colors used in the system desktop. You can use these colors to produce applications and custom components that fit well in the desktop color scheme. On platforms that allow the desktop colors to be modified dynamically, the actual colors represented by these symbolic system colors may be dynamically updated.

The SystemColor class does not have a constructor, but it defines constant SystemColor objects that represent each of the symbolic colors used by the system desktop. If you need to compare a SystemColor object to a regular Color object, use the getRGB() method of both objects and compare the resulting values.

public final class SystemColor extends Color implements Serializable {
// No Constructor
// Public Constants
public static final int ACTIVE_CAPTION ; =1
public static final int ACTIVE_CAPTION_BORDER ; =3
public static final int ACTIVE_CAPTION_TEXT ; =2
public static final SystemColor activeCaption ;
public static final SystemColor activeCaptionBorder ;
public static final SystemColor activeCaptionText ;
public static final SystemColor control ;
public static final int CONTROL ; =17
public static final int CONTROL_DK_SHADOW ; =22
public static final int CONTROL_HIGHLIGHT ; =19
public static final int CONTROL_LT_HIGHLIGHT ; =20
public static final int CONTROL_SHADOW ; =21
public static final int CONTROL_TEXT ; =18
public static final SystemColor controlDkShadow ;
public static final SystemColor controlHighlight ;
public static final SystemColor controlLtHighlight ;
public static final SystemColor controlShadow ;
public static final SystemColor controlText ;
public static final SystemColor desktop ;
public static final int DESKTOP ; =0
public static final int INACTIVE_CAPTION ; =4
public static final int INACTIVE_CAPTION_BORDER ; =6
public static final int INACTIVE_CAPTION_TEXT ; =5
public static final SystemColor inactiveCaption ;
public static final SystemColor inactiveCaptionBorder ;
public static final SystemColor inactiveCaptionText ;
public static final SystemColor info ;
public static final int INFO ; =24
public static final int INFO_TEXT ; =25
public static final SystemColor infoText ;
public static final SystemColor menu ;
public static final int MENU ; =10
public static final int MENU_TEXT ; =11
public static final SystemColor menuText ;
public static final int NUM_COLORS ; =26
public static final SystemColor scrollbar ;
public static final int SCROLLBAR ; =23
public static final int TEXT ; =12
public static final SystemColor text ;
public static final int TEXT_HIGHLIGHT ; =14
public static final int TEXT_HIGHLIGHT_TEXT ; =15
public static final int TEXT_INACTIVE_TEXT ; =16
public static final int TEXT_TEXT ; =13
public static final SystemColor textHighlight ;
public static final SystemColor textHighlightText ;
public static final SystemColor textInactiveText ;
public static final SystemColor textText ;
public static final int WINDOW ; =7
public static final SystemColor window ;
public static final int WINDOW_BORDER ; =8
public static final int WINDOW_TEXT ; =9
public static final SystemColor windowBorder ;
public static final SystemColor windowText ;
// Public Methods Overriding Color
1.2public PaintContext createContext (java.awt.image.ColorModel cm, Rectangle r, java.awt.geom.Rectangle2D r2d, java.awt.geom.AffineTransform xform, RenderingHints hints);
public int getRGB ();
public String toString ();
}

Hierarchy: Object-->Color(Paint(Transparency),Serializable)-->SystemColor(Serializable)

Type Of: Too many fields to list.

TextAreaJava 1.0
java.awtserializable AWT component PJ1.1(mod)

This class is a GUI component that displays and optionally edits multiline text. The appendText(), insertText(), and replaceText() methods provide various techniques for specifying text to appear in the TextArea. Many important TextArea methods are defined by its TextComponent superclass. See also TextComponent and TextField.

The four-argument version of the TextArea() constructor allows you to specify a scrollbar display policy for the TextArea object. Personal Java environments can define a scrolling mechanism other than scrollbars. In this case, the scrollbar display policy can be ignored.

public class TextArea extends TextComponent {
// Public Constructors
public TextArea ();
public TextArea (String text);
public TextArea (int rows, int columns);
public TextArea (String text, int rows, int columns);
1.1public TextArea (String text, int rows, int columns, int scrollbars);
// Public Constants
1.1public static final int SCROLLBARS_BOTH ; =0
1.1public static final int SCROLLBARS_HORIZONTAL_ONLY ; =2
1.1public static final int SCROLLBARS_NONE ; =3
1.1public static final int SCROLLBARS_VERTICAL_ONLY ; =1
// Property Accessor Methods (by property name)
public int getColumns (); default:0
1.1public void setColumns (int columns);
1.1public Dimension getMinimumSize (); Overrides:Component
1.1public Dimension getMinimumSize (int rows, int columns);
1.1public Dimension getPreferredSize (); Overrides:Component
1.1public Dimension getPreferredSize (int rows, int columns);
public int getRows (); default:0
1.1public void setRows (int rows);
1.1public int getScrollbarVisibility (); default:0
// Public Instance Methods
1.1public void append (String str);
1.1public void insert (String str, int pos);
1.1public void replaceRange (String str, int start, int end);
// Protected Methods Overriding TextComponent
protected String paramString ();
// Public Methods Overriding Component
public void addNotify ();
// Deprecated Public Methods
#public void appendText (String str); synchronized
#public void insertText (String str, int pos); synchronized
#public Dimension minimumSize (); Overrides:Component
#public Dimension minimumSize (int rows, int columns);
#public Dimension preferredSize (); Overrides:Component
#public Dimension preferredSize (int rows, int columns);
#public void replaceText (String str, int start, int end); synchronized
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->TextComponent-->TextArea

Passed To: Toolkit.createTextArea()

TextComponentJava 1.0
java.awtserializable AWT component PJ1.1

This class is the superclass of the TextArea and TextField components. It cannot be instantiated itself but provides methods that are common to these two component types. setEditable() specifies whether the text in the component is editable. getText() returns the text in the component, and setText() specifies text to be displayed. getSelectedText() returns the currently selected text in the component, and getSelectionStart() and getSelectionEnd() return the extents of the selected region of text. select() and selectAll() select some and all of the text displayed in the text component, respectively.

See also TextField and TextArea.

public class TextComponent extends Component {
// No Constructor
// Event Registration Methods (by event name)
1.1public void addTextListener (java.awt.event.TextListener l); synchronized
1.1public void removeTextListener (java.awt.event.TextListener l); synchronized
// Property Accessor Methods (by property name)
1.1public int getCaretPosition (); synchronized
1.1public void setCaretPosition (int position); synchronized
public boolean isEditable ();
public void setEditable (boolean b); synchronized
public String getSelectedText (); synchronized
public int getSelectionEnd (); synchronized
1.1public void setSelectionEnd (int selectionEnd); synchronized
public int getSelectionStart (); synchronized
1.1public void setSelectionStart (int selectionStart); synchronized
public String getText (); synchronized
public void setText (String t); synchronized
// Public Instance Methods
public void select (int selectionStart, int selectionEnd); synchronized
public void selectAll (); synchronized
// Public Methods Overriding Component
public void removeNotify ();
// Protected Methods Overriding Component
protected String paramString ();
1.1protected void processEvent (AWTEvent e);
// Protected Instance Methods
1.1protected void processTextEvent (java.awt.event.TextEvent e);
// Protected Instance Fields
1.1protected transient java.awt.event.TextListener textListener ;
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->TextComponent

Subclasses: TextArea, TextField

TextFieldJava 1.0
java.awtserializable AWT component PJ1.1

This Component displays a single line of optionally editable text. Most of its interesting methods are defined by its TextComponent superclass. Use setEchoChar() to specify a character to be echoed when requesting sensitive input, such as a password.

See also TextComponent and TextArea.

public class TextField extends TextComponent {
// Public Constructors
public TextField ();
public TextField (int columns);
public TextField (String text);
public TextField (String text, int columns);
// Event Registration Methods (by event name)
1.1public void addActionListener (java.awt.event.ActionListener l); synchronized
1.1public void removeActionListener (java.awt.event.ActionListener l); synchronized
// Property Accessor Methods (by property name)
public int getColumns (); default:0
1.1public void setColumns (int columns); synchronized
public char getEchoChar (); default:\0
1.1public void setEchoChar (char c);
1.1public Dimension getMinimumSize (); Overrides:Component
1.1public Dimension getMinimumSize (int columns);
1.1public Dimension getPreferredSize (); Overrides:Component
1.1public Dimension getPreferredSize (int columns);
1.2public void setText (String t); Overrides:TextComponent
// Public Instance Methods
public boolean echoCharIsSet ();
// Protected Methods Overriding TextComponent
protected String paramString ();
1.1protected void processEvent (AWTEvent e);
// Public Methods Overriding Component
public void addNotify ();
// Protected Instance Methods
1.1protected void processActionEvent (java.awt.event.ActionEvent e);
// Deprecated Public Methods
#public Dimension minimumSize (); Overrides:Component
#public Dimension minimumSize (int columns);
#public Dimension preferredSize (); Overrides:Component
#public Dimension preferredSize (int columns);
#public void setEchoCharacter (char c); synchronized
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->TextComponent-->TextField

Passed To: Toolkit.createTextField()

TexturePaintJava 1.2
java.awt

This implementation of Paint is used to perform Java 2D drawing and filling operations with a texture or pattern of colors defined in a BufferedImage object.

When you create a TexturePaint object, you must specify the BufferedImage that defines the texture. You must also specify a rectangle that defines both the initial position of the image and the tile size with which the image is replicated. Typically, you specify a rectangle with its upper-left corner at (0,0) and a width and height equal to the width and height of the image

public class TexturePaint implements Paint {
// Public Constructors
public TexturePaint (java.awt.image.BufferedImage txtr, java.awt.geom.Rectangle2D anchor);
// Public Instance Methods
public java.awt.geom.Rectangle2D getAnchorRect ();
public java.awt.image.BufferedImage getImage ();
// Methods Implementing Paint
public PaintContext createContext (java.awt.image.ColorModel cm, Rectangle deviceBounds, java.awt.geom.Rectangle2D userBounds, java.awt.geom.AffineTransform xform, RenderingHints hints);
// Methods Implementing Transparency
public int getTransparency ();
}

Hierarchy: Object-->TexturePaint(Paint(Transparency))

ToolkitJava 1.0
java.awtPJ1.1(mod)

This abstract class defines methods that, when implemented, create platform-dependent peers for each of the Component types in java.awt. Java supports its platform-independent GUI interface by implementing a subclass of Toolkit for each platform. Portable programs should never use these methods to create peers directly--they should use the Component classes themselves. A Toolkit object cannot be instantiated directly. The getToolkit() method of Component returns the Toolkit being used for a particular component.

The Toolkit class also defines methods that you can use directly. The static method getDefaultToolkit() returns the default Toolkit that is in use. getScreenSize() returns the screen size in pixels, and getScreenResolution() returns the resolution in dots per inch. sync() flushes all pending graphics output, which can be useful for animation. Other methods of interest include beep(), getSystemClipboard(), createCustomCursor(), and addAWTEventListener(). getPrintJob() is part of the Java 1.1 printing API. In Personal Java environments, printing support is optional, and this method can throw an exception.

public abstract class Toolkit {
// Public Constructors
public Toolkit ();
// Public Class Methods
public static Toolkit getDefaultToolkit (); synchronized
1.1public static String getProperty (String key, String defaultValue);
// Protected Class Methods
1.1protected static Container getNativeContainer (Component c);
// Event Registration Methods (by event name)
1.2public void removeAWTEventListener (java.awt.event.AWTEventListener listener);
// Property Accessor Methods (by property name)
public abstract java.awt.image.ColorModel getColorModel ();
1.2public int getMaximumCursorColors (); constant
1.1public int getMenuShortcutKeyMask (); constant
public abstract int getScreenResolution ();
public abstract Dimension getScreenSize ();
1.1public abstract java.awt.datatransfer.Clipboard getSystemClipboard ();
1.1public final EventQueue getSystemEventQueue ();
// Public Instance Methods
1.2public void addAWTEventListener (java.awt.event.AWTEventListener listener, long eventMask);
1.2public void addPropertyChangeListener (String name, java.beans.PropertyChangeListener pcl); synchronized
1.1public abstract void beep ();
public abstract int checkImage (Image image, int width, int height, java.awt.image.ImageObserver observer);
1.2public Cursor createCustomCursor (Image cursor, Point hotSpot, String name) throws IndexOutOfBoundsException;
1.2public java.awt.dnd.DragGestureRecognizer createDragGestureRecognizer (Class abstractRecognizerClass, java.awt.dnd.DragSource ds, Component c, int srcActions, java.awt.dnd.DragGestureListener dgl); constant
1.2public abstract java.awt.dnd.peer.DragSourceContextPeer createDragSourceContextPeer (java.awt.dnd.DragGestureEvent dge) throws java.awt.dnd.InvalidDnDOperationException;
1.2public abstract Image createImage (java.net.URL url);
1.1public Image createImage (byte[ ] imagedata);
1.2public abstract Image createImage (String filename);
public abstract Image createImage (java.awt.image.ImageProducer producer);
1.1public abstract Image createImage (byte[ ] imagedata, int imageoffset, int imagelength);
1.2public Dimension getBestCursorSize (int preferredWidth, int preferredHeight);
1.2public final Object getDesktopProperty (String propertyName); synchronized
public abstract Image getImage (java.net.URL url);
public abstract Image getImage (String filename);
1.1public abstract PrintJob getPrintJob (Frame frame, String jobtitle, java.util.Properties props);
public abstract boolean prepareImage (Image image, int width, int height, java.awt.image.ImageObserver observer);
1.2public void removePropertyChangeListener (String name, java.beans.PropertyChangeListener pcl); synchronized
public abstract void sync ();
// Protected Instance Methods
protected abstract java.awt.peer.ButtonPeer createButton (Button target);
protected abstract java.awt.peer.CanvasPeer createCanvas (Canvas target);
protected abstract java.awt.peer.CheckboxPeer createCheckbox (Checkbox target);
protected abstract java.awt.peer.CheckboxMenuItemPeer createCheckboxMenuItem (CheckboxMenuItem target);
protected abstract java.awt.peer.ChoicePeer createChoice (Choice target);
1.1protected java.awt.peer.LightweightPeer createComponent (Component target);
protected abstract java.awt.peer.DialogPeer createDialog (Dialog target);
protected abstract java.awt.peer.FileDialogPeer createFileDialog (FileDialog target);
protected abstract java.awt.peer.FramePeer createFrame (Frame target);
protected abstract java.awt.peer.LabelPeer createLabel (Label target);
protected abstract java.awt.peer.ListPeer createList (java.awt.List target);
protected abstract java.awt.peer.MenuPeer createMenu (Menu target);
protected abstract java.awt.peer.MenuBarPeer createMenuBar (MenuBar target);
protected abstract java.awt.peer.MenuItemPeer createMenuItem (MenuItem target);
protected abstract java.awt.peer.PanelPeer createPanel (Panel target);
1.1protected abstract java.awt.peer.PopupMenuPeer createPopupMenu (PopupMenu target);
protected abstract java.awt.peer.ScrollbarPeer createScrollbar (Scrollbar target);
1.1protected abstract java.awt.peer.ScrollPanePeer createScrollPane (ScrollPane target);
protected abstract java.awt.peer.TextAreaPeer createTextArea (TextArea target);
protected abstract java.awt.peer.TextFieldPeer createTextField (TextField target);
protected abstract java.awt.peer.WindowPeer createWindow (Window target);
1.1protected abstract EventQueue getSystemEventQueueImpl ();
1.2protected void initializeDesktopProperties (); empty
1.2protected Object lazilyLoadDesktopProperty (String name); constant
1.1protected void loadSystemColors (int[ ] systemColors); empty
1.2protected final void setDesktopProperty (String name, Object newValue); synchronized
// Protected Instance Fields
1.2protected final java.util.Map desktopProperties ;
1.2protected final java.beans.PropertyChangeSupport desktopPropsSupport ;
// Deprecated Public Methods
#public abstract String[ ] getFontList ();
#public abstract FontMetrics getFontMetrics (Font font);
// Deprecated Protected Methods
1.1#protected abstract java.awt.peer.FontPeer getFontPeer (String name, int style);
}

Returned By: Component.getToolkit(), Toolkit.getDefaultToolkit(), Window.getToolkit(), java.awt.peer.ComponentPeer.getToolkit()

TransparencyJava 1.2
java.awt

The integer constants defined by this interface identify the three types of transparency supported by Java 2D. Although the Transparency interface is implemented only by a couple of Java 2D classes, the constants it defines are more widely used. These constants are:

OPAQUE

All colors are fully opaque, with no transparency. The alpha value of every pixel is 1.0.

BITMASK

Colors are either fully opaque or fully transparent, as specified by the bits in a bit mask. That is, each pixel has 1 bit associated with it that specifies whether the pixel is opaque (alpha is 1.0) or transparent (alpha is 0.0).

TRANSLUCENT

Colors may be totally opaque, totally transparent, or translucent. This model of transparency uses an alpha channel that is wider than 1 bit and supports a number of alpha transparency levels between 1.0 and 0.0.

public abstract interface Transparency {
// Public Constants
public static final int BITMASK ; =2
public static final int OPAQUE ; =1
public static final int TRANSLUCENT ; =3
// Public Instance Methods
public abstract int getTransparency ();
}

Implementations: Paint, java.awt.image.ColorModel

WindowJava 1.0
java.awtserializable AWT component PJ1.1(mod)

This class represents a top-level window with no borders or menu bar. Window is a Container with BorderLayout as its default layout manager. Window is rarely used directly; its subclasses Frame and Dialog are more commonly useful.

show() (which overrides the show() method of Component) makes a Window visible and brings it to the front of other windows. toFront() brings a window to the front, and toBack() buries a window beneath others. pack() is an important method that initiates layout management for the window, setting the window size to match the preferred size of the components contained within the window. getToolkit() returns the Toolkit() in use for this window. Call dispose() when a Window is no longer needed, to free its window system resources.

Although the Window class is part of the Personal Java API, Personal Java implementations can prohibit the creation of Window objects. In this case, the Window() constructor throws an exception.

public class Window extends Container {
// Public Constructors
1.2public Window (Window owner);
public Window (Frame owner);
// Event Registration Methods (by event name)
1.1public void addWindowListener (java.awt.event.WindowListener l); synchronized
1.1public void removeWindowListener (java.awt.event.WindowListener l); synchronized
// Property Accessor Methods (by property name)
1.1public Component getFocusOwner ();
1.2public java.awt.im.InputContext getInputContext (); Overrides:Component
1.1public java.util.Locale getLocale (); Overrides:Component
1.2public Window[ ] getOwnedWindows ();
1.2public Window getOwner ();
1.1public boolean isShowing (); Overrides:Component
public Toolkit getToolkit (); Overrides:Component
public final String getWarningString ();
// Public Instance Methods
1.2public void applyResourceBundle (java.util.ResourceBundle rb);
1.2public void applyResourceBundle (String rbName);
public void dispose ();
public void pack ();
public void toBack ();
public void toFront ();
// Public Methods Overriding Container
public void addNotify ();
1.2public void setCursor (Cursor cursor); synchronized
// Protected Methods Overriding Container
1.1protected void processEvent (AWTEvent e);
// Public Methods Overriding Component
1.2public void hide ();
public void show ();
// Protected Methods Overriding Object
1.2protected void finalize () throws Throwable;
// Protected Instance Methods
1.1protected void processWindowEvent (java.awt.event.WindowEvent e);
// Deprecated Public Methods
1.1#public boolean postEvent (Event e); Overrides:Component
}

Hierarchy: Object-->Component(java.awt.image.ImageObserver,MenuContainer,Serializable)-->Container-->Window

Subclasses: Dialog, Frame, javax.swing.JWindow

Passed To: Toolkit.createWindow(), Window.Window(), java.awt.event.WindowEvent.WindowEvent(), javax.swing.JWindow.JWindow()

Returned By: Window.{getOwnedWindows(), getOwner()}, java.awt.event.WindowEvent.getWindow(), javax.swing.SwingUtilities.windowForComponent()



Library Navigation Links

Copyright © 2001 O'Reilly & Associates. All rights reserved.







??????????????@Mail.ru