Drag and Drop is a direct manipulation gesture found in many Graphical
User Interface systems that provides a mechanism to transfer
information between two entities logically associated with presentation
elements in the GUI.

This package provides the classes necessary for services
to interact with applications in order to retrieve
information (authentication data including usernames
or passwords, for example) or to display information
(error and warning messages, for example).

Provides the API that defines the contract between the transaction
manager and the resource manager, which allows the transaction
manager to enlist and delist resource objects (supplied by the
resource manager driver) in JTA transactions.

This package presents a framework that allows application developers to
make use of security services like authentication, data integrity and
data confidentiality from a variety of underlying security mechanisms
like Kerberos, using a unified API.

Provides the mapping of the OMG CORBA APIs to the JavaTM
programming language, including the class ORB, which is implemented
so that a programmer can use it as a fully-functional Object Request Broker
(ORB).

Provides the exception InvalidName, which is thrown
by the method ORB.resolve_initial_references
and the exception InconsistentTypeCode, which is thrown
by the Dynamic Any creation methods in the ORB class.

This package contains the exceptions and typedefs from the ORBInitInfo
local interface of the PortableInterceptor module specified in the OMG
Portable Interceptor specification,
http://cgi.omg.org/cgi-bin/doc?ptc/2000-08-06, section 21.7.2.

The IllegalPathStateException represents an
exception that is thrown if an operation is performed on a path
that is in an illegal state with respect to the particular
operation being performed, such as appending a path segment
to a GeneralPath without an initial moveto.

The NoninvertibleTransformException class represents
an exception that is thrown if an operation is performed requiring
the inverse of an AffineTransform object but the
AffineTransform is in a non-invertible state.

An IllegalAccessException is thrown when an application tries
to reflectively create an instance (other than an array),
set or get a field, or invoke a method, but the currently
executing method does not have access to the definition of
the specified class, field, method or constructor.

Thrown by a method invocation on a proxy instance if its invocation
handler's invoke method throws a
checked exception (a Throwable that is not assignable
to RuntimeException or Error) that
is not assignable to any of the exception types declared in the
throws clause of the method that was invoked on the
proxy instance and dispatched to the invocation handler.

Unchecked exception thrown when an attempt is made to acquire a lock on a
region of a file that overlaps a region already locked by the same Java
virtual machine, or when another thread is already waiting to lock an
overlapping region of the same file.

Unchecked exception thrown when an attempt is made to construct a channel in
a group that is shutdown or the completion handler for an I/O operation
cannot be invoked because the channel group has terminated.

An AccessException is thrown by certain methods of the
java.rmi.Naming class (specifically bind,
rebind, and unbind) and methods of the
java.rmi.activation.ActivationSystem interface to
indicate that the caller does not have permission to perform the action
requested by the method call.

A ServerError is thrown as a result of a remote method
invocation when an Error is thrown while processing
the invocation on the server, either while unmarshalling the arguments,
executing the remote method itself, or marshalling the return value.

A ServerException is thrown as a result of a remote method
invocation when a RemoteException is thrown while processing
the invocation on the server, either while unmarshalling the arguments or
executing the remote method itself.

An UnexpectedException is thrown if the client of a
remote method call receives, as a result of the call, a checked
exception that is not among the checked exception types declared in the
throws clause of the method in the remote interface.

An UnmarshalException can be thrown while unmarshalling the
parameters or results of a remote method call if any of the following
conditions occur:
if an exception occurs while unmarshalling the call header
if the protocol for the return value is invalid
if a java.io.IOException occurs unmarshalling
parameters (on the server side) or the return value (on the client side).

An UnknownGroupException is thrown by methods of classes and
interfaces in the java.rmi.activation package when the
ActivationGroupID parameter to the method is determined to be
invalid, i.e., not known by the ActivationSystem.

1.2 style stubs no longer use this method. Instead of
using a sequence of method calls to the remote reference
(newCall, invoke, and done), a
stub uses a single method, invoke(Remote, Method, Object[],
int), on the remote reference to carry out parameter
marshalling, remote method executing and unmarshalling of the return
value.

This exception is thrown by
doPrivileged(PrivilegedExceptionAction) and
doPrivileged(PrivilegedExceptionAction,
AccessControlContext context) to indicate
that the action being performed threw a checked exception.

A runtime exception for Provider exceptions (such as
misconfiguration errors or unrecoverable internal errors),
which may be subclassed by Providers to
throw specialized, provider-specific runtime errors.

This is an exception that is thrown whenever the modification of an object
(such as an Access Control List) is only allowed to be done by an owner of
the object, but the Principal attempting the modification is not an owner.

An exception thrown as a DataTruncation exception
(on writes) or reported as a
DataTruncation warning (on reads)
when a data values is unexpectedly truncated for reasons other than its having
execeeded MaxFieldSize.

The subclass of SQLException thrown in situations where a
previously failed operation might be able to succeed if the application performs
some recovery steps and retries the entire transaction or in the case of a
distributed transaction, the transaction branch.

The subclass of SQLException is thrown in situations where a
previoulsy failed operation might be able to succeed when the operation is
retried without any intervention by application-level functionality.

This exception may be thrown on any method for which Activity context
is accessed and indicates that the attempted invocation or the Activity
context associated with the attempted invocation is incompatible with
the Activity's current state.

This exception is thrown when an attempt is
made to add, or remove, or modify an attribute, its identifier,
or its values that conflicts with the attribute's (schema) definition
or the attribute's state.

The INVALID_ACTIVITY system exception may be raised on the
Activity or Transaction services' resume methods if a transaction or
Activity is resumed in a context different to that from which it was
suspended.

This exception typically indicates an administrative mismatch, for
example, a server may have made an attempt to register itself with
an implementation repository under a name that is already in use,
or is unknown to the repository.

REBIND is raised when the current effective RebindPolicy,
has a value of NO_REBIND or NO_RECONNECT and an invocation on a bound
object reference results in a LocateReply message with status
OBJECT_FORWARD or a Reply message with status LOCATION_FORWARD.

This exception is raised if an operation implementation
throws a non-CORBA exception (such as an exception
specific to the implementation's programming language),
or if an operation raises a user exception that does not
appear in the operation's raises expression.

DOM operations only raise exceptions in "exceptional" circumstances, i.e.,
when an operation is impossible to perform (either for logical reasons,
because data is lost, or because the implementation has become unstable).