Returns true if the specified x,y location is contained within the look and feel's defined shape of the specified component.

  Returns true if the specified x,y location is
contained within the look and feel's defined shape of the specified
component. x and y are defined to be relative
to the coordinate system of the specified component. Although
a component's bounds is constrained to a rectangle,
this method provides the means for defining a non-rectangular
shape within those bounds for the purpose of hit detection.
Parameters:
- c - the component where the x,y location is being queried; this argument is often ignored, but might be used if the UI object is stateless and shared by multiple components
- x - the x coordinate of the point
- y - the y coordinate of the point
See Also: JComponent.contains(int, int), Component.contains(int, int),

  Creates a view for an element.

  Creates a view for an element.
If a subclass wishes to directly implement the factory
producing the view(s), it should reimplement this
method. By default it simply returns null indicating
it is unable to represent the element.
Returns: the view
Parameters:
- elem - the element

  Creates a view for an element.

  Creates a view for an element.
If a subclass wishes to directly implement the factory
producing the view(s), it should reimplement this
method. By default it simply returns null indicating
it is unable to represent the part of the element.
Returns: the view
Parameters:
- elem - the element
- p0 - the starting offset >= 0
- p1 - the ending offset >= p0

  Creates the object to use for a caret.

  Creates the object to use for a caret. By default an
instance of BasicCaret is created. This method
can be redefined to provide something else that implements
the InputPosition interface or a subclass of JCaret.
Returns: the caret object

  Creates the object to use for adding highlights.

  Creates the object to use for adding highlights. By default
an instance of BasicHighlighter is created. This method
can be redefined to provide something else that implements
the Highlighter interface or a subclass of DefaultHighlighter.
Returns: the highlighter

  Creates the keymap to use for the text component, and installs any necessary bindings into it.

  Creates the keymap to use for the text component, and installs any necessary bindings into it. By default, the keymap is shared between all instances of this type of TextUI. The keymap has the name defined by the getKeymapName method. If the keymap is not found, then DEFAULT_KEYMAP from JTextComponent is used.

The set of bindings used to create the keymap is fetched from the UIManager using a key formed by combining the BasicTextUI.getPropertyPrefix() method and the string .keyBindings. The type is expected to be JTextComponent.KeyBinding[].
Returns: the keymap
See Also: BasicTextUI.getKeymapName(), JTextComponent,

  Returns an instance of the UI delegate for the specified component.

  Returns an instance of the UI delegate for the specified component.
Each subclass must provide its own static createUI
method that returns an instance of that UI delegate subclass.
If the UI delegate subclass is stateless, it may return an instance
that is shared by multiple components. If the UI delegate is
stateful, then it should return a new instance per component.
The default implementation of this method throws an error, as it
should never be invoked.

  Causes the portion of the view responsible for the given part of the model to be repainted.

  Causes the portion of the view responsible for the
given part of the model to be repainted. Does nothing if
the view is not currently painted.
Parameters:
- tc - the text component for which this UI is installed
- p0 - the beginning of the range >= 0
- p1 - the end of the range >= p0
See Also: TextUI.damageRange(javax.swing.text.JTextComponent, int, int),

  Causes the portion of the view responsible for the given part of the model to be repainted.

  Causes the portion of the view responsible for the
given part of the model to be repainted.
Parameters:
- p0 - the beginning of the range >= 0
- p1 - the end of the range >= p0

  Returns the ith Accessible child of the object.

  Returns the ith Accessible child of the object. UIs might need to override this if they present areas on the screen that can be viewed as components, but actual components are not used for presenting those areas.

Note: As of v1.3, it is recommended that developers call Component.AccessibleAWTComponent.getAccessibleChild() instead of this method.
Returns: the ith Accessible child of the object
Parameters:
- i - zero-based index of child
See Also: ComponentUI.getAccessibleChildrenCount(javax.swing.JComponent),

  Returns the number of accessible children in the object.

  Returns the number of accessible children in the object. If all
of the children of this object implement Accessible,
this
method should return the number of children of this object.
UIs might wish to override this if they present areas on the
screen that can be viewed as components, but actual components
are not used for presenting those areas.

Note: As of v1.3, it is recommended that developers call
Component.AccessibleAWTComponent.getAccessibleChildrenCount() instead
of this method.
Returns: the number of accessible children in the object
See Also: ComponentUI.getAccessibleChild(javax.swing.JComponent, int),

  Returns the baseline.

  Returns the baseline. The baseline is measured from the top of the component. This method is primarily meant for LayoutManagers to align components along their baseline. A return value less than 0 indicates this component does not have a reasonable baseline and that LayoutManagers should not align this component on its baseline.

This method returns -1. Subclasses that have a meaningful baseline should override appropriately.
Returns: baseline or a value < 0 indicating there is no reasonable baseline
Parameters:
- c - JComponent baseline is being requested for
- width - the width to get the baseline for
- height - the height to get the baseline for
Throws:
- NullPointerException - if c is null
- IllegalArgumentException - if width or height is < 0
Since: 1.6
See Also: JComponent.getBaseline(int,int),

  Returns an enum indicating how the baseline of he component changes as the size changes.

  Returns an enum indicating how the baseline of he component changes as the size changes. This method is primarily meant for layout managers and GUI builders.

This method returns BaselineResizeBehavior.OTHER. Subclasses that support a baseline should override appropriately.
Returns: an enum indicating how the baseline changes as the component size changes
Parameters:
- c - JComponent to return baseline resize behavior for
Throws:
- NullPointerException - if c is null
Since: 1.6
See Also: JComponent.getBaseline(int, int),

  Fetches the text component associated with this UI implementation.

  Fetches the text component associated with this
UI implementation. This will be null until
the ui has been installed.
Returns: the editor component

  Fetches the EditorKit for the UI.

  Fetches the EditorKit for the UI.
Returns: the editor capabilities
Parameters:
- tc - the text component for which this UI is installed
See Also: TextUI.getEditorKit(javax.swing.text.JTextComponent),

  Fetches the name of the keymap that will be installed/used by default for this UI.

  Fetches the name of the keymap that will be installed/used
by default for this UI. This is implemented to create a
name based upon the classname. The name is the the name
of the class with the package prefix removed.
Returns: the name

  Gets the maximum size for the editor component.

  Gets the maximum size for the editor component.
Returns: the size
Parameters:
- c - the editor component

  Gets the minimum size for the editor component.

  Gets the minimum size for the editor component.
Returns: the size
Parameters:
- c - the editor component

  Provides a way to determine the next visually represented model location that one might place a caret.

  Provides a way to determine the next visually represented model
location that one might place a caret. Some views may not be visible,
they might not be in the same order found in the model, or they just
might not allow access to some of the locations in the model.

  Gets the preferred size for the editor component.

  Gets the preferred size for the editor component. If the component
has been given a size prior to receiving this request, it will
set the size of the view hierarchy to reflect the size of the component
before requesting the preferred size of the view hierarchy. This
allows formatted views to format to the current component size before
answering the request. Other views don't care about currently formatted
size and give the same answer either way.
Returns: the size
Parameters:
- c - the editor component

  Gets the name used as a key to look up properties through the UIManager.

  Gets the name used as a key to look up properties through the
UIManager. This is used as a prefix to all the standard
text properties.
Returns: the name

  Fetches a View with the allocation of the associated text component (i.e.

  Fetches a View with the allocation of the associated text component (i.e. the root of the hierarchy) that can be traversed to determine how the model is being represented spatially.

NOTE:The View hierarchy can be traversed from the root view, and other things can be done as well. Things done in this way cannot be protected like simple method calls through the TextUI. Therefore, proper operation in the presence of concurrency must be arranged by any logic that calls this method!
Returns: the view
Parameters:
- tc - the text component for which this UI is installed
See Also: TextUI.getRootView(javax.swing.text.JTextComponent),

  Returns the string to be used as the tooltip at the passed in location.

  Returns the string to be used as the tooltip at the passed in location.
This forwards the method onto the root View.
Since: 1.4
See Also: JTextComponent.getToolTipText(java.awt.event.MouseEvent), View.getToolTipText(float, float, java.awt.Shape),

  Gets the allocation to give the root View.

  Gets the allocation to give the root View. Due
to an unfortunate set of historical events this
method is inappropriately named. The Rectangle
returned has nothing to do with visibility.
The component must have a non-zero positive size for
this translation to be computed.
Returns: the bounding box for the root view

  Initializes component properties, e.g.

  Initializes component properties, e.g. font, foreground,
background, caret color, selection color, selected text color,
disabled text color, and border color. The font, foreground, and
background properties are only set if their current value is either null
or a UIResource, other properties are set if the current
value is null.
See Also: BasicTextUI.uninstallDefaults(), BasicTextUI.installUI(javax.swing.JComponent),

Installs listeners for the UI.

  Installs the UI for a component.

  Installs the UI for a component. This does the following
things.

1. 
   Set the associated component to opaque (can be changed
   easily by a subclass or on JTextComponent directly),
   which is the most common case. This will cause the
   component's background color to be painted.
   
2. 
   Install the default caret and highlighter into the
   associated component.
   
3. 
   Attach to the editor and model. If there is no
   model, a default one is created.
   
4. 
   create the view factory and the view hierarchy used
   to represent the model.
   

Parameters:
- c - the editor component
See Also: ComponentUI.installUI(javax.swing.JComponent),

  Flags model changes.

  Flags model changes.
This is called whenever the model has changed.
It is implemented to rebuild the view hierarchy
to represent the default root element of the
associated model.

  Converts the given location in the model to a place in the view coordinate system.

  Converts the given location in the model to a place in
the view coordinate system.
The component must have a non-zero positive size for
this translation to be computed.
Returns: the coordinates as a rectangle, null if the model is not painted
Parameters:
- tc - the text component for which this UI is installed
- pos - the local location in the model to translate >= 0
Throws:
- BadLocationException - if the given position does not represent a valid location in the associated document
See Also: TextUI.modelToView(javax.swing.text.JTextComponent, int),

  Converts the given location in the model to a place in the view coordinate system.

  Converts the given location in the model to a place in
the view coordinate system.
The component must have a non-zero positive size for
this translation to be computed.
Returns: the coordinates as a rectangle, null if the model is not painted
Parameters:
- tc - the text component for which this UI is installed
- pos - the local location in the model to translate >= 0
Throws:
- BadLocationException - if the given position does not represent a valid location in the associated document
See Also: TextUI.modelToView(javax.swing.text.JTextComponent, int),

  Paints the interface.

  Paints the interface. This is routed to the
paintSafely method under the guarantee that
the model won't change from the view of this thread
while it's rendering (if the associated model is
derived from AbstractDocument). This enables the
model to potentially be updated asynchronously.
Parameters:
- g - the graphics context
- c - the editor component

  Paints a background for the view.

  Paints a background for the view. This will only be
called if isOpaque() on the associated component is
true. The default is to paint the background color
of the component.
Parameters:
- g - the graphics context

  Paints the interface safely with a guarantee that the model won't change from the view of this thread.

  Paints the interface safely with a guarantee that
the model won't change from the view of this thread.
This does the following things, rendering from
back to front.

1. 
   If the component is marked as opaque, the background
   is painted in the current background color of the
   component.
   
2. 
   The highlights (if any) are painted.
   
3. 
   The view hierarchy is painted.
   
4. 
   The caret is painted.
   

Parameters:
- g - the graphics context

  This method gets called when a bound property is changed on the associated JTextComponent.

  This method gets called when a bound property is changed
on the associated JTextComponent. This is a hook
which UI implementations may change to reflect how the
UI displays bound properties of JTextComponent subclasses.
This is implemented to do nothing (i.e. the response to
properties in JTextComponent itself are handled prior
to calling this method).

This implementation updates the background of the text
component if the editable and/or enabled state changes.
Parameters:
- evt - the property change event

  Sets the current root of the view hierarchy and calls invalidate().

  Sets the current root of the view hierarchy and calls invalidate().
If there were any child components, they will be removed (i.e.
there are assumed to have come from components embedded in views).
Parameters:
- v - the root view

  Sets the component properties that haven't been explicitly overridden to null.

  Sets the component properties that haven't been explicitly overridden to
null. A property is considered overridden if its current value
is not a UIResource.
See Also: BasicTextUI.installDefaults(), BasicTextUI.uninstallUI(javax.swing.JComponent),

Uninstalls listeners for the UI.

  Deinstalls the UI for a component.

  Deinstalls the UI for a component. This removes the listeners,
uninstalls the highlighter, removes views, and nulls out the keymap.
Parameters:
- c - the editor component
See Also: ComponentUI.uninstallUI(javax.swing.JComponent),

  Superclass paints background in an uncontrollable way (i.e.

  Superclass paints background in an uncontrollable way (i.e. one might want an image tiled into the background). To prevent this from happening twice, this method is reimplemented to simply paint.

NOTE: Superclass is also not thread-safe in it's rendering of the background, although that's not an issue with the default rendering.

  Converts the given place in the view coordinate system to the nearest representative location in the model.

  Converts the given place in the view coordinate system
to the nearest representative location in the model.
The component must have a non-zero positive size for
this translation to be computed.
Returns: the offset from the start of the document >= 0, -1 if not painted
Parameters:
- tc - the text component for which this UI is installed
- pt - the location in the view to translate. This should be in the same coordinate system as the mouse events.
See Also: TextUI.viewToModel(javax.swing.text.JTextComponent, java.awt.Point),

  Converts the given place in the view coordinate system to the nearest representative location in the model.

  Converts the given place in the view coordinate system
to the nearest representative location in the model.
The component must have a non-zero positive size for
this translation to be computed.
Returns: the offset from the start of the document >= 0, -1 if the component doesn't yet have a positive size.
Parameters:
- tc - the text component for which this UI is installed
- pt - the location in the view to translate. This should be in the same coordinate system as the mouse events.
See Also: TextUI.viewToModel(javax.swing.text.JTextComponent, java.awt.Point),