diff options
Diffstat (limited to 'libjava/classpath/javax/swing/text/FlowView.java')
| -rw-r--r-- | libjava/classpath/javax/swing/text/FlowView.java | 617 |
1 files changed, 617 insertions, 0 deletions
diff --git a/libjava/classpath/javax/swing/text/FlowView.java b/libjava/classpath/javax/swing/text/FlowView.java new file mode 100644 index 00000000000..a6ef89efb78 --- /dev/null +++ b/libjava/classpath/javax/swing/text/FlowView.java @@ -0,0 +1,617 @@ +/* FlowView.java -- A composite View + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package javax.swing.text; + +import java.awt.Container; +import java.awt.Graphics; +import java.awt.Rectangle; +import java.awt.Shape; +import java.util.Vector; + +import javax.swing.event.DocumentEvent; + +/** + * A <code>View</code> that can flows it's children into it's layout space. + * + * The <code>FlowView</code> manages a set of logical views (that are + * the children of the {@link #layoutPool} field). These are translated + * at layout time into a set of physical views. These are the views that + * are managed as the real child views. Each of these child views represents + * a row and are laid out within a box using the superclasses behaviour. + * The concrete implementation of the rows must be provided by subclasses. + * + * @author Roman Kennke (roman@kennke.org) + */ +public abstract class FlowView extends BoxView +{ + /** + * A strategy for translating the logical views of a <code>FlowView</code> + * into the real views. + */ + public static class FlowStrategy + { + /** + * Creates a new instance of <code>FlowStragegy</code>. + */ + public FlowStrategy() + { + } + + /** + * Receives notification from a <code>FlowView</code> that some content + * has been inserted into the document at a location that the + * <code>FlowView</code> is responsible for. + * + * The default implementation simply calls {@link #layout}. + * + * @param fv the flow view that sends the notification + * @param e the document event describing the change + * @param alloc the current allocation of the flow view + */ + public void insertUpdate(FlowView fv, DocumentEvent e, Rectangle alloc) + { + layout(fv); + } + + /** + * Receives notification from a <code>FlowView</code> that some content + * has been removed from the document at a location that the + * <code>FlowView</code> is responsible for. + * + * The default implementation simply calls {@link #layout}. + * + * @param fv the flow view that sends the notification + * @param e the document event describing the change + * @param alloc the current allocation of the flow view + */ + public void removeUpdate(FlowView fv, DocumentEvent e, Rectangle alloc) + { + layout(fv); + } + + /** + * Receives notification from a <code>FlowView</code> that some attributes + * have changed in the document at a location that the + * <code>FlowView</code> is responsible for. + * + * The default implementation simply calls {@link #layout}. + * + * @param fv the flow view that sends the notification + * @param e the document event describing the change + * @param alloc the current allocation of the flow view + */ + public void changedUpdate(FlowView fv, DocumentEvent e, Rectangle alloc) + { + layout(fv); + } + + /** + * Returns the logical view of the managed <code>FlowView</code>. + * + * @param fv the flow view for which to return the logical view + * + * @return the logical view of the managed <code>FlowView</code> + */ + public View getLogicalView(FlowView fv) + { + return fv.layoutPool; + } + + /** + * Performs the layout for the whole view. By default this rebuilds + * all the physical views from the logical views of the managed FlowView. + * + * This is called by {@link FlowLayout#layout} to update the layout of + * the view. + * + * @param fv the flow view for which we perform the layout + */ + public void layout(FlowView fv) + { + fv.removeAll(); + Element el = fv.getElement(); + + int rowStart = el.getStartOffset(); + int end = el.getEndOffset(); + int rowIndex = 0; + while (rowStart >= 0 && rowStart < end) + { + View row = fv.createRow(); + fv.append(row); + rowStart = layoutRow(fv, rowIndex, rowStart); + rowIndex++; + } + } + + /** + * Lays out one row of the flow view. This is called by {@link #layout} + * to fill one row with child views until the available span is exhausted. + * + * @param fv the flow view for which we perform the layout + * @param rowIndex the index of the row + * @param pos the start position for the row + * + * @return the start position of the next row + */ + protected int layoutRow(FlowView fv, int rowIndex, int pos) + { + int spanLeft = fv.getFlowSpan(rowIndex); + if (spanLeft <= 0) + return -1; + + int offset = pos; + View row = fv.getView(rowIndex); + int flowAxis = fv.getFlowAxis(); + + while (spanLeft > 0) + { + View child = createView(fv, offset, spanLeft, rowIndex); + if (child == null) + break; + + int span = (int) child.getPreferredSpan(flowAxis); + if (span > spanLeft) + break; + + row.append(child); + spanLeft -= span; + offset = child.getEndOffset(); + } + return offset; + } + + /** + * Creates physical views that form the rows of the flow view. This + * can be an entire view from the logical view (if it fits within the + * available span), a fragment of such a view (if it doesn't fit in the + * available span and can be broken down) or <code>null</code> (if it does + * not fit in the available span and also cannot be broken down). + * + * @param fv the flow view + * @param startOffset the start offset for the view to be created + * @param spanLeft the available span + * @param rowIndex the index of the row + * + * @return a view to fill the row with, or <code>null</code> if there + * is no view or view fragment that fits in the available span + */ + protected View createView(FlowView fv, int offset, int spanLeft, + int rowIndex) + { + // Find the logical element for the given offset. + View logicalView = getLogicalView(fv); + + int viewIndex = logicalView.getViewIndex(offset, Position.Bias.Forward); + View child = logicalView.getView(viewIndex); + int flowAxis = fv.getFlowAxis(); + int span = (int) child.getPreferredSpan(flowAxis); + + if (span <= spanLeft) + return child; + + else if (child.getBreakWeight(flowAxis, offset, spanLeft) + > BadBreakWeight) + // FIXME: What to do with the pos parameter here? + return child.breakView(flowAxis, offset, 0, spanLeft); + else + return null; + } + } + + /** + * This special subclass of <code>View</code> is used to represent + * the logical representation of this view. It does not support any + * visual representation, this is handled by the physical view implemented + * in the <code>FlowView</code>. + */ + class LogicalView extends View + { + /** + * The child views of this logical view. + */ + Vector children; + + /** + * Creates a new LogicalView instance. + */ + LogicalView(Element el) + { + super(el); + children = new Vector(); + } + + /** + * Returns the container that holds this view. The logical view returns + * the enclosing FlowView's container here. + * + * @return the container that holds this view + */ + public Container getContainer() + { + return FlowView.this.getContainer(); + } + + /** + * Returns the number of child views of this logical view. + * + * @return the number of child views of this logical view + */ + public int getViewCount() + { + return children.size(); + } + + /** + * Returns the child view at the specified index. + * + * @param index the index + * + * @return the child view at the specified index + */ + public View getView(int index) + { + return (View) children.get(index); + } + + /** + * Replaces some child views with other child views. + * + * @param offset the offset at which to replace child views + * @param length the number of children to remove + * @param views the views to be inserted + */ + public void replace(int offset, int length, View[] views) + { + if (length > 0) + { + for (int count = 0; count < length; ++count) + children.remove(offset); + } + + int endOffset = offset + views.length; + for (int i = offset; i < endOffset; ++i) + { + children.add(i, views[i - offset]); + // Set the parent of the child views to the flow view itself so + // it has something to resolve. + views[i - offset].setParent(FlowView.this); + } + } + + /** + * Returns the index of the child view that contains the specified + * position in the document model. + * + * @param pos the position for which we are searching the child view + * @param b the bias + * + * @return the index of the child view that contains the specified + * position in the document model + */ + public int getViewIndex(int pos, Position.Bias b) + { + return getElement().getElementIndex(pos); + } + + /** + * Throws an AssertionError because it must never be called. LogicalView + * only serves as a holder for child views and has no visual + * representation. + */ + public float getPreferredSpan(int axis) + { + throw new AssertionError("This method must not be called in " + + "LogicalView."); + } + + /** + * Throws an AssertionError because it must never be called. LogicalView + * only serves as a holder for child views and has no visual + * representation. + */ + public Shape modelToView(int pos, Shape a, Position.Bias b) + throws BadLocationException + { + throw new AssertionError("This method must not be called in " + + "LogicalView."); + } + + /** + * Throws an AssertionError because it must never be called. LogicalView + * only serves as a holder for child views and has no visual + * representation. + */ + public void paint(Graphics g, Shape s) + { + throw new AssertionError("This method must not be called in " + + "LogicalView."); + } + + /** + * Throws an AssertionError because it must never be called. LogicalView + * only serves as a holder for child views and has no visual + * representation. + */ + public int viewToModel(float x, float y, Shape a, Position.Bias[] b) + { + throw new AssertionError("This method must not be called in " + + "LogicalView."); + } + } + + /** + * The shared instance of FlowStrategy. + */ + static final FlowStrategy sharedStrategy = new FlowStrategy(); + + /** + * The span of the <code>FlowView</code> that should be flowed. + */ + protected int layoutSpan; + + /** + * Represents the logical child elements of this view, encapsulated within + * one parent view (an instance of a package private <code>LogicalView</code> + * class). These will be translated to a set of real views that are then + * displayed on screen. This translation is performed by the inner class + * {@link FlowStrategy}. + */ + protected View layoutPool; + + /** + * The <code>FlowStrategy</code> to use for translating between the + * logical and physical view. + */ + protected FlowStrategy strategy; + + /** + * Creates a new <code>FlowView</code> for the given + * <code>Element</code> and <code>axis</code>. + * + * @param element the element that is rendered by this FlowView + * @param axis the axis along which the view is tiled, either + * <code>View.X_AXIS</code> or <code>View.Y_AXIS</code>, the flow + * axis is orthogonal to this one + */ + public FlowView(Element element, int axis) + { + super(element, axis); + strategy = sharedStrategy; + } + + /** + * Returns the axis along which the view should be flowed. This is + * orthogonal to the axis along which the boxes are tiled. + * + * @return the axis along which the view should be flowed + */ + public int getFlowAxis() + { + int axis = getAxis(); + int flowAxis; + + if (axis == X_AXIS) + flowAxis = Y_AXIS; + else + flowAxis = X_AXIS; + + return flowAxis; + + } + + /** + * Returns the span of the flow for the specified child view. A flow + * layout can be shaped by providing different span values for different + * child indices. The default implementation returns the entire available + * span inside the view. + * + * @param index the index of the child for which to return the span + * + * @return the span of the flow for the specified child view + */ + public int getFlowSpan(int index) + { + return layoutSpan; + } + + /** + * Returns the location along the flow axis where the flow span starts + * given a child view index. The flow can be shaped by providing + * different values here. + * + * @param index the index of the child for which to return the flow location + * + * @return the location along the flow axis where the flow span starts + */ + public int getFlowStart(int index) + { + return getLeftInset(); // TODO: Is this correct? + } + + /** + * Creates a new view that represents a row within a flow. + * + * @return a view for a new row + */ + protected abstract View createRow(); + + /** + * Loads the children of this view. The <code>FlowView</code> does not + * directly load its children. Instead it creates a logical view + * (@{link #layoutPool}) which is filled by the logical child views. + * The real children are created at layout time and each represent one + * row. + * + * This method is called by {@link #setParent} in order to initialize + * the view. + * + * @param vf the view factory to use for creating the child views + */ + protected void loadChildren(ViewFactory vf) + { + if (layoutPool == null) + { + layoutPool = new LogicalView(getElement()); + + Element el = getElement(); + int count = el.getElementCount(); + for (int i = 0; i < count; ++i) + { + Element childEl = el.getElement(i); + View childView = vf.create(childEl); + layoutPool.append(childView); + } + } + } + + /** + * Performs the layout of this view. If the span along the flow axis changed, + * this first calls {@link FlowStrategy.layout} in order to rebuild the + * rows of this view. Then the superclass's behaviour is called to arrange + * the rows within the box. + * + * @param width the width of the view + * @param height the height of the view + */ + protected void layout(int width, int height) + { + boolean rebuild = false; + + int flowAxis = getFlowAxis(); + if (flowAxis == X_AXIS) + { + rebuild = !(width == layoutSpan); + layoutSpan = width; + } + else + { + rebuild = !(height == layoutSpan); + layoutSpan = height; + } + + if (rebuild) + strategy.layout(this); + + // TODO: If the span along the box axis has changed in the process of + // relayouting the rows (that is, if rows have been added or removed), + // call preferenceChanged in order to throw away cached layout information + // of the surrounding BoxView. + + super.layout(width, height); + } + + /** + * Receice notification that some content has been inserted in the region + * that this view is responsible for. This calls + * {@link FlowStrategy#insertUpdate}. + * + * @param changes the document event describing the changes + * @param a the current allocation of the view + * @param vf the view factory that is used for creating new child views + */ + public void insertUpdate(DocumentEvent changes, Shape a, ViewFactory vf) + { + strategy.insertUpdate(this, changes, getInsideAllocation(a)); + } + + /** + * Receice notification that some content has been removed from the region + * that this view is responsible for. This calls + * {@link FlowStrategy#removeUpdate}. + * + * @param changes the document event describing the changes + * @param a the current allocation of the view + * @param vf the view factory that is used for creating new child views + */ + public void removeUpdate(DocumentEvent changes, Shape a, ViewFactory vf) + { + strategy.removeUpdate(this, changes, getInsideAllocation(a)); + } + + /** + * Receice notification that some attributes changed in the region + * that this view is responsible for. This calls + * {@link FlowStrategy#changedUpdate}. + * + * @param changes the document event describing the changes + * @param a the current allocation of the view + * @param vf the view factory that is used for creating new child views + */ + public void changedUpdate(DocumentEvent changes, Shape a, ViewFactory vf) + { + strategy.changedUpdate(this, changes, getInsideAllocation(a)); + } + + /** + * Returns the index of the child <code>View</code> for the given model + * position. + * + * This is implemented to iterate over the children of this + * view (the rows) and return the index of the first view that contains + * the given position. + * + * @param pos the model position for whicht the child <code>View</code> is + * queried + * + * @return the index of the child <code>View</code> for the given model + * position + */ + protected int getViewIndexAtPosition(int pos) + { + // First make sure we have a valid layout. + if (!isAllocationValid()) + layout(getWidth(), getHeight()); + + int count = getViewCount(); + int result = -1; + + for (int i = 0; i < count; ++i) + { + View child = getView(i); + int start = child.getStartOffset(); + int end = child.getEndOffset(); + if (start <= pos && end > pos) + { + result = i; + break; + } + } + return result; + } +} |
