| java.lang.Object
 javax.swing.text.View
All known Subclasses: javax.swing.text.html.ImageView, javax.swing.text.GlyphView, javax.swing.text.ComponentView, javax.swing.text.html.HRuleView, javax.swing.text.IconView, javax.swing.text.AsyncBoxView, javax.swing.text.PlainView, javax.swing.text.CompositeView,
| View | | abstract public class View implements SwingConstants(Code) | |
A very important part of the text package is the View class.
As the name suggests it represents a view of the text model,
or a piece of the text model.
It is this class that is responsible for the look of the text component.
The view is not intended to be some completely new thing that one must
learn, but rather is much like a lightweight component.
By default, a view is very light. It contains a reference to the parent
view from which it can fetch many things without holding state, and it
contains a reference to a portion of the model (Element).
A view does not
have to exactly represent an element in the model, that is simply a typical
and therefore convenient mapping. A view can alternatively maintain a couple
of Position objects to maintain its location in the model (i.e. represent
a fragment of an element). This is typically the result of formatting where
views have been broken down into pieces. The convenience of a substantial
relationship to the element makes it easier to build factories to produce the
views, and makes it easier to keep track of the view pieces as the model is
changed and the view must be changed to reflect the model. Simple views
therefore represent an Element directly and complex views do not.
A view has the following responsibilities:
- Participate in layout.
-
The view has a setSize method which is like
doLayout and setSize in Component combined.
The view has a preferenceChanged method which is
like invalidate in Component except that one can
invalidate just one axis
and the child requesting the change is identified.
A View expresses the size that it would like to be in terms of three
values, a minimum, a preferred, and a maximum span. Layout in a view is
can be done independently upon each axis. For a properly functioning View
implementation, the minimum span will be <= the preferred span which in turn
will be <= the maximum span.
The minimum set of methods for layout are:
The setSize method should be prepared to be called a number of times
(i.e. It may be called even if the size didn't change).
The setSize method
is generally called to make sure the View layout is complete prior to trying
to perform an operation on it that requires an up-to-date layout. A view's
size should always be set to a value within the minimum and maximum
span specified by that view. Additionally, the view must always call the
preferenceChanged method on the parent if it has changed the
values for the
layout it would like, and expects the parent to honor. The parent View is
not required to recognize a change until the preferenceChanged
has been sent.
This allows parent View implementations to cache the child requirements if
desired. The calling sequence looks something like the following:
The exact calling sequence is up to the layout functionality of
the parent view (if the view has any children). The view may collect
the preferences of the children prior to determining what it will give
each child, or it might iteratively update the children one at a time.
- Render a portion of the model.
-
This is done in the paint method, which is pretty much like a component
paint method. Views are expected to potentially populate a fairly large
tree. A View has the following semantics for rendering:
- The view gets its allocation from the parent at paint time, so it
must be prepared to redo layout if the allocated area is different from
what it is prepared to deal with.
- The coordinate system is the same as the hosting
Component
(i.e. the Component returned by the
getContainer method).
This means a child view lives in the same coordinate system as the parent
view unless the parent has explicitly changed the coordinate system.
To schedule itself to be repainted a view can call repaint on the hosting
Component.
- The default is to not clip the children. It is more efficient
to allow a view to clip only if it really feels it needs clipping.
- The
Graphics object given is not initialized in any way.
A view should set any settings needed.
- A
View is inherently transparent. While a view may render into its
entire allocation, typically a view does not. Rendering is performed by
tranversing down the tree of View implementations.
Each View is responsible
for rendering its children. This behavior is depended upon for thread
safety. While view implementations do not necessarily have to be implemented
with thread safety in mind, other view implementations that do make use of
concurrency can depend upon a tree traversal to guarantee thread safety.
- The order of views relative to the model is up to the implementation.
Although child views will typically be arranged in the same order that they
occur in the model, they may be visually arranged in an entirely different
order. View implementations may have Z-Order associated with them if the
children are overlapping.
The methods for rendering are:
- Translate between the model and view coordinate systems.
-
Because the view objects are produced from a factory and therefore cannot
necessarily be counted upon to be in a particular pattern, one must be able
to perform translation to properly locate spatial representation of the model.
The methods for doing this are:
The layout must be valid prior to attempting to make the translation.
The translation is not valid, and must not be attempted while changes
are being broadcasted from the model via a DocumentEvent.
- Respond to changes from the model.
-
If the overall view is represented by many pieces (which is the best situation
if one want to be able to change the view and write the least amount of new code),
it would be impractical to have a huge number of DocumentListeners.
If each
view listened to the model, only a few would actually be interested in the
changes broadcasted at any given time. Since the model has no knowledge of
views, it has no way to filter the broadcast of change information. The view
hierarchy itself is instead responsible for propagating the change information.
At any level in the view hierarchy, that view knows enough about its children to
best distribute the change information further. Changes are therefore broadcasted
starting from the root of the view hierarchy.
The methods for doing this are:
author:
Timothy Prinzing
version:
1.81 05/05/07 |
| Field Summary | |
| final public static int | BadBreakWeight
The weight to indicate a view is a bad break
opportunity for the purpose of formatting. | | final public static int | ExcellentBreakWeight
The weight to indicate a view supports breaking,
and this represents a very attractive place to
break. | | final public static int | ForcedBreakWeight
The weight to indicate a view supports breaking,
and must be broken to be represented properly
when placed in a view that formats its children
by breaking them. | | final public static int | GoodBreakWeight
The weight to indicate a view supports breaking,
but better opportunities probably exist. | | final public static int | X_AXIS
Axis for format/break operations. | | final public static int | Y_AXIS
Axis for format/break operations. | | final static Position.Bias[] | sharedBiasReturn
|
| Constructor Summary | |
| public | View(Element elem)
Creates a new View object. |
| Method Summary | |
| public void | append(View v)
Appends a single child view. | | public View | breakView(int axis, int offset, float pos, float len)
Tries to break this view on the given axis. | | public void | changedUpdate(DocumentEvent e, Shape a, ViewFactory f)
Gives notification from the document that attributes were changed
in a location that this view is responsible for.
To reduce the burden to subclasses, this functionality is
spread out into the following calls that subclasses can
reimplement:
- updateChildren is called
if there were any changes to the element this view is
responsible for.
| | public View | createFragment(int p0, int p1)
Creates a view that represents a portion of the element.
This is potentially useful during formatting operations
for taking measurements of fragments of the view. | | protected void | forwardUpdate(DocumentEvent.ElementChange ec, DocumentEvent e, Shape a, ViewFactory f)
Forwards the given DocumentEvent to the child views
that need to be notified of the change to the model.
If there were changes to the element this view is
responsible for, that should be considered when
forwarding (i.e. | | protected void | forwardUpdateToView(View v, DocumentEvent e, Shape a, ViewFactory f)
Forwards the DocumentEvent to the give child view. | | public float | getAlignment(int axis)
Determines the desired alignment for this view along an
axis. | | public AttributeSet | getAttributes()
Fetches the attributes to use when rendering. | | public int | getBreakWeight(int axis, float pos, float len)
Determines how attractive a break opportunity in
this view is. | | public Shape | getChildAllocation(int index, Shape a)
Fetches the allocation for the given child view. | | public Container | getContainer()
Fetches the container hosting the view. | | public Document | getDocument()
Fetches the model associated with the view. | | public Element | getElement()
Fetches the structural portion of the subject that this
view is mapped to. | | public int | getEndOffset()
Fetches the portion of the model for which this view is
responsible. | | public Graphics | getGraphics()
Fetch a Graphics for rendering. | | public float | getMaximumSpan(int axis)
Determines the maximum span for this view along an
axis. | | public float | getMinimumSpan(int axis)
Determines the minimum span for this view along an
axis. | | public int | getNextVisualPositionFrom(int pos, Position.Bias b, Shape a, int direction, Position.Bias[] biasRet)
Provides a way to determine the next visually represented model
location at which one might place a caret. | | public View | getParent()
Returns the parent of the view. | | abstract public float | getPreferredSpan(int axis)
Determines the preferred span for this view along an
axis.
Parameters:
axis - may be either View.X_AXIS orView.Y_AXIS the span the view would like to be rendered into.Typically the view is told to render into the spanthat is returned, although there is no guarantee. | | public int | getResizeWeight(int axis)
Determines the resizability of the view along the
given axis. | | public int | getStartOffset()
Fetches the portion of the model for which this view is
responsible. | | public String | getToolTipText(float x, float y, Shape allocation)
Returns the tooltip text at the specified location. | | public View | getView(int n)
Gets the nth child view. | | public int | getViewCount()
Returns the number of views in this view. | | public ViewFactory | getViewFactory()
Fetches the ViewFactory implementation that is feeding
the view hierarchy. | | public int | getViewIndex(int pos, Position.Bias b)
Returns the child view index representing the given position in
the model. | | public int | getViewIndex(float x, float y, Shape allocation)
Returns the child view index representing the given position in
the view. | | public void | insert(int offs, View v)
Inserts a single child view. | | public void | insertUpdate(DocumentEvent e, Shape a, ViewFactory f)
Gives notification that something was inserted into
the document in a location that this view is responsible for. | | public boolean | isVisible()
Returns a boolean that indicates whether
the view is visible or not. | | abstract public Shape | modelToView(int pos, Shape a, Position.Bias b)
Provides a mapping, for a given character,
from the document model coordinate space
to the view coordinate space. | | public Shape | modelToView(int p0, Position.Bias b0, int p1, Position.Bias b1, Shape a)
Provides a mapping, for a given region,
from the document model coordinate space
to the view coordinate space. | | public Shape | modelToView(int pos, Shape a)
Provides a mapping from the document model coordinate space
to the coordinate space of the view mapped to it. | | abstract public void | paint(Graphics g, Shape allocation)
Renders using the given rendering surface and area on that
surface. | | public void | preferenceChanged(View child, boolean width, boolean height)
Child views can call this on the parent to indicate that
the preference has changed and should be reconsidered
for layout. | | public void | remove(int i)
Removes one of the children at the given position. | | public void | removeAll()
Removes all of the children. | | public void | removeUpdate(DocumentEvent e, Shape a, ViewFactory f)
Gives notification that something was removed from the document
in a location that this view is responsible for.
To reduce the burden to subclasses, this functionality is
spread out into the following calls that subclasses can
reimplement:
- updateChildren is called
if there were any changes to the element this view is
responsible for.
| | public void | replace(int offset, int length, View[] views)
Replaces child views. | | public void | setParent(View parent)
Establishes the parent view for this view. | | public void | setSize(float width, float height)
Sets the size of the view. | | protected boolean | updateChildren(DocumentEvent.ElementChange ec, DocumentEvent e, ViewFactory f)
Updates the child views in response to receiving notification
that the model changed, and there is change record for the
element this view is responsible for. | | protected void | updateLayout(DocumentEvent.ElementChange ec, DocumentEvent e, Shape a)
Updates the layout in response to receiving notification of
change from the model. | | abstract public int | viewToModel(float x, float y, Shape a, Position.Bias[] biasReturn)
Provides a mapping from the view coordinate space to the logical
coordinate space of the model. | | public int | viewToModel(float x, float y, Shape a)
Provides a mapping from the view coordinate space to the logical
coordinate space of the model. |
| X_AXIS | | final public static int X_AXIS(Code) | | Axis for format/break operations.
|
| Y_AXIS | | final public static int Y_AXIS(Code) | | Axis for format/break operations.
|
| View | | public View(Element elem)(Code) | | Creates a new View object.
Parameters:
elem - the Element to represent |
| append | | public void append(View v)(Code) | | Appends a single child view. This is a convenience
call to replace.
Parameters:
v - the view
See Also: View.replace
since:
1.3 |
| breakView | | public View breakView(int axis, int offset, float pos, float len)(Code) | | Tries to break this view on the given axis. This is
called by views that try to do formatting of their
children. For example, a view of a paragraph will
typically try to place its children into row and
views representing chunks of text can sometimes be
broken down into smaller pieces.
This is implemented to return the view itself, which
represents the default behavior on not being
breakable. If the view does support breaking, the
starting offset of the view returned should be the
given offset, and the end offset should be less than
or equal to the end offset of the view being broken.
Parameters:
axis - may be either View.X_AXIS orView.Y_AXIS
Parameters:
offset - the location in the document modelthat a broken fragment would occupy >= 0. Thiswould be the starting offset of the fragmentreturned
Parameters:
pos - the position along the axis that thebroken view would occupy >= 0. This may be useful forthings like tab calculations
Parameters:
len - specifies the distance along the axiswhere a potential break is desired >= 0 the fragment of the view that represents thegiven span, if the view can be broken. If the viewdoesn't support breaking behavior, the view itself isreturned.
See Also: ParagraphView |
| changedUpdate | | public void changedUpdate(DocumentEvent e, Shape a, ViewFactory f)(Code) | | Gives notification from the document that attributes were changed
in a location that this view is responsible for.
To reduce the burden to subclasses, this functionality is
spread out into the following calls that subclasses can
reimplement:
- updateChildren is called
if there were any changes to the element this view is
responsible for. If this view has child views that are
represent the child elements, then this method should do
whatever is necessary to make sure the child views correctly
represent the model.
- forwardUpdate is called
to forward the DocumentEvent to the appropriate child views.
- updateLayout is called to
give the view a chance to either repair its layout, to reschedule
layout, or do nothing.
Parameters:
e - the change information from the associated document
Parameters:
a - the current allocation of the view
Parameters:
f - the factory to use to rebuild if the view has children
See Also: View.changedUpdate |
| createFragment | | public View createFragment(int p0, int p1)(Code) | | Creates a view that represents a portion of the element.
This is potentially useful during formatting operations
for taking measurements of fragments of the view. If
the view doesn't support fragmenting (the default), it
should return itself.
Parameters:
p0 - the starting offset >= 0. This should be a valuegreater or equal to the element starting offset andless than the element ending offset.
Parameters:
p1 - the ending offset > p0. This should be a valueless than or equal to the elements end offset andgreater than the elements starting offset. the view fragment, or itself if the view doesn'tsupport breaking into fragments
See Also: LabelView |
| forwardUpdate | | protected void forwardUpdate(DocumentEvent.ElementChange ec, DocumentEvent e, Shape a, ViewFactory f)(Code) | | Forwards the given DocumentEvent to the child views
that need to be notified of the change to the model.
If there were changes to the element this view is
responsible for, that should be considered when
forwarding (i.e. new child views should not get
notified).
Parameters:
ec - changes to the element this view is responsiblefor (may be null if there were no changes).
Parameters:
e - the change information from the associated document
Parameters:
a - the current allocation of the view
Parameters:
f - the factory to use to rebuild if the view has children
See Also: View.insertUpdate
See Also: View.removeUpdate
See Also: View.changedUpdate
See Also:
since:
1.3 |
| forwardUpdateToView | | protected void forwardUpdateToView(View v, DocumentEvent e, Shape a, ViewFactory f)(Code) | | Forwards the DocumentEvent to the give child view. This
simply messages the view with a call to insertUpdate,
removeUpdate, or changedUpdate depending
upon the type of the event. This is called by
forwardUpdate to forward
the event to children that need it.
Parameters:
v - the child view to forward the event to
Parameters:
e - the change information from the associated document
Parameters:
a - the current allocation of the view
Parameters:
f - the factory to use to rebuild if the view has children
See Also: View.forwardUpdate
since:
1.3 |
| getAlignment | | public float getAlignment(int axis)(Code) | | Determines the desired alignment for this view along an
axis. The desired alignment is returned. This should be
a value >= 0.0 and <= 1.0, where 0 indicates alignment at
the origin and 1.0 indicates alignment to the full span
away from the origin. An alignment of 0.5 would be the
center of the view.
Parameters:
axis - may be either View.X_AXIS orView.Y_AXIS the value 0.5 |
| getAttributes | | public AttributeSet getAttributes()(Code) | | Fetches the attributes to use when rendering. By default
this simply returns the attributes of the associated element.
This method should be used rather than using the element
directly to obtain access to the attributes to allow
view-specific attributes to be mixed in or to allow the
view to have view-specific conversion of attributes by
subclasses.
Each view should document what attributes it recognizes
for the purpose of rendering or layout, and should always
access them through the AttributeSet returned
by this method.
|
| getBreakWeight | | public int getBreakWeight(int axis, float pos, float len)(Code) | | Determines how attractive a break opportunity in
this view is. This can be used for determining which
view is the most attractive to call breakView
on in the process of formatting. A view that represents
text that has whitespace in it might be more attractive
than a view that has no whitespace, for example. The
higher the weight, the more attractive the break. A
value equal to or lower than BadBreakWeight
should not be considered for a break. A value greater
than or equal to ForcedBreakWeight should
be broken.
This is implemented to provide the default behavior
of returning BadBreakWeight unless the length
is greater than the length of the view in which case the
entire view represents the fragment. Unless a view has
been written to support breaking behavior, it is not
attractive to try and break the view. An example of
a view that does support breaking is LabelView.
An example of a view that uses break weight is
ParagraphView.
Parameters:
axis - may be either View.X_AXIS orView.Y_AXIS
Parameters:
pos - the potential location of the start of the broken view >= 0. This may be useful for calculating tabpositions
Parameters:
len - specifies the relative length from poswhere a potential break is desired >= 0 the weight, which should be a value betweenForcedBreakWeight and BadBreakWeight
See Also: LabelView
See Also: ParagraphView
See Also: View.BadBreakWeight
See Also: View.GoodBreakWeight
See Also: View.ExcellentBreakWeight
See Also: View.ForcedBreakWeight |
| getChildAllocation | | public Shape getChildAllocation(int index, Shape a)(Code) | | Fetches the allocation for the given child view.
This enables finding out where various views
are located, without assuming how the views store
their location. This returns null since the
default is to not have any child views.
Parameters:
index - the index of the child, >= 0 && <getViewCount()
Parameters:
a - the allocation to this view the allocation to the child |
| getContainer | | public Container getContainer()(Code) | | Fetches the container hosting the view. This is useful for
things like scheduling a repaint, finding out the host
components font, etc. The default implementation
of this is to forward the query to the parent view.
the container, null if none |
| getElement | | public Element getElement()(Code) | | Fetches the structural portion of the subject that this
view is mapped to. The view may not be responsible for the
entire portion of the element.
the subject
See Also: View.getElement |
| getEndOffset | | public int getEndOffset()(Code) | | Fetches the portion of the model for which this view is
responsible.
the ending offset into the model >= 0
See Also: View.getEndOffset |
| getGraphics | | public Graphics getGraphics()(Code) | | Fetch a Graphics for rendering.
This can be used to determine
font characteristics, and will be different for a print view
than a component view.
a Graphics object for rendering
since:
1.3 |
| getMaximumSpan | | public float getMaximumSpan(int axis)(Code) | | Determines the maximum span for this view along an
axis.
Parameters:
axis - may be either View.X_AXIS orView.Y_AXIS the maximum span the view can be rendered into
See Also: View.getPreferredSpan |
| getMinimumSpan | | public float getMinimumSpan(int axis)(Code) | | Determines the minimum span for this view along an
axis.
Parameters:
axis - may be either View.X_AXIS orView.Y_AXIS the minimum span the view can be rendered into
See Also: View.getPreferredSpan |
| getNextVisualPositionFrom | | public int getNextVisualPositionFrom(int pos, Position.Bias b, Shape a, int direction, Position.Bias[] biasRet) throws BadLocationException(Code) | | Provides a way to determine the next visually represented model
location at which 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.
Parameters:
pos - the position to convert >= 0
Parameters:
a - the allocated region in which to render
Parameters:
direction - the direction from the current position that canbe thought of as the arrow keys typically found on a keyboard.This will be one of the following values:- SwingConstants.WEST
- SwingConstants.EAST
- SwingConstants.NORTH
- SwingConstants.SOUTH
the location within the model that best represents the nextlocation visual position
exception:
BadLocationException -
exception:
IllegalArgumentException - if directiondoesn't have one of the legal values above |
| getParent | | public View getParent()(Code) | | Returns the parent of the view.
the parent, or null if none exists |
| getPreferredSpan | | abstract public float getPreferredSpan(int axis)(Code) | | Determines the preferred span for this view along an
axis.
Parameters:
axis - may be either View.X_AXIS orView.Y_AXIS the span the view would like to be rendered into.Typically the view is told to render into the spanthat is returned, although there is no guarantee. The parent may choose to resize or break the view
See Also: View.getPreferredSpan |
| getResizeWeight | | public int getResizeWeight(int axis)(Code) | | Determines the resizability of the view along the
given axis. A value of 0 or less is not resizable.
Parameters:
axis - may be either View.X_AXIS orView.Y_AXIS the weight |
| getStartOffset | | public int getStartOffset()(Code) | | Fetches the portion of the model for which this view is
responsible.
the starting offset into the model >= 0
See Also: View.getStartOffset |
| getToolTipText | | public String getToolTipText(float x, float y, Shape allocation)(Code) | | Returns the tooltip text at the specified location. The default
implementation returns the value from the child View identified by
the passed in location.
since:
1.4
See Also: JTextComponent.getToolTipText |
| getView | | public View getView(int n)(Code) | | Gets the nth child view. Since there are no
children by default, this returns null.
Parameters:
n - the number of the view to get, >= 0 && < getViewCount() the view |
| getViewCount | | public int getViewCount()(Code) | | Returns the number of views in this view. Since
the default is to not be a composite view this
returns 0.
the number of views >= 0
See Also: View.getViewCount |
| getViewFactory | | public ViewFactory getViewFactory()(Code) | | Fetches the ViewFactory implementation that is feeding
the view hierarchy. Normally the views are given this
as an argument to updates from the model when they
are most likely to need the factory, but this
method serves to provide it at other times.
the factory, null if none |
| getViewIndex | | public int getViewIndex(int pos, Position.Bias b)(Code) | | Returns the child view index representing the given position in
the model. By default a view has no children so this is implemented
to return -1 to indicate there is no valid child index for any
position.
Parameters:
pos - the position >= 0 index of the view representing the given position, or -1 if no view represents that position
since:
1.3 |
| getViewIndex | | public int getViewIndex(float x, float y, Shape allocation)(Code) | | Returns the child view index representing the given position in
the view. This iterates over all the children returning the
first with a bounds that contains x, y.
Parameters:
x - the x coordinate
Parameters:
y - the y coordinate
Parameters:
allocation - current allocation of the View. index of the view representing the given location, or -1 if no view represents that position
since:
1.4 |
| insert | | public void insert(int offs, View v)(Code) | | Inserts a single child view. This is a convenience
call to replace.
Parameters:
offs - the offset of the view to insert before >= 0
Parameters:
v - the view
See Also: View.replace
since:
1.3 |
| insertUpdate | | public void insertUpdate(DocumentEvent e, Shape a, ViewFactory f)(Code) | | Gives notification that something was inserted into
the document in a location that this view is responsible for.
To reduce the burden to subclasses, this functionality is
spread out into the following calls that subclasses can
reimplement:
- updateChildren is called
if there were any changes to the element this view is
responsible for. If this view has child views that are
represent the child elements, then this method should do
whatever is necessary to make sure the child views correctly
represent the model.
- forwardUpdate is called
to forward the DocumentEvent to the appropriate child views.
- updateLayout is called to
give the view a chance to either repair its layout, to reschedule
layout, or do nothing.
Parameters:
e - the change information from the associated document
Parameters:
a - the current allocation of the view
Parameters:
f - the factory to use to rebuild if the view has children
See Also: View.insertUpdate |
| isVisible | | public boolean isVisible()(Code) | | Returns a boolean that indicates whether
the view is visible or not. By default
all views are visible.
always returns true |
| modelToView | | abstract public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException(Code) | | Provides a mapping, for a given character,
from the document model coordinate space
to the view coordinate space.
Parameters:
pos - the position of the desired character (>=0)
Parameters:
a - the area of the view, which encompasses the requested character
Parameters:
b - the bias toward the previous character or thenext character represented by the offset, in case the position is a boundary of two views; b will have oneof these values:-
Position.Bias.Forward -
Position.Bias.Backward
the bounding box, in view coordinate space,of the character at the specified position
exception:
BadLocationException - if the specified position doesnot represent a valid location in the associated document
exception:
IllegalArgumentException - if b is not one of thelegal Position.Bias values listed above
See Also: View.viewToModel |
| modelToView | | public Shape modelToView(int p0, Position.Bias b0, int p1, Position.Bias b1, Shape a) throws BadLocationException(Code) | | Provides a mapping, for a given region,
from the document model coordinate space
to the view coordinate space. The specified region is
created as a union of the first and last character positions.
Parameters:
p0 - the position of the first character (>=0)
Parameters:
b0 - the bias of the first character position,toward the previous character or thenext character represented by the offset, in case the position is a boundary of two views; b0 will have oneof these values:-
Position.Bias.Forward -
Position.Bias.Backward
Parameters:
p1 - the position of the last character (>=0)
Parameters:
b1 - the bias for the second character position, definedone of the legal values shown above
Parameters:
a - the area of the view, which encompasses the requested region the bounding box which is a union of the region specifiedby the first and last character positions
exception:
BadLocationException - if the given position doesnot represent a valid location in the associated document
exception:
IllegalArgumentException - if b0 orb1 are not one of thelegal Position.Bias values listed above
See Also: View.viewToModel |
| modelToView | | public Shape modelToView(int pos, Shape a) throws BadLocationException(Code) | | Provides a mapping from the document model coordinate space
to the coordinate space of the view mapped to it. This is
implemented to default the bias to Position.Bias.Forward
which was previously implied.
Parameters:
pos - the position to convert >= 0
Parameters:
a - the allocated region in which to render the bounding box of the given position is returned
exception:
BadLocationException - if the given position doesnot represent a valid location in the associated document
See Also: View.modelToView |
| paint | | abstract public void paint(Graphics g, Shape allocation)(Code) | | Renders using the given rendering surface and area on that
surface. The view may need to do layout and create child
views to enable itself to render into the given allocation.
Parameters:
g - the rendering surface to use
Parameters:
allocation - the allocated region to render into |
| preferenceChanged | | public void preferenceChanged(View child, boolean width, boolean height)(Code) | | Child views can call this on the parent to indicate that
the preference has changed and should be reconsidered
for layout. By default this just propagates upward to
the next parent. The root view will call
revalidate on the associated text component.
Parameters:
child - the child view
Parameters:
width - true if the width preference has changed
Parameters:
height - true if the height preference has changed
See Also: javax.swing.JComponent.revalidate |
| remove | | public void remove(int i)(Code) | | Removes one of the children at the given position.
This is a convenience call to replace.
since:
1.3 |
| removeAll | | public void removeAll()(Code) | | Removes all of the children. This is a convenience
call to replace.
since:
1.3 |
| removeUpdate | | public void removeUpdate(DocumentEvent e, Shape a, ViewFactory f)(Code) | | Gives notification that something was removed from the document
in a location that this view is responsible for.
To reduce the burden to subclasses, this functionality is
spread out into the following calls that subclasses can
reimplement:
- updateChildren is called
if there were any changes to the element this view is
responsible for. If this view has child views that are
represent the child elements, then this method should do
whatever is necessary to make sure the child views correctly
represent the model.
- forwardUpdate is called
to forward the DocumentEvent to the appropriate child views.
- updateLayout is called to
give the view a chance to either repair its layout, to reschedule
layout, or do nothing.
Parameters:
e - the change information from the associated document
Parameters:
a - the current allocation of the view
Parameters:
f - the factory to use to rebuild if the view has children
See Also: View.removeUpdate |
| replace | | public void replace(int offset, int length, View[] views)(Code) | | Replaces child views. If there are no views to remove
this acts as an insert. If there are no views to
add this acts as a remove. Views being removed will
have the parent set to null, and the internal reference
to them removed so that they can be garbage collected.
This is implemented to do nothing, because by default
a view has no children.
Parameters:
offset - the starting index into the child views to insertthe new views. This should be a value >= 0 and <= getViewCount
Parameters:
length - the number of existing child views to removeThis should be a value >= 0 and <= (getViewCount() - offset).
Parameters:
views - the child views to add. This value can benull to indicate no children are being added(useful to remove).
since:
1.3 |
| setParent | | public void setParent(View parent)(Code) | | Establishes the parent view for this view. This is
guaranteed to be called before any other methods if the
parent view is functioning properly. This is also
the last method called, since it is called to indicate
the view has been removed from the hierarchy as
well. When this method is called to set the parent to
null, this method does the same for each of its children,
propogating the notification that they have been
disconnected from the view tree. If this is
reimplemented, super.setParent() should
be called.
Parameters:
parent - the new parent, or null if the view isbeing removed from a parent |
| setSize | | public void setSize(float width, float height)(Code) | | Sets the size of the view. This should cause
layout of the view along the given axis, if it
has any layout duties.
Parameters:
width - the width >= 0
Parameters:
height - the height >= 0 |
| updateChildren | | protected boolean updateChildren(DocumentEvent.ElementChange ec, DocumentEvent e, ViewFactory f)(Code) | | Updates the child views in response to receiving notification
that the model changed, and there is change record for the
element this view is responsible for. This is implemented
to assume the child views are directly responsible for the
child elements of the element this view represents. The
ViewFactory is used to create child views for each element
specified as added in the ElementChange, starting at the
index specified in the given ElementChange. The number of
child views representing the removed elements specified are
removed.
Parameters:
ec - the change information for the element this viewis responsible for. This should not be null if this method gets called
Parameters:
e - the change information from the associated document
Parameters:
f - the factory to use to build child views whether or not the child views represent thechild elements of the element this view is responsiblefor. Some views create children that represent a portion of the element they are responsible for, and should returnfalse. This information is used to determine if views in the range of the added elements should be forwarded toor not
See Also: View.insertUpdate
See Also: View.removeUpdate
See Also: View.changedUpdate
since:
1.3 |
| updateLayout | | protected void updateLayout(DocumentEvent.ElementChange ec, DocumentEvent e, Shape a)(Code) | | Updates the layout in response to receiving notification of
change from the model. This is implemented to call
preferenceChanged to reschedule a new layout
if the ElementChange record is not null.
Parameters:
ec - changes to the element this view is responsiblefor (may be null if there were no changes)
Parameters:
e - the change information from the associated document
Parameters:
a - the current allocation of the view
See Also: View.insertUpdate
See Also: View.removeUpdate
See Also: View.changedUpdate
See Also:
since:
1.3 |
| viewToModel | | abstract public int viewToModel(float x, float y, Shape a, Position.Bias[] biasReturn)(Code) | | Provides a mapping from the view coordinate space to the logical
coordinate space of the model. The biasReturn
argument will be filled in to indicate that the point given is
closer to the next character in the model or the previous
character in the model.
Parameters:
x - the X coordinate >= 0
Parameters:
y - the Y coordinate >= 0
Parameters:
a - the allocated region in which to render the location within the model that best represents thegiven point in the view >= 0. The biasReturnargument will befilled in to indicate that the point given is closer to the nextcharacter in the model or the previous character in the model. |
| viewToModel | | public int viewToModel(float x, float y, Shape a)(Code) | | Provides a mapping from the view coordinate space to the logical
coordinate space of the model.
Parameters:
x - the X coordinate >= 0
Parameters:
y - the Y coordinate >= 0
Parameters:
a - the allocated region in which to render the location within the model that best represents thegiven point in the view >= 0
See Also: View.viewToModel |
|
|