<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<!--
Copyright 1998-2001 Sun Microsystems, Inc.  All Rights Reserved.
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

This code is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 only, as
published by the Free Software Foundation.  Sun designates this
particular file as subject to the "Classpath" exception as provided
by Sun in the LICENSE file that accompanied this code.

This code is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
version 2 for more details (a copy is included in the LICENSE file that
accompanied this code).

You should have received a copy of the GNU General Public License version
2 along with this work; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
CA 95054 USA or visit www.sun.com if you need additional information or
have any questions.
-->

</head>
<body bgcolor="white">

Provides user interface objects built according to the
Basic look and feel. The Basic look and feel provides default 
behavior used by many look and feel packages. 
It contains components, layout managers,
events, event listeners, and adapters. 
You can subclass the classes in
this package to create your own customized look and feel.

<p>These classes are designed to be used while the
corresponding <code>LookAndFeel</code> class has been
installed
(<code>UIManager.setLookAndFeel(new <i>XXX</i>LookAndFeel())</code>).
Using them while a different <code>LookAndFeel</code> is installed
may produce unexpected results, including exceptions.
Additionally, changing the <code>LookAndFeel</code>
maintained by the <code>UIManager</code> without updating the
corresponding <code>ComponentUI</code> of any
<code>JComponent</code>s may also produce unexpected results,
such as the wrong colors showing up, and is generally not
encouraged.

<p>
<strong>Note:</strong>
Most of the Swing API is <em>not</em> thread safe.
For details, see
<a
href="http://java.sun.com/docs/books/tutorial/uiswing/overview/threads.html"
target="_top">Threads and Swing</a>,
a section in
<em><a href="http://java.sun.com/docs/books/tutorial/"
target="_top">The Java Tutorial</a></em>.

@since 1.2
@serial exclude

</body>
</html>
