/* * Copyright (c) 1997, 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.html; import java.util.Enumeration;import java.awt.*;import javax.swing.SizeRequirements;import javax.swing.border.*;import javax.swing.event.DocumentEvent;import javax.swing.text.*; /** * A view implementation to display a block (as a box) * with CSS specifications. * * @author  Timothy Prinzing */public class BlockView extends BoxView  {     /**     * 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);    }     /**     * Establishes the parent view for this view.  This is     * guaranteed to be called before any other methods if the     * parent view is functioning properly.     * <p>     * This is implemented     * to forward to the superclass as well as call the     * {@link #setPropertiesFromAttributes()}     * method to set the paragraph properties from the css     * attributes.  The call is made at this time to ensure     * the ability to resolve upward through the parents     * view attributes.     *     * @param parent the new parent, or null if the view is     *  being removed from a parent it was previously added     *  to     */    public void setParent(View parent) {        super.setParent(parent);        if (parent != null) {            setPropertiesFromAttributes();        }    }     /**     * Calculate the requirements of the block along the major     * axis (i.e. the axis along with it tiles).  This is implemented     * to provide the superclass behavior and then adjust it if the     * CSS width or height attribute is specified and applicable to     * the axis.     */    protected SizeRequirements calculateMajorAxisRequirements(int axis, SizeRequirements r) {        if (r == null) {            r = new SizeRequirements();        }        if (! spanSetFromAttributes(axis, r, cssWidth, cssHeight)) {            r = super.calculateMajorAxisRequirements(axis, r);        }        else {            // Offset by the margins so that pref/min/max return the            // right value.            SizeRequirements parentR = 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, parentR);        }        return r;    }     /**     * Calculate the requirements of the block along the minor     * axis (i.e. the axis orthoginal to the axis along with it tiles).     * This is implemented     * to provide the superclass behavior and then adjust it if the     * CSS width or height attribute is specified and applicable to     * the axis.     */    protected SizeRequirements calculateMinorAxisRequirements(int axis, SizeRequirements r) {        if (r == null) {            r = new SizeRequirements();        }         if (! spanSetFromAttributes(axis, r, cssWidth, cssHeight)) {             /*             * The requirements were not directly specified by attributes, so             * compute the aggregate of the requirements of the children.  The             * children that have a percentage value specified will be treated             * as completely stretchable since that child is not limited in any             * way.             *//*            int min = 0;            long pref = 0;            int max = 0;            int n = getViewCount();            for (int i = 0; i < n; i++) {                View v = getView(i);                min = Math.max((int) v.getMinimumSpan(axis), min);                pref = Math.max((int) v.getPreferredSpan(axis), pref);                if (                max = Math.max((int) v.getMaximumSpan(axis), max);             }            r.preferred = (int) pref;            r.minimum = min;            r.maximum = max;            */            r = super.calculateMinorAxisRequirements(axis, r);        }        else {            // Offset by the margins so that pref/min/max return the            // right value.            SizeRequirements parentR = 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, parentR);        }         /*         * Set the alignment based upon the CSS properties if it is         * specified.  For X_AXIS this would be text-align, for         * Y_AXIS this would be vertical-align.         */        if (axis == X_AXIS) {            Object o = getAttributes().getAttribute(CSS.Attribute.TEXT_ALIGN);            if (o != null) {                String align = o.toString();                if (align.equals("center")) {                    r.alignment = 0.5f;                } else if (align.equals("right")) {                    r.alignment = 1.0f;                } else {                    r.alignment = 0.0f;                }            }        }        // Y_AXIS TBD        return r;    }     boolean isPercentage(int axis, AttributeSet a) {        if (axis == X_AXIS) {            if (cssWidth != null) {                return cssWidth.isPercentage();            }        } else {            if (cssHeight != null) {                return cssHeight.isPercentage();            }        }        return false;    }     /**     * Adjust the given requirements to the CSS width or height if     * it is specified along the applicable axis.  Return true if the     * size is exactly specified, false if the span is not specified     * in an attribute or the size specified is a percentage.     */    static boolean spanSetFromAttributes(int axis, SizeRequirements r,                                         CSS.LengthValue cssWidth,                                         CSS.LengthValue cssHeight) {        if (axis == X_AXIS) {            if ((cssWidth != null) && (! cssWidth.isPercentage())) {                r.minimum = r.preferred = r.maximum = (int) cssWidth.getValue();                return true;            }        } else {            if ((cssHeight != null) && (! cssHeight.isPercentage())) {                r.minimum = r.preferred = r.maximum = (int) cssHeight.getValue();                return true;            }        }        return false;    }     /**     * Performs layout for the minor axis of the box (i.e. the     * axis orthoginal to the axis that it represents). The results     * of the layout (the offset and span for each children) are     * placed in the given arrays which represent the allocations to     * the children along the minor axis.     *     * @param targetSpan the total span given to the view, which     *  whould be used to layout the childre.     * @param axis the axis being layed out     * @param offsets the offsets from the origin of the view for     *  each of the child views; this is a return value and is     *  filled in by the implementation of this method     * @param spans the span of each child view; this is a return     *  value and is filled in by the implementation of this method     */    protected void layoutMinorAxis(int targetSpan, int axis, int[] offsets, int[] spans) {        int n = getViewCount();        Object key = (axis == X_AXIS) ? CSS.Attribute.WIDTH : CSS.Attribute.HEIGHT;        for (int i = 0; i < n; i++) {            View v = getView(i);            int min = (int) v.getMinimumSpan(axis);            int max;             // check for percentage span            AttributeSet a = v.getAttributes();            CSS.LengthValue lv = (CSS.LengthValue) a.getAttribute(key);            if ((lv != null) && lv.isPercentage()) {                // bound the span to the percentage specified                min = Math.max((int) lv.getValue(targetSpan), min);                max = min;            } else {                max = (int)v.getMaximumSpan(axis);            }             // assign the offset and span for the child            if (max < targetSpan) {                // can't make the child this wide, align it                float align = v.getAlignment(axis);                offsets[i] = (int) ((targetSpan - max) * align);                spans[i] = max;            } else {                // make it the target width, or as small as it can get.                offsets[i] = 0;                spans[i] = Math.max(min, targetSpan);            }        }    }      /**     * Renders using the given rendering surface and area on that     * surface.  This is implemented to delegate to the css box     * painter to paint the border and background prior to the     * interior.     *     * @param g the rendering surface to use     * @param allocation the allocated region to render into     * @see View#paint     */    public void paint(Graphics g, Shape allocation) {        Rectangle a = (Rectangle) allocation;        painter.paint(g, a.x, a.y, a.width, a.height, this);        super.paint(g, a);    }     /**     * Fetches the attributes to use when rendering.  This is     * implemented to multiplex the attributes specified in the     * model with a StyleSheet.     */    public AttributeSet getAttributes() {        if (attr == null) {            StyleSheet sheet = getStyleSheet();            attr = sheet.getViewAttributes(this);        }        return attr;    }     /**     * Gets the resize weight.     *     * @param axis may be either X_AXIS or Y_AXIS     * @return the weight     * @exception IllegalArgumentException for an invalid axis     */    public int getResizeWeight(int axis) {        switch (axis) {        case View.X_AXIS:            return 1;        case View.Y_AXIS:            return 0;        default:            throw new IllegalArgumentException("Invalid axis: " + axis);        }    }     /**     * Gets the alignment.     *     * @param axis may be either X_AXIS or Y_AXIS     * @return the alignment     */    public float getAlignment(int axis) {        switch (axis) {        case View.X_AXIS:            return 0;        case View.Y_AXIS:            if (getViewCount() == 0) {                return 0;            }            float span = getPreferredSpan(View.Y_AXIS);            View v = getView(0);            float above = v.getPreferredSpan(View.Y_AXIS);            float a = (((int)span) != 0) ? (above * v.getAlignment(View.Y_AXIS)) / span: 0;            return a;        default:            throw new IllegalArgumentException("Invalid axis: " + axis);        }    }     public void changedUpdate(DocumentEvent changes, Shape a, ViewFactory f) {        super.changedUpdate(changes, a, f);        int pos = changes.getOffset();        if (pos <= getStartOffset() && (pos + changes.getLength()) >=            getEndOffset()) {            setPropertiesFromAttributes();        }    }     /**     * Determines the preferred span for this view along an     * axis.     *     * @param axis may be either <code>View.X_AXIS</code>     *           or <code>View.Y_AXIS</code>     * @return   the span the view would like to be rendered into >= 0;     *           typically the view is told to render into the span     *           that is returned, although there is no guarantee;     *           the parent may choose to resize or break the view     * @exception IllegalArgumentException for an invalid axis type     */    public float getPreferredSpan(int axis) {        return super.getPreferredSpan(axis);    }     /**     * Determines the minimum span for this view along an     * axis.     *     * @param axis may be either <code>View.X_AXIS</code>     *           or <code>View.Y_AXIS</code>     * @return  the span the view would like to be rendered into >= 0;     *           typically the view is told to render into the span     *           that is returned, although there is no guarantee;     *           the parent may choose to resize or break the view     * @exception IllegalArgumentException for an invalid axis type     */    public float getMinimumSpan(int axis) {        return super.getMinimumSpan(axis);    }     /**     * Determines the maximum span for this view along an     * axis.     *     * @param axis may be either <code>View.X_AXIS</code>     *           or <code>View.Y_AXIS</code>     * @return   the span the view would like to be rendered into >= 0;     *           typically the view is told to render into the span     *           that is returned, although there is no guarantee;     *           the parent may choose to resize or break the view     * @exception IllegalArgumentException for an invalid axis type     */    public float getMaximumSpan(int axis) {        return super.getMaximumSpan(axis);    }     /**     * Update any cached values that come from attributes.     */    protected void setPropertiesFromAttributes() {         // update attributes        StyleSheet sheet = getStyleSheet();        attr = sheet.getViewAttributes(this);         // Reset the painter        painter = sheet.getBoxPainter(attr);        if (attr != null) {            setInsets((short) painter.getInset(TOP, this),                      (short) painter.getInset(LEFT, this),                      (short) painter.getInset(BOTTOM, this),                      (short) painter.getInset(RIGHT, this));        }         // Get the width/height        cssWidth = (CSS.LengthValue) attr.getAttribute(CSS.Attribute.WIDTH);        cssHeight = (CSS.LengthValue) attr.getAttribute(CSS.Attribute.HEIGHT);    }     protected StyleSheet getStyleSheet() {        HTMLDocument doc = (HTMLDocument) getDocument();        return doc.getStyleSheet();    }     /**     * Constrains <code>want</code> to fit in the minimum size specified     * by <code>min</code>.     */    private void constrainSize(int axis, SizeRequirements want,                               SizeRequirements min) {        if (min.minimum > want.minimum) {            want.minimum = want.preferred = min.minimum;            want.maximum = Math.max(want.maximum, min.maximum);        }    }     private AttributeSet attr;    private StyleSheet.BoxPainter painter;     private CSS.LengthValue cssWidth;    private CSS.LengthValue cssHeight; }