public FlowView(Element elem,
    int axis) 
{
        super(elem, axis);
        layoutSpan = Integer.MAX_VALUE;
        strategy = new FlowStrategy();
}

Constructs a FlowView for the given element.

Parameters:

elem - the element that this view is responsible for

axis - may be either View.X_AXIS or View.Y_AXIS

 protected SizeRequirements calculateMinorAxisRequirements(int axis,
    SizeRequirements r) 
{
        if (r == null) {
            r = new SizeRequirements();
        }
        float pref = layoutPool.getPreferredSpan(axis);
        float min = layoutPool.getMinimumSpan(axis);
        // Don't include insets, Box.getXXXSpan will include them.
        r.minimum = (int)min;
        r.preferred = Math.max(r.minimum, (int) pref);
        r.maximum = Integer.MAX_VALUE;
        r.alignment = 0.5f;
        return r;
}

Calculate equirements along the minor axis. This is implemented to forward the request to the logical view by calling getMinimumSpan, getPreferredSpan, and getMaximumSpan on it.

 public  void changedUpdate(DocumentEvent changes,
    Shape a,
    ViewFactory f) 
{
        layoutPool.changedUpdate(changes, a, f);
        strategy.changedUpdate(this, changes, getInsideAllocation(a));
}

Gives notification from the document that attributes were changed in a location that this view is responsible for.

 abstract protected View createRow()
Create a View that should be used to hold a
a rows worth of children in a flow. This is
called by the FlowStrategy when new children
are added or removed (i.e. rows are added or
removed) in the process of updating the flow.

 public int getFlowAxis() 
{
        if (getAxis() == Y_AXIS) {
            return X_AXIS;
        }
        return Y_AXIS;
}

Fetches the axis along which views should be flowed. By default, this will be the axis orthogonal to the axis along which the flow rows are tiled (the axis of the default flow rows themselves). This is typically used by the FlowStrategy.

 public int getFlowSpan(int index) 
{
        return layoutSpan;
}

Fetch the constraining span to flow against for the given child index. This is called by the FlowStrategy while it is updating the flow. A flow can be shaped by providing different values for the row constraints. By default, the entire span inside of the insets along the flow axis is returned.

 public int getFlowStart(int index) 
{
        return 0;
}

Fetch the location along the flow axis that the flow span will start at. This is called by the FlowStrategy while it is updating the flow. A flow can be shaped by providing different values for the row constraints.

 protected int getViewIndexAtPosition(int pos) 
{
        if (pos  >= getStartOffset() && (pos <  getEndOffset())) {
            for (int counter = 0; counter <  getViewCount(); counter++) {
                View v = getView(counter);
                if(pos  >= v.getStartOffset() &&
                   pos <  v.getEndOffset()) {
                    return counter;
                }
            }
        }
        return -1;
}

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

 public  void insertUpdate(DocumentEvent changes,
    Shape a,
    ViewFactory f) 
{
        layoutPool.insertUpdate(changes, a, f);
        strategy.insertUpdate(this, changes, getInsideAllocation(a));
}

Gives notification that something was inserted into the document in a location that this view is responsible for.

 protected  void layout(int width,
    int height) 
{
        final int faxis = getFlowAxis();
        int newSpan;
        if (faxis == X_AXIS) {
            newSpan = (int)width;
        } else {
            newSpan = (int)height;
        }
        if (layoutSpan != newSpan) {
            layoutChanged(faxis);
            layoutChanged(getAxis());
            layoutSpan = newSpan;
        }
        // repair the flow if necessary
        if (! isLayoutValid(faxis)) {
            final int heightAxis = getAxis();
            int oldFlowHeight = (int)((heightAxis == X_AXIS)? getWidth() : getHeight());
            strategy.layout(this);
            int newFlowHeight = (int) getPreferredSpan(heightAxis);
            if (oldFlowHeight != newFlowHeight) {
                View p = getParent();
                if (p != null) {
                    p.preferenceChanged(this, (heightAxis == X_AXIS), (heightAxis == Y_AXIS));
                }
                // PENDING(shannonh)
                // Temporary fix for 4250847
                // Can be removed when TraversalContext is added
                Component host = getContainer();
                if (host != null) {
                    //nb idk 12/12/2001 host should not be equal to null. We need to add assertion here
                    host.repaint();
                }
            }
        }
        super.layout(width, height);
}

Lays out the children. If the span along the flow axis has changed, layout is marked as invalid which which will cause the superclass behavior to recalculate the layout along the box axis. The FlowStrategy.layout method will be called to rebuild the flow rows as appropriate. If the height of this view changes (determined by the perferred size along the box axis), a preferenceChanged is called. Following all of that, the normal box layout of the superclass is performed.

 protected  void loadChildren(ViewFactory f) 
{
        if (layoutPool == null) {
            layoutPool = new LogicalView(getElement());
        }
        layoutPool.setParent(this);
        // This synthetic insertUpdate call gives the strategy a chance
        // to initialize.
        strategy.insertUpdate(this, null, null);
}

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 in the process of formatting). If the layoutPool variable is null, an instance of LogicalView is created to represent the logical view that is used in the process of formatting.

 public  void removeUpdate(DocumentEvent changes,
    Shape a,
    ViewFactory f) 
{
        layoutPool.removeUpdate(changes, a, f);
        strategy.removeUpdate(this, changes, getInsideAllocation(a));
}

Gives notification that something was removed from the document in a location that this view is responsible for.

 public  void setParent(View parent) 
{
        super.setParent(parent);
        if (parent == null
                && layoutPool != null ) {
            layoutPool.setParent(null);
        }
}

{@inheritDoc}