https://openjdk.java.net/ 
/*
 * Copyright (c) 1998, 2006, Oracle and/or its affiliates. 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package javax.swing.text;

import java.util.Vector;
import java.awt.*;
import javax.swing.event.*;


ZoneView is a View implementation that creates zones for which
the child views are not created or stored until they are needed
for display or model/view translations.  This enables a substantial
reduction in memory consumption for situations where the model
being represented is very large, by building view objects only for
the region being actively viewed/edited.  The size of the children
can be estimated in some way, or calculated asynchronously with
only the result being saved.


ZoneView extends BoxView to provide a box that implements
zones for its children.  The zones are special View implementations
(the children of an instance of this class) that represent only a
portion of the model that an instance of ZoneView is responsible
for.  The zones don't create child views until an attempt is made
to display them. A box shaped view is well suited to this because:
  
    
  
  • 
  Boxes are a heavily used view, and having a box that
  provides this behavior gives substantial opportunity
  to plug the behavior into a view hierarchy from the
  view factory.
  
  • 
  Boxes are tiled in one direction, so it is easy to
  divide them into zones in a reliable way.
  
  • 
  Boxes typically have a simple relationship to the model (i.e. they
  create child views that directly represent the child elements).
  
  • 
  Boxes are easier to estimate the size of than some other shapes.
  



The default behavior is controled by two properties, maxZoneSize
and maxZonesLoaded.  Setting maxZoneSize to Integer.MAX_VALUE would
have the effect of causing only one zone to be created.  This would
effectively turn the view into an implementation of the decorator
pattern.  Setting maxZonesLoaded to a value of Integer.MAX_VALUE would
cause zones to never be unloaded.  For simplicity, zones are created on
boundaries represented by the child elements of the element the view is
responsible for.  The zones can be any View implementation, but the
default implementation is based upon AsyncBoxView which supports fairly
large zones efficiently.

Author: Timothy Prinzing
See Also:
Since:  1.3
/**
 * ZoneView is a View implementation that creates zones for which
 * the child views are not created or stored until they are needed
 * for display or model/view translations.  This enables a substantial
 * reduction in memory consumption for situations where the model
 * being represented is very large, by building view objects only for
 * the region being actively viewed/edited.  The size of the children
 * can be estimated in some way, or calculated asynchronously with
 * only the result being saved.
 * <p>
 * ZoneView extends BoxView to provide a box that implements
 * zones for its children.  The zones are special View implementations
 * (the children of an instance of this class) that represent only a
 * portion of the model that an instance of ZoneView is responsible
 * for.  The zones don't create child views until an attempt is made
 * to display them. A box shaped view is well suited to this because:
 *   <ul>
 *   <li>
 *   Boxes are a heavily used view, and having a box that
 *   provides this behavior gives substantial opportunity
 *   to plug the behavior into a view hierarchy from the
 *   view factory.
 *   <li>
 *   Boxes are tiled in one direction, so it is easy to
 *   divide them into zones in a reliable way.
 *   <li>
 *   Boxes typically have a simple relationship to the model (i.e. they
 *   create child views that directly represent the child elements).
 *   <li>
 *   Boxes are easier to estimate the size of than some other shapes.
 *   </ul>
 * <p>
 * The default behavior is controled by two properties, maxZoneSize
 * and maxZonesLoaded.  Setting maxZoneSize to Integer.MAX_VALUE would
 * have the effect of causing only one zone to be created.  This would
 * effectively turn the view into an implementation of the decorator
 * pattern.  Setting maxZonesLoaded to a value of Integer.MAX_VALUE would
 * cause zones to never be unloaded.  For simplicity, zones are created on
 * boundaries represented by the child elements of the element the view is
 * responsible for.  The zones can be any View implementation, but the
 * default implementation is based upon AsyncBoxView which supports fairly
 * large zones efficiently.
 *
 * @author  Timothy Prinzing
 * @see     View
 * @since   1.3
 */
public class ZoneView extends BoxView {

    int maxZoneSize = 8 * 1024;
    int maxZonesLoaded = 3;
    Vector loadedZones;

    
Constructs a ZoneView.

Params:
  • elem – the element this view is responsible for
  • axis – either View.X_AXIS or View.Y_AXIS
/**
     * Constructs a ZoneView.
     *
     * @param elem the element this view is responsible for
     * @param axis either View.X_AXIS or View.Y_AXIS
     */
    public ZoneView(Element elem, int axis) {
        super(elem, axis);
        loadedZones = new Vector();
    }

    
Get the current maximum zone size.

/**
     * Get the current maximum zone size.
     */
    public int getMaximumZoneSize() {
        return maxZoneSize;
    }

    
Set the desired maximum zone size.  A
zone may get larger than this size if
a single child view is larger than this
size since zones are formed on child view
boundaries.

Params:
  • size – the number of characters the zone
may represent before attempting to break
the zone into a smaller size.
/**
     * Set the desired maximum zone size.  A
     * zone may get larger than this size if
     * a single child view is larger than this
     * size since zones are formed on child view
     * boundaries.
     *
     * @param size the number of characters the zone
     * may represent before attempting to break
     * the zone into a smaller size.
     */
    public void setMaximumZoneSize(int size) {
        maxZoneSize = size;
    }

    
Get the current setting of the number of zones
allowed to be loaded at the same time.

/**
     * Get the current setting of the number of zones
     * allowed to be loaded at the same time.
     */
    public int getMaxZonesLoaded() {
        return maxZonesLoaded;
    }

    
Sets the current setting of the number of zones
allowed to be loaded at the same time. This will throw an
IllegalArgumentException if mzl is less
than 1.

Params:
  • mzl – the desired maximum number of zones
 to be actively loaded, must be greater than 0
Throws:
/**
     * Sets the current setting of the number of zones
     * allowed to be loaded at the same time. This will throw an
     * <code>IllegalArgumentException</code> if <code>mzl</code> is less
     * than 1.
     *
     * @param mzl the desired maximum number of zones
     *  to be actively loaded, must be greater than 0
     * @exception IllegalArgumentException if <code>mzl</code> is < 1
     */
    public void setMaxZonesLoaded(int mzl) {
        if (mzl < 1) {
            throw new IllegalArgumentException("ZoneView.setMaxZonesLoaded must be greater than 0.");
        }
        maxZonesLoaded = mzl;
        unloadOldZones();
    }

    
Called by a zone when it gets loaded.  This happens when
an attempt is made to display or perform a model/view
translation on a zone that was in an unloaded state.
This is imlemented to check if the maximum number of
zones was reached and to unload the oldest zone if so.

Params:
  • zone – the child view that was just loaded.
/**
     * Called by a zone when it gets loaded.  This happens when
     * an attempt is made to display or perform a model/view
     * translation on a zone that was in an unloaded state.
     * This is imlemented to check if the maximum number of
     * zones was reached and to unload the oldest zone if so.
     *
     * @param zone the child view that was just loaded.
     */
    protected void zoneWasLoaded(View zone) {
        //System.out.println("loading: " + zone.getStartOffset() + "," + zone.getEndOffset());
        loadedZones.addElement(zone);
        unloadOldZones();
    }

    void unloadOldZones() {
        while (loadedZones.size() > getMaxZonesLoaded()) {
            View zone = (View) loadedZones.elementAt(0);
            loadedZones.removeElementAt(0);
            unloadZone(zone);
        }
    }

    
Unload a zone (Convert the zone to its memory saving state).
The zones are expected to represent a subset of the
child elements of the element this view is responsible for.
Therefore, the default implementation is to simple remove
all the children.

Params:
  • zone – the child view desired to be set to an
 unloaded state.
/**
     * Unload a zone (Convert the zone to its memory saving state).
     * The zones are expected to represent a subset of the
     * child elements of the element this view is responsible for.
     * Therefore, the default implementation is to simple remove
     * all the children.
     *
     * @param zone the child view desired to be set to an
     *  unloaded state.
     */
    protected void unloadZone(View zone) {
        //System.out.println("unloading: " + zone.getStartOffset() + "," + zone.getEndOffset());
        zone.removeAll();
    }

    
Determine if a zone is in the loaded state.
The zones are expected to represent a subset of the
child elements of the element this view is responsible for.
Therefore, the default implementation is to return
true if the view has children.

/**
     * Determine if a zone is in the loaded state.
     * The zones are expected to represent a subset of the
     * child elements of the element this view is responsible for.
     * Therefore, the default implementation is to return
     * true if the view has children.
     */
    protected boolean isZoneLoaded(View zone) {
        return (zone.getViewCount() > 0);
    }

    
Create a view to represent a zone for the given
range within the model (which should be within
the range of this objects responsibility).  This
is called by the zone management logic to create
new zones.  Subclasses can provide a different
implementation for a zone by changing this method.

Params:
  • p0 – the start of the desired zone.  This should
 be >= getStartOffset() and < getEndOffset().  This
 value should also be < p1.
  • p1 – the end of the desired zone.  This should
 be > getStartOffset() and <= getEndOffset().  This
 value should also be > p0.
/**
     * Create a view to represent a zone for the given
     * range within the model (which should be within
     * the range of this objects responsibility).  This
     * is called by the zone management logic to create
     * new zones.  Subclasses can provide a different
     * implementation for a zone by changing this method.
     *
     * @param p0 the start of the desired zone.  This should
     *  be >= getStartOffset() and < getEndOffset().  This
     *  value should also be < p1.
     * @param p1 the end of the desired zone.  This should
     *  be > getStartOffset() and <= getEndOffset().  This
     *  value should also be > p0.
     */
    protected View createZone(int p0, int p1) {
        Document doc = getDocument();
        View zone = null;
        try {
            zone = new Zone(getElement(),
                            doc.createPosition(p0),
                            doc.createPosition(p1));
        } catch (BadLocationException ble) {
            // this should puke in some way.
            throw new StateInvariantError(ble.getMessage());
        }
        return zone;
    }

    
Loads all of the children to initialize the view.
This is called by the setParent method.
This is reimplemented to not load any children directly
(as they are created by the zones).  This method creates
the initial set of zones.  Zones don't actually get
populated however until an attempt is made to display
them or to do model/view coordinate translation.

Params:
  • f – the view factory
/**
     * Loads all of the children to initialize the view.
     * This is called by the <code>setParent</code> method.
     * This is reimplemented to not load any children directly
     * (as they are created by the zones).  This method creates
     * the initial set of zones.  Zones don't actually get
     * populated however until an attempt is made to display
     * them or to do model/view coordinate translation.
     *
     * @param f the view factory
     */
    protected void loadChildren(ViewFactory f) {
        // build the first zone.
        Document doc = getDocument();
        int offs0 = getStartOffset();
        int offs1 = getEndOffset();
        append(createZone(offs0, offs1));
        handleInsert(offs0, offs1 - offs0);
    }

    
Returns the child view index representing the given position in
the model.

Params:
  • pos – the position >= 0
Returns: index of the view representing the given position, or
  -1 if no view represents that position
/**
     * Returns the child view index representing the given position in
     * the model.
     *
     * @param pos the position >= 0
     * @return  index of the view representing the given position, or
     *   -1 if no view represents that position
     */
    protected int getViewIndexAtPosition(int pos) {
        // PENDING(prinz) this could be done as a binary
        // search, and probably should be.
        int n = getViewCount();
        if (pos == getEndOffset()) {
            return n - 1;
        }
        for(int i = 0; i < n; i++) {
            View v = getView(i);
            if(pos >= v.getStartOffset() &&
               pos < v.getEndOffset()) {
                return i;
            }
        }
        return -1;
    }

    void handleInsert(int pos, int length) {
        int index = getViewIndex(pos, Position.Bias.Forward);
        View v = getView(index);
        int offs0 = v.getStartOffset();
        int offs1 = v.getEndOffset();
        if ((offs1 - offs0) > maxZoneSize) {
            splitZone(index, offs0, offs1);
        }
    }

    void handleRemove(int pos, int length) {
        // IMPLEMENT
    }

    
Break up the zone at the given index into pieces
of an acceptable size.

/**
     * Break up the zone at the given index into pieces
     * of an acceptable size.
     */
    void splitZone(int index, int offs0, int offs1) {
        // divide the old zone into a new set of bins
        Element elem = getElement();
        Document doc = elem.getDocument();
        Vector zones = new Vector();
        int offs = offs0;
        do {
            offs0 = offs;
            offs = Math.min(getDesiredZoneEnd(offs0), offs1);
            zones.addElement(createZone(offs0, offs));
        } while (offs < offs1);
        View oldZone = getView(index);
        View[] newZones = new View[zones.size()];
        zones.copyInto(newZones);
        replace(index, 1, newZones);
    }

    
Returns the zone position to use for the
end of a zone that starts at the given
position.  By default this returns something
close to half the max zone size.

/**
     * Returns the zone position to use for the
     * end of a zone that starts at the given
     * position.  By default this returns something
     * close to half the max zone size.
     */
    int getDesiredZoneEnd(int pos) {
        Element elem = getElement();
        int index = elem.getElementIndex(pos + (maxZoneSize / 2));
        Element child = elem.getElement(index);
        int offs0 = child.getStartOffset();
        int offs1 = child.getEndOffset();
        if ((offs1 - pos) > maxZoneSize) {
            if (offs0 > pos) {
                return offs0;
            }
        }
        return offs1;
    }

    // ---- View methods ----------------------------------------------------

    
The superclass behavior will try to update the child views
which is not desired in this case, since the children are
zones and not directly effected by the changes to the
associated element.  This is reimplemented to do nothing
and return false.

/**
     * The superclass behavior will try to update the child views
     * which is not desired in this case, since the children are
     * zones and not directly effected by the changes to the
     * associated element.  This is reimplemented to do nothing
     * and return false.
     */
    protected boolean updateChildren(DocumentEvent.ElementChange ec,
                                     DocumentEvent e, ViewFactory f) {
        return false;
    }

    
Gives notification that something was inserted into the document
in a location that this view is responsible for.  This is largely
delegated to the superclass, but is reimplemented to update the
relevant zone (i.e. determine if a zone needs to be split into a
set of 2 or more zones).

Params:
  • changes – the change information from the associated document
  • a – the current allocation of the view
  • f – the factory to use to rebuild if the view has children
See Also:
/**
     * Gives notification that something was inserted into the document
     * in a location that this view is responsible for.  This is largely
     * delegated to the superclass, but is reimplemented to update the
     * relevant zone (i.e. determine if a zone needs to be split into a
     * set of 2 or more zones).
     *
     * @param changes the change information from the associated document
     * @param a the current allocation of the view
     * @param f the factory to use to rebuild if the view has children
     * @see View#insertUpdate
     */
    public void insertUpdate(DocumentEvent changes, Shape a, ViewFactory f) {
        handleInsert(changes.getOffset(), changes.getLength());
        super.insertUpdate(changes, a, f);
    }

    
Gives notification that something was removed from the document
in a location that this view is responsible for.  This is largely
delegated to the superclass, but is reimplemented to update the
relevant zones (i.e. determine if zones need to be removed or
joined with another zone).

Params:
  • changes – the change information from the associated document
  • a – the current allocation of the view
  • f – the factory to use to rebuild if the view has children
See Also:
/**
     * Gives notification that something was removed from the document
     * in a location that this view is responsible for.  This is largely
     * delegated to the superclass, but is reimplemented to update the
     * relevant zones (i.e. determine if zones need to be removed or
     * joined with another zone).
     *
     * @param changes the change information from the associated document
     * @param a the current allocation of the view
     * @param f the factory to use to rebuild if the view has children
     * @see View#removeUpdate
     */
    public void removeUpdate(DocumentEvent changes, Shape a, ViewFactory f) {
        handleRemove(changes.getOffset(), changes.getLength());
        super.removeUpdate(changes, a, f);
    }

    
Internally created view that has the purpose of holding
the views that represent the children of the ZoneView
that have been arranged in a zone.

/**
     * Internally created view that has the purpose of holding
     * the views that represent the children of the ZoneView
     * that have been arranged in a zone.
     */
    class Zone extends AsyncBoxView {

        private Position start;
        private Position end;

        public Zone(Element elem, Position start, Position end) {
            super(elem, ZoneView.this.getAxis());
            this.start = start;
            this.end = end;
        }

        
Creates the child views and populates the
zone with them.  This is done by translating
the positions to child element index locations
and building views to those elements.  If the
zone is already loaded, this does nothing.

/**
         * Creates the child views and populates the
         * zone with them.  This is done by translating
         * the positions to child element index locations
         * and building views to those elements.  If the
         * zone is already loaded, this does nothing.
         */
        public void load() {
            if (! isLoaded()) {
                setEstimatedMajorSpan(true);
                Element e = getElement();
                ViewFactory f = getViewFactory();
                int index0 = e.getElementIndex(getStartOffset());
                int index1 = e.getElementIndex(getEndOffset());
                View[] added = new View[index1 - index0 + 1];
                for (int i = index0; i <= index1; i++) {
                    added[i - index0] = f.create(e.getElement(i));
                }
                replace(0, 0, added);

                zoneWasLoaded(this);
            }
        }

        
Removes the child views and returns to a
state of unloaded.

/**
         * Removes the child views and returns to a
         * state of unloaded.
         */
        public void unload() {
            setEstimatedMajorSpan(true);
            removeAll();
        }

        
Determines if the zone is in the loaded state
or not.

/**
         * Determines if the zone is in the loaded state
         * or not.
         */
        public boolean isLoaded() {
            return (getViewCount() != 0);
        }

        
This method is reimplemented to not build the children
since the children are created when the zone is loaded
rather then when it is placed in the view hierarchy.
The major span is estimated at this point by building
the first child (but not storing it), and calling
setEstimatedMajorSpan(true) followed by setSpan for
the major axis with the estimated span.

/**
         * This method is reimplemented to not build the children
         * since the children are created when the zone is loaded
         * rather then when it is placed in the view hierarchy.
         * The major span is estimated at this point by building
         * the first child (but not storing it), and calling
         * setEstimatedMajorSpan(true) followed by setSpan for
         * the major axis with the estimated span.
         */
        protected void loadChildren(ViewFactory f) {
            // mark the major span as estimated
            setEstimatedMajorSpan(true);

            // estimate the span
            Element elem = getElement();
            int index0 = elem.getElementIndex(getStartOffset());
            int index1 = elem.getElementIndex(getEndOffset());
            int nChildren = index1 - index0;

            // replace this with something real
            //setSpan(getMajorAxis(), nChildren * 10);

            View first = f.create(elem.getElement(index0));
            first.setParent(this);
            float w = first.getPreferredSpan(X_AXIS);
            float h = first.getPreferredSpan(Y_AXIS);
            if (getMajorAxis() == X_AXIS) {
                w *= nChildren;
            } else {
                h += nChildren;
            }

            setSize(w, h);
        }

        
Publish the changes in preferences upward to the parent
view.


This is reimplemented to stop the superclass behavior
if the zone has not yet been loaded.  If the zone is
unloaded for example, the last seen major span is the
best estimate and a calculated span for no children
is undesirable.

/**
         * Publish the changes in preferences upward to the parent
         * view.
         * <p>
         * This is reimplemented to stop the superclass behavior
         * if the zone has not yet been loaded.  If the zone is
         * unloaded for example, the last seen major span is the
         * best estimate and a calculated span for no children
         * is undesirable.
         */
        protected void flushRequirementChanges() {
            if (isLoaded()) {
                super.flushRequirementChanges();
            }
        }

        
Returns the child view index representing the given position in
the model.  Since the zone contains a cluster of the overall
set of child elements, we can determine the index fairly
quickly from the model by subtracting the index of the
start offset from the index of the position given.

Params:
  • pos – the position >= 0
Returns: index of the view representing the given position, or
  -1 if no view represents that position
Since:1.3
/**
         * Returns the child view index representing the given position in
         * the model.  Since the zone contains a cluster of the overall
         * set of child elements, we can determine the index fairly
         * quickly from the model by subtracting the index of the
         * start offset from the index of the position given.
         *
         * @param pos the position >= 0
         * @return  index of the view representing the given position, or
         *   -1 if no view represents that position
         * @since 1.3
         */
        public int getViewIndex(int pos, Position.Bias b) {
            boolean isBackward = (b == Position.Bias.Backward);
            pos = (isBackward) ? Math.max(0, pos - 1) : pos;
            Element elem = getElement();
            int index1 = elem.getElementIndex(pos);
            int index0 = elem.getElementIndex(getStartOffset());
            return index1 - index0;
        }

        protected boolean updateChildren(DocumentEvent.ElementChange ec,
                                         DocumentEvent e, ViewFactory f) {
            // the structure of this element changed.
            Element[] removedElems = ec.getChildrenRemoved();
            Element[] addedElems = ec.getChildrenAdded();
            Element elem = getElement();
            int index0 = elem.getElementIndex(getStartOffset());
            int index1 = elem.getElementIndex(getEndOffset()-1);
            int index = ec.getIndex();
            if ((index >= index0) && (index <= index1)) {
                // The change is in this zone
                int replaceIndex = index - index0;
                int nadd = Math.min(index1 - index0 + 1, addedElems.length);
                int nremove = Math.min(index1 - index0 + 1, removedElems.length);
                View[] added = new View[nadd];
                for (int i = 0; i < nadd; i++) {
                    added[i] = f.create(addedElems[i]);
                }
                replace(replaceIndex, nremove, added);
            }
            return true;
        }

        // --- View methods ----------------------------------

        
Fetches the attributes to use when rendering.  This view
isn't directly responsible for an element so it returns
the outer classes attributes.

/**
         * Fetches the attributes to use when rendering.  This view
         * isn't directly responsible for an element so it returns
         * the outer classes attributes.
         */
        public AttributeSet getAttributes() {
            return ZoneView.this.getAttributes();
        }

        
Renders using the given rendering surface and area on that
surface.  This is implemented to load the zone if its not
already loaded, and then perform the superclass behavior.

Params:
  • g – the rendering surface to use
  • a – the allocated region to render into
See Also:
/**
         * Renders using the given rendering surface and area on that
         * surface.  This is implemented to load the zone if its not
         * already loaded, and then perform the superclass behavior.
         *
         * @param g the rendering surface to use
         * @param a the allocated region to render into
         * @see View#paint
         */
        public void paint(Graphics g, Shape a) {
            load();
            super.paint(g, a);
        }

        
Provides a mapping from the view coordinate space to the logical
coordinate space of the model.  This is implemented to first
make sure the zone is loaded before providing the superclass
behavior.

Params:
  • x –   x coordinate of the view location to convert >= 0
  • y –   y coordinate of the view location to convert >= 0
  • a – the allocated region to render into
See Also:
Returns:the location within the model that best represents the
 given point in the view >= 0
/**
         * Provides a mapping from the view coordinate space to the logical
         * coordinate space of the model.  This is implemented to first
         * make sure the zone is loaded before providing the superclass
         * behavior.
         *
         * @param x   x coordinate of the view location to convert >= 0
         * @param y   y coordinate of the view location to convert >= 0
         * @param a the allocated region to render into
         * @return the location within the model that best represents the
         *  given point in the view >= 0
         * @see View#viewToModel
         */
        public int viewToModel(float x, float y, Shape a, Position.Bias[] bias) {
            load();
            return super.viewToModel(x, y, a, bias);
        }

        
Provides a mapping from the document model coordinate space
to the coordinate space of the view mapped to it.  This is
implemented to provide the superclass behavior after first
making sure the zone is loaded (The zone must be loaded to
make this calculation).

Params:
  • pos – the position to convert
  • a – the allocated region to render into
Throws:
  • BadLocationException –  if the given position does not represent a
  valid location in the associated document
See Also:
Returns:the bounding box of the given position
/**
         * Provides a mapping from the document model coordinate space
         * to the coordinate space of the view mapped to it.  This is
         * implemented to provide the superclass behavior after first
         * making sure the zone is loaded (The zone must be loaded to
         * make this calculation).
         *
         * @param pos the position to convert
         * @param a the allocated region to render into
         * @return the bounding box of the given position
         * @exception BadLocationException  if the given position does not represent a
         *   valid location in the associated document
         * @see View#modelToView
         */
        public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {
            load();
            return super.modelToView(pos, a, b);
        }

        
Start of the zones range.

See Also:
  • getStartOffset.getStartOffset
/**
         * Start of the zones range.
         *
         * @see View#getStartOffset
         */
        public int getStartOffset() {
            return start.getOffset();
        }

        
End of the zones range.

/**
         * End of the zones range.
         */
        public int getEndOffset() {
            return end.getOffset();
        }

        
Gives notification that something was inserted into
the document in a location that this view is responsible for.
If the zone has been loaded, the superclass behavior is
invoked, otherwise this does nothing.

Params:
  • e – the change information from the associated document
  • a – the current allocation of the view
  • f – the factory to use to rebuild if the view has children
See Also:
/**
         * Gives notification that something was inserted into
         * the document in a location that this view is responsible for.
         * If the zone has been loaded, the superclass behavior is
         * invoked, otherwise this does nothing.
         *
         * @param e the change information from the associated document
         * @param a the current allocation of the view
         * @param f the factory to use to rebuild if the view has children
         * @see View#insertUpdate
         */
        public void insertUpdate(DocumentEvent e, Shape a, ViewFactory f) {
            if (isLoaded()) {
                super.insertUpdate(e, a, f);
            }
        }

        
Gives notification that something was removed from the document
in a location that this view is responsible for.
If the zone has been loaded, the superclass behavior is
invoked, otherwise this does nothing.

Params:
  • e – the change information from the associated document
  • a – the current allocation of the view
  • f – the factory to use to rebuild if the view has children
See Also:
/**
         * Gives notification that something was removed from the document
         * in a location that this view is responsible for.
         * If the zone has been loaded, the superclass behavior is
         * invoked, otherwise this does nothing.
         *
         * @param e the change information from the associated document
         * @param a the current allocation of the view
         * @param f the factory to use to rebuild if the view has children
         * @see View#removeUpdate
         */
        public void removeUpdate(DocumentEvent e, Shape a, ViewFactory f) {
            if (isLoaded()) {
                super.removeUpdate(e, a, f);
            }
        }

        
Gives notification from the document that attributes were changed
in a location that this view is responsible for.
If the zone has been loaded, the superclass behavior is
invoked, otherwise this does nothing.

Params:
  • e – the change information from the associated document
  • a – the current allocation of the view
  • f – the factory to use to rebuild if the view has children
See Also:
/**
         * Gives notification from the document that attributes were changed
         * in a location that this view is responsible for.
         * If the zone has been loaded, the superclass behavior is
         * invoked, otherwise this does nothing.
         *
         * @param e the change information from the associated document
         * @param a the current allocation of the view
         * @param f the factory to use to rebuild if the view has children
         * @see View#removeUpdate
         */
        public void changedUpdate(DocumentEvent e, Shape a, ViewFactory f) {
            if (isLoaded()) {
                super.changedUpdate(e, a, f);
            }
        }

    }
}