| /* BlockView.java -- |
| 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.html; |
| |
| import gnu.javax.swing.text.html.css.Length; |
| |
| import java.awt.Graphics; |
| import java.awt.Rectangle; |
| import java.awt.Shape; |
| import java.util.HashMap; |
| |
| import javax.swing.SizeRequirements; |
| import javax.swing.event.DocumentEvent; |
| import javax.swing.text.AttributeSet; |
| import javax.swing.text.BoxView; |
| import javax.swing.text.Element; |
| import javax.swing.text.View; |
| import javax.swing.text.ViewFactory; |
| |
| /** |
| * @author Lillian Angel <langel@redhat.com> |
| */ |
| public class BlockView extends BoxView |
| { |
| |
| /** |
| * Stores information about child positioning according to the |
| * CSS attributes position, left, right, top and bottom. |
| */ |
| private static class PositionInfo |
| { |
| // TODO: Use enums when available. |
| |
| /** |
| * Static positioning. This is the default and is thus rarely really |
| * used. |
| */ |
| static final int STATIC = 0; |
| |
| /** |
| * Relative positioning. The box is teaked relative to its static |
| * computed bounds. |
| */ |
| static final int RELATIVE = 1; |
| |
| /** |
| * Absolute positioning. The box is moved relative to the parent's box. |
| */ |
| static final int ABSOLUTE = 2; |
| |
| /** |
| * Like ABSOLUTE, with some fixation against the viewport (not yet |
| * implemented). |
| */ |
| static final int FIXED = 3; |
| |
| /** |
| * The type according to the constants of this class. |
| */ |
| int type; |
| |
| /** |
| * The left constraint, null if not set. |
| */ |
| Length left; |
| |
| /** |
| * The right constraint, null if not set. |
| */ |
| Length right; |
| |
| /** |
| * The top constraint, null if not set. |
| */ |
| Length top; |
| |
| /** |
| * The bottom constraint, null if not set. |
| */ |
| Length bottom; |
| |
| /** |
| * Creates a new PositionInfo object. |
| * |
| * @param typ the type to set |
| * @param l the left constraint |
| * @param r the right constraint |
| * @param t the top constraint |
| * @param b the bottom constraint |
| */ |
| PositionInfo(int typ, Length l, Length r, Length t, Length b) |
| { |
| type = typ; |
| left = l; |
| right = r; |
| top = t; |
| bottom = b; |
| } |
| } |
| |
| /** |
| * The attributes for this view. |
| */ |
| private AttributeSet attributes; |
| |
| /** |
| * The box painter for this view. |
| * |
| * This is package private because the TableView needs access to it. |
| */ |
| StyleSheet.BoxPainter painter; |
| |
| /** |
| * The width and height as specified in the stylesheet, null if not |
| * specified. The first value is the X_AXIS, the second the Y_AXIS. You |
| * can index this directly by the X_AXIS and Y_AXIS constants. |
| */ |
| private Length[] cssSpans; |
| |
| /** |
| * Stores additional CSS layout information. |
| */ |
| private HashMap positionInfo; |
| |
| /** |
| * Creates a new view that represents an html box. |
| * This can be used for a number of elements. |
| * |
| * @param elem - the element to create a view for |
| * @param axis - either View.X_AXIS or View.Y_AXIS |
| */ |
| public BlockView(Element elem, int axis) |
| { |
| super(elem, axis); |
| cssSpans = new Length[2]; |
| positionInfo = new HashMap(); |
| } |
| |
| /** |
| * Creates the parent view for this. It is called before |
| * any other methods, if the parent view is working properly. |
| * Implemented to forward to the superclass and call |
| * setPropertiesFromAttributes to set the paragraph |
| * properties. |
| * |
| * @param parent - the new parent, or null if the view |
| * is being removed from a parent it was added to. |
| */ |
| public void setParent(View parent) |
| { |
| super.setParent(parent); |
| |
| if (parent != null) |
| setPropertiesFromAttributes(); |
| } |
| |
| /** |
| * Calculates the requirements along the major axis. |
| * This is implemented to call the superclass and then |
| * adjust it if the CSS width or height attribute is specified |
| * and applicable. |
| * |
| * @param axis - the axis to check the requirements for. |
| * @param r - the SizeRequirements. If null, one is created. |
| * @return the new SizeRequirements object. |
| */ |
| protected SizeRequirements calculateMajorAxisRequirements(int axis, |
| SizeRequirements r) |
| { |
| if (r == null) |
| r = new SizeRequirements(); |
| |
| if (setCSSSpan(r, axis)) |
| { |
| // If we have set the span from CSS, then we need to adjust |
| // the margins. |
| SizeRequirements parent = super.calculateMajorAxisRequirements(axis, |
| null); |
| int margin = axis == X_AXIS ? getLeftInset() + getRightInset() |
| : getTopInset() + getBottomInset(); |
| r.minimum -= margin; |
| r.preferred -= margin; |
| r.maximum -= margin; |
| constrainSize(axis, r, parent); |
| } |
| else |
| r = super.calculateMajorAxisRequirements(axis, r); |
| return r; |
| } |
| |
| /** |
| * Calculates the requirements along the minor axis. |
| * This is implemented to call the superclass and then |
| * adjust it if the CSS width or height attribute is specified |
| * and applicable. |
| * |
| * @param axis - the axis to check the requirements for. |
| * @param r - the SizeRequirements. If null, one is created. |
| * @return the new SizeRequirements object. |
| */ |
| protected SizeRequirements calculateMinorAxisRequirements(int axis, |
| SizeRequirements r) |
| { |
| if (r == null) |
| r = new SizeRequirements(); |
| |
| if (setCSSSpan(r, axis)) |
| { |
| // If we have set the span from CSS, then we need to adjust |
| // the margins. |
| SizeRequirements parent = super.calculateMinorAxisRequirements(axis, |
| null); |
| int margin = axis == X_AXIS ? getLeftInset() + getRightInset() |
| : getTopInset() + getBottomInset(); |
| r.minimum -= margin; |
| r.preferred -= margin; |
| r.maximum -= margin; |
| constrainSize(axis, r, parent); |
| } |
| else |
| r = super.calculateMinorAxisRequirements(axis, r); |
| |
| // Apply text alignment if appropriate. |
| if (axis == X_AXIS) |
| { |
| Object o = getAttributes().getAttribute(CSS.Attribute.TEXT_ALIGN); |
| if (o != null) |
| { |
| String al = o.toString().trim(); |
| if (al.equals("center")) |
| r.alignment = 0.5f; |
| else if (al.equals("right")) |
| r.alignment = 1.0f; |
| else |
| r.alignment = 0.0f; |
| } |
| } |
| return r; |
| } |
| |
| /** |
| * Sets the span on the SizeRequirements object according to the |
| * according CSS span value, when it is set. |
| * |
| * @param r the size requirements |
| * @param axis the axis |
| * |
| * @return <code>true</code> when the CSS span has been set, |
| * <code>false</code> otherwise |
| */ |
| private boolean setCSSSpan(SizeRequirements r, int axis) |
| { |
| boolean ret = false; |
| Length span = cssSpans[axis]; |
| // We can't set relative CSS spans here because we don't know |
| // yet about the allocated span. Instead we use the view's |
| // normal requirements. |
| if (span != null && ! span.isPercentage()) |
| { |
| r.minimum = (int) span.getValue(); |
| r.preferred = (int) span.getValue(); |
| r.maximum = (int) span.getValue(); |
| ret = true; |
| } |
| return ret; |
| } |
| |
| /** |
| * Constrains the <code>r</code> requirements according to |
| * <code>min</code>. |
| * |
| * @param axis the axis |
| * @param r the requirements to constrain |
| * @param min the constraining requirements |
| */ |
| private void constrainSize(int axis, SizeRequirements r, |
| SizeRequirements min) |
| { |
| if (min.minimum > r.minimum) |
| { |
| r.minimum = min.minimum; |
| r.preferred = min.minimum; |
| r.maximum = Math.max(r.maximum, min.maximum); |
| } |
| } |
| |
| /** |
| * Lays out the box along the minor axis (the axis that is |
| * perpendicular to the axis that it represents). The results |
| * of the layout are placed in the given arrays which are |
| * the allocations to the children along the minor axis. |
| * |
| * @param targetSpan - the total span given to the view, also |
| * used to layout the children. |
| * @param axis - the minor axis |
| * @param offsets - the offsets from the origin of the view for |
| * all the child views. This is a return value and is filled in by this |
| * function. |
| * @param spans - the span of each child view. This is a return value and is |
| * filled in by this function. |
| */ |
| protected void layoutMinorAxis(int targetSpan, int axis, |
| int[] offsets, int[] spans) |
| { |
| int viewCount = getViewCount(); |
| for (int i = 0; i < viewCount; i++) |
| { |
| View view = getView(i); |
| int min = (int) view.getMinimumSpan(axis); |
| int max; |
| // Handle CSS span value of child. |
| Length length = cssSpans[axis]; |
| if (length != null) |
| { |
| min = Math.max((int) length.getValue(targetSpan), min); |
| max = min; |
| } |
| else |
| max = (int) view.getMaximumSpan(axis); |
| |
| if (max < targetSpan) |
| { |
| // Align child. |
| float align = view.getAlignment(axis); |
| offsets[i] = (int) ((targetSpan - max) * align); |
| spans[i] = max; |
| } |
| else |
| { |
| offsets[i] = 0; |
| spans[i] = Math.max(min, targetSpan); |
| } |
| |
| // Adjust according to CSS position info. |
| positionView(targetSpan, axis, i, offsets, spans); |
| } |
| } |
| |
| /** |
| * Overridden to perform additional CSS layout (absolute/relative |
| * positioning). |
| */ |
| protected void layoutMajorAxis(int targetSpan, int axis, |
| int[] offsets, int[] spans) |
| { |
| super.layoutMajorAxis(targetSpan, axis, offsets, spans); |
| |
| // Adjust according to CSS position info. |
| int viewCount = getViewCount(); |
| for (int i = 0; i < viewCount; i++) |
| { |
| positionView(targetSpan, axis, i, offsets, spans); |
| } |
| } |
| |
| /** |
| * Positions a view according to any additional CSS constraints. |
| * |
| * @param targetSpan the target span |
| * @param axis the axis |
| * @param i the index of the view |
| * @param offsets the offsets get placed here |
| * @param spans the spans get placed here |
| */ |
| private void positionView(int targetSpan, int axis, int i, int[] offsets, |
| int[] spans) |
| { |
| View view = getView(i); |
| PositionInfo pos = (PositionInfo) positionInfo.get(view); |
| if (pos != null) |
| { |
| int p0 = -1; |
| int p1 = -1; |
| if (axis == X_AXIS) |
| { |
| Length l = pos.left; |
| if (l != null) |
| p0 = (int) l.getValue(targetSpan); |
| l = pos.right; |
| if (l != null) |
| p1 = (int) l.getValue(targetSpan); |
| } |
| else |
| { |
| Length l = pos.top; |
| if (l != null) |
| p0 = (int) l.getValue(targetSpan); |
| l = pos.bottom; |
| if (l != null) |
| p1 = (int) l.getValue(targetSpan); |
| } |
| if (pos.type == PositionInfo.ABSOLUTE |
| || pos.type == PositionInfo.FIXED) |
| { |
| if (p0 != -1) |
| { |
| offsets[i] = p0; |
| if (p1 != -1) |
| { |
| // Overrides computed width. (Possibly overconstrained |
| // when the width attribute was set too.) |
| spans[i] = targetSpan - p1 - offsets[i]; |
| } |
| } |
| else if (p1 != -1) |
| { |
| // Preserve any computed width. |
| offsets[i] = targetSpan - p1 - spans[i]; |
| } |
| } |
| else if (pos.type == PositionInfo.RELATIVE) |
| { |
| if (p0 != -1) |
| { |
| offsets[i] += p0; |
| if (p1 != -1) |
| { |
| // Overrides computed width. (Possibly overconstrained |
| // when the width attribute was set too.) |
| spans[i] = spans[i] - p0 - p1 - offsets[i]; |
| } |
| } |
| else if (p1 != -1) |
| { |
| // Preserve any computed width. |
| offsets[i] -= p1; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Paints using the given graphics configuration and shape. |
| * This delegates to the css box painter to paint the |
| * border and background prior to the interior. |
| * |
| * @param g - Graphics configuration |
| * @param a - the Shape to render into. |
| */ |
| public void paint(Graphics g, Shape a) |
| { |
| Rectangle rect = a instanceof Rectangle ? (Rectangle) a : a.getBounds(); |
| |
| // Debug output. Shows blocks in green rectangles. |
| // g.setColor(Color.GREEN); |
| // g.drawRect(rect.x, rect.y, rect.width, rect.height); |
| |
| painter.paint(g, rect.x, rect.y, rect.width, rect.height, this); |
| super.paint(g, a); |
| } |
| |
| /** |
| * Fetches the attributes to use when painting. |
| * |
| * @return the attributes of this model. |
| */ |
| public AttributeSet getAttributes() |
| { |
| if (attributes == null) |
| attributes = getStyleSheet().getViewAttributes(this); |
| return attributes; |
| } |
| |
| /** |
| * Gets the resize weight. |
| * |
| * @param axis - the axis to get the resize weight for. |
| * @return the resize weight. |
| * @throws IllegalArgumentException - for an invalid axis |
| */ |
| public int getResizeWeight(int axis) throws IllegalArgumentException |
| { |
| // Can't resize the Y_AXIS |
| if (axis == Y_AXIS) |
| return 0; |
| if (axis == X_AXIS) |
| return 1; |
| throw new IllegalArgumentException("Invalid Axis"); |
| } |
| |
| /** |
| * Gets the alignment. |
| * |
| * @param axis - the axis to get the alignment for. |
| * @return the alignment. |
| */ |
| public float getAlignment(int axis) |
| { |
| if (axis == X_AXIS) |
| return super.getAlignment(axis); |
| if (axis == Y_AXIS) |
| { |
| if (getViewCount() == 0) |
| return 0.0F; |
| float prefHeight = getPreferredSpan(Y_AXIS); |
| View first = getView(0); |
| float firstRowHeight = first.getPreferredSpan(Y_AXIS); |
| return prefHeight != 0 ? (firstRowHeight * first.getAlignment(Y_AXIS)) |
| / prefHeight |
| : 0; |
| } |
| throw new IllegalArgumentException("Invalid Axis"); |
| } |
| |
| /** |
| * Gives notification from the document that attributes were |
| * changed in a location that this view is responsible for. |
| * |
| * @param ev - the change information |
| * @param a - the current shape of the view |
| * @param f - the factory to use to rebuild if the view has children. |
| */ |
| public void changedUpdate(DocumentEvent ev, |
| Shape a, ViewFactory f) |
| { |
| super.changedUpdate(ev, a, f); |
| |
| // If more elements were added, then need to set the properties for them |
| int currPos = ev.getOffset(); |
| if (currPos <= getStartOffset() |
| && (currPos + ev.getLength()) >= getEndOffset()) |
| setPropertiesFromAttributes(); |
| } |
| |
| /** |
| * Determines the preferred span along the axis. |
| * |
| * @param axis - the view to get the preferred span for. |
| * @return the span the view would like to be painted into >=0/ |
| * The view is usually told to paint into the span that is returned, |
| * although the parent may choose to resize or break the view. |
| * @throws IllegalArgumentException - for an invalid axis |
| */ |
| public float getPreferredSpan(int axis) throws IllegalArgumentException |
| { |
| if (axis == X_AXIS || axis == Y_AXIS) |
| return super.getPreferredSpan(axis); |
| throw new IllegalArgumentException("Invalid Axis"); |
| } |
| |
| /** |
| * Determines the minimum span along the axis. |
| * |
| * @param axis - the axis to get the minimum span for. |
| * @return the span the view would like to be painted into >=0/ |
| * The view is usually told to paint into the span that is returned, |
| * although the parent may choose to resize or break the view. |
| * @throws IllegalArgumentException - for an invalid axis |
| */ |
| public float getMinimumSpan(int axis) throws IllegalArgumentException |
| { |
| if (axis == X_AXIS || axis == Y_AXIS) |
| return super.getMinimumSpan(axis); |
| throw new IllegalArgumentException("Invalid Axis"); |
| } |
| |
| /** |
| * Determines the maximum span along the axis. |
| * |
| * @param axis - the axis to get the maximum span for. |
| * @return the span the view would like to be painted into >=0/ |
| * The view is usually told to paint into the span that is returned, |
| * although the parent may choose to resize or break the view. |
| * @throws IllegalArgumentException - for an invalid axis |
| */ |
| public float getMaximumSpan(int axis) throws IllegalArgumentException |
| { |
| if (axis == X_AXIS || axis == Y_AXIS) |
| return super.getMaximumSpan(axis); |
| throw new IllegalArgumentException("Invalid Axis"); |
| } |
| |
| /** |
| * Updates any cached values that come from attributes. |
| */ |
| protected void setPropertiesFromAttributes() |
| { |
| // Fetch attributes. |
| StyleSheet ss = getStyleSheet(); |
| attributes = ss.getViewAttributes(this); |
| |
| // Fetch painter. |
| painter = ss.getBoxPainter(attributes); |
| |
| // Update insets. |
| if (attributes != null) |
| { |
| setInsets((short) painter.getInset(TOP, this), |
| (short) painter.getInset(LEFT, this), |
| (short) painter.getInset(BOTTOM, this), |
| (short) painter.getInset(RIGHT, this)); |
| } |
| |
| // Fetch width and height. |
| float emBase = ss.getEMBase(attributes); |
| float exBase = ss.getEXBase(attributes); |
| cssSpans[X_AXIS] = (Length) attributes.getAttribute(CSS.Attribute.WIDTH); |
| if (cssSpans[X_AXIS] != null) |
| cssSpans[X_AXIS].setFontBases(emBase, exBase); |
| cssSpans[Y_AXIS] = (Length) attributes.getAttribute(CSS.Attribute.HEIGHT); |
| if (cssSpans[Y_AXIS] != null) |
| cssSpans[Y_AXIS].setFontBases(emBase, exBase); |
| } |
| |
| /** |
| * Gets the default style sheet. |
| * |
| * @return the style sheet |
| */ |
| protected StyleSheet getStyleSheet() |
| { |
| HTMLDocument doc = (HTMLDocument) getDocument(); |
| return doc.getStyleSheet(); |
| } |
| |
| /** |
| * Overridden to fetch additional CSS layout information. |
| */ |
| public void replace(int offset, int length, View[] views) |
| { |
| // First remove unneeded stuff. |
| for (int i = 0; i < length; i++) |
| { |
| View child = getView(i + offset); |
| positionInfo.remove(child); |
| } |
| |
| // Call super to actually replace the views. |
| super.replace(offset, length, views); |
| |
| // Now fetch the position infos for the new views. |
| for (int i = 0; i < views.length; i++) |
| { |
| fetchLayoutInfo(views[i]); |
| } |
| } |
| |
| /** |
| * Fetches and stores the layout info for the specified view. |
| * |
| * @param view the view for which the layout info is stored |
| */ |
| private void fetchLayoutInfo(View view) |
| { |
| AttributeSet atts = view.getAttributes(); |
| Object o = atts.getAttribute(CSS.Attribute.POSITION); |
| if (o != null && o instanceof String && ! o.equals("static")) |
| { |
| int type; |
| if (o.equals("relative")) |
| type = PositionInfo.RELATIVE; |
| else if (o.equals("absolute")) |
| type = PositionInfo.ABSOLUTE; |
| else if (o.equals("fixed")) |
| type = PositionInfo.FIXED; |
| else |
| type = PositionInfo.STATIC; |
| |
| if (type != PositionInfo.STATIC) |
| { |
| StyleSheet ss = getStyleSheet(); |
| float emBase = ss.getEMBase(atts); |
| float exBase = ss.getEXBase(atts); |
| Length left = (Length) atts.getAttribute(CSS.Attribute.LEFT); |
| if (left != null) |
| left.setFontBases(emBase, exBase); |
| Length right = (Length) atts.getAttribute(CSS.Attribute.RIGHT); |
| if (right != null) |
| right.setFontBases(emBase, exBase); |
| Length top = (Length) atts.getAttribute(CSS.Attribute.TOP); |
| if (top != null) |
| top.setFontBases(emBase, exBase); |
| Length bottom = (Length) atts.getAttribute(CSS.Attribute.BOTTOM); |
| if (bottom != null) |
| bottom.setFontBases(emBase, exBase); |
| if (left != null || right != null || top != null || bottom != null) |
| { |
| PositionInfo pos = new PositionInfo(type, left, right, top, |
| bottom); |
| positionInfo.put(view, pos); |
| } |
| } |
| } |
| } |
| } |