/**         * Adds a {@code Group} to this {@code ParallelGroup} with the         * specified alignment. If the child is smaller than the         * {@code Group} it is aligned based on the specified         * alignment.         *         * @param alignment the alignment         * @param group the {@code Group} to add         * @return this {@code ParallelGroup}         * @throws IllegalArgumentException if {@code alignment} is         *         {@code null}         */        public ParallelGroup addGroup(Alignment alignment, Group group) {            checkChildAlignment(alignment);            group.setAlignment(alignment);            return (ParallelGroup)addSpring(group);        }         /**         * Adds a {@code Component} to this {@code ParallelGroup} with         * the specified alignment.         *         * @param alignment the alignment         * @param component the {@code Component} to add         * @return this {@code Group}         * @throws IllegalArgumentException if {@code alignment} is         *         {@code null}         */        public ParallelGroup addComponent(Component component,                Alignment alignment) {            return addComponent(component, alignment, DEFAULT_SIZE, DEFAULT_SIZE,                    DEFAULT_SIZE);        }         /**         * Adds a {@code Component} to this {@code ParallelGroup} with the         * specified alignment and size.         *         * @param alignment the alignment         * @param component the {@code Component} to add         * @param min the minimum size         * @param pref the preferred size         * @param max the maximum size         * @throws IllegalArgumentException if {@code alignment} is         *         {@code null}         * @return this {@code Group}         */        public ParallelGroup addComponent(Component component,                Alignment alignment, int min, int pref, int max) {            checkChildAlignment(alignment);            ComponentSpring spring = new ComponentSpring(component,                    min, pref, max);            spring.setAlignment(alignment);            return (ParallelGroup)addSpring(spring);        }         boolean isResizable() {            return resizable;        }         int operator(int a, int b) {            return Math.max(a, b);        }         int calculateMinimumSize(int axis) {            if (!isResizable()) {                return getPreferredSize(axis);            }            return super.calculateMinimumSize(axis);        }         int calculateMaximumSize(int axis) {            if (!isResizable()) {                return getPreferredSize(axis);            }            return super.calculateMaximumSize(axis);        }         void setValidSize(int axis, int origin, int size) {            for (Spring spring : springs) {                setChildSize(spring, axis, origin, size);            }        }         void setChildSize(Spring spring, int axis, int origin, int size) {            Alignment alignment = spring.getAlignment();            int springSize = Math.min(                    Math.max(spring.getMinimumSize(axis), size),                    spring.getMaximumSize(axis));            if (alignment == null) {                alignment = childAlignment;            }            switch (alignment) {                case TRAILING:                    spring.setSize(axis, origin + size - springSize,                            springSize);                    break;                case CENTER:                    spring.setSize(axis, origin +                            (size - springSize) / 2,springSize);                    break;                default: // LEADING, or BASELINE                    spring.setSize(axis, origin, springSize);                    break;            }        }         @Override        void insertAutopadding(int axis,                List<AutoPreferredGapSpring> leadingPadding,                List<AutoPreferredGapSpring> trailingPadding,                List<ComponentSpring> leading, List<ComponentSpring> trailing,                boolean insert) {            for (Spring spring : springs) {                if (spring instanceof ComponentSpring) {                    if (((ComponentSpring)spring).isVisible()) {                        for (AutoPreferredGapSpring gapSpring :                                 leadingPadding) {                            gapSpring.addTarget((ComponentSpring)spring, axis);                        }                        trailing.add((ComponentSpring)spring);                    }                } else if (spring instanceof Group) {                    ((Group)spring).insertAutopadding(axis, leadingPadding,                            trailingPadding, leading, trailing, insert);                } else if (spring instanceof AutoPreferredGapSpring) {                    ((AutoPreferredGapSpring)spring).setSources(leading);                    trailingPadding.add((AutoPreferredGapSpring)spring);                }            }        }         private void checkChildAlignment(Alignment alignment) {            checkChildAlignment(alignment, (this instanceof BaselineGroup));        }         private void checkChildAlignment(Alignment alignment,                boolean allowsBaseline) {            if (alignment == null) {                throw new IllegalArgumentException("Alignment must be non-null");            }            if (!allowsBaseline && alignment == Alignment.BASELINE) {                throw new IllegalArgumentException("Alignment must be one of:" +                        "LEADING, TRAILING or CENTER");            }        }    }      /**     * An extension of {@code ParallelGroup} that aligns its     * constituent {@code Spring}s along the baseline.     */    private class BaselineGroup extends ParallelGroup {        // Whether or not all child springs have a baseline        private boolean allSpringsHaveBaseline;         // max(spring.getBaseline()) of all springs aligned along the baseline        // that have a baseline        private int prefAscent;         // max(spring.getPreferredSize().height - spring.getBaseline()) of all        // springs aligned along the baseline that have a baseline        private int prefDescent;         // Whether baselineAnchoredToTop was explicitly set        private boolean baselineAnchorSet;         // Whether the baseline is anchored to the top or the bottom.        // If anchored to the top the baseline is always at prefAscent,        // otherwise the baseline is at (height - prefDescent)        private boolean baselineAnchoredToTop;         // Whether or not the baseline has been calculated.        private boolean calcedBaseline;         BaselineGroup(boolean resizable) {            super(Alignment.LEADING, resizable);            prefAscent = prefDescent = -1;            calcedBaseline = false;        }         BaselineGroup(boolean resizable, boolean baselineAnchoredToTop) {            this(resizable);            this.baselineAnchoredToTop = baselineAnchoredToTop;            baselineAnchorSet = true;        }         void unset() {            super.unset();            prefAscent = prefDescent = -1;            calcedBaseline = false;        }         void setValidSize(int axis, int origin, int size) {            checkAxis(axis);            if (prefAscent == -1) {                super.setValidSize(axis, origin, size);            } else {                // do baseline layout                baselineLayout(origin, size);            }        }         int calculateSize(int axis, int type) {            checkAxis(axis);            if (!calcedBaseline) {                calculateBaselineAndResizeBehavior();            }            if (type == MIN_SIZE) {                return calculateMinSize();            }            if (type == MAX_SIZE) {                return calculateMaxSize();            }            if (allSpringsHaveBaseline) {                return prefAscent + prefDescent;            }            return Math.max(prefAscent + prefDescent,                    super.calculateSize(axis, type));        }         private void calculateBaselineAndResizeBehavior() {            // calculate baseline            prefAscent = 0;            prefDescent = 0;            int baselineSpringCount = 0;            BaselineResizeBehavior resizeBehavior = null;            for (Spring spring : springs) {                if (spring.getAlignment() == null ||                        spring.getAlignment() == Alignment.BASELINE) {                    int baseline = spring.getBaseline();                    if (baseline >= 0) {                        if (spring.isResizable(VERTICAL)) {                            BaselineResizeBehavior brb = spring.                                    getBaselineResizeBehavior();                            if (resizeBehavior == null) {                                resizeBehavior = brb;                            } else if (brb != resizeBehavior) {                                resizeBehavior = BaselineResizeBehavior.                                        CONSTANT_ASCENT;                            }                        }                        prefAscent = Math.max(prefAscent, baseline);                        prefDescent = Math.max(prefDescent, spring.                                getPreferredSize(VERTICAL) - baseline);                        baselineSpringCount++;                    }                }            }            if (!baselineAnchorSet) {                if (resizeBehavior == BaselineResizeBehavior.CONSTANT_DESCENT){                    this.baselineAnchoredToTop = false;                } else {                    this.baselineAnchoredToTop = true;                }            }            allSpringsHaveBaseline = (baselineSpringCount == springs.size());            calcedBaseline = true;        }         private int calculateMaxSize() {            int maxAscent = prefAscent;            int maxDescent = prefDescent;            int nonBaselineMax = 0;            for (Spring spring : springs) {                int baseline;                int springMax = spring.getMaximumSize(VERTICAL);                if ((spring.getAlignment() == null ||                        spring.getAlignment() == Alignment.BASELINE) &&                        (baseline = spring.getBaseline()) >= 0) {                    int springPref = spring.getPreferredSize(VERTICAL);                    if (springPref != springMax) {                        switch (spring.getBaselineResizeBehavior()) {                            case CONSTANT_ASCENT:                                if (baselineAnchoredToTop) {                                    maxDescent = Math.max(maxDescent,                                            springMax - baseline);                                }                                break;                            case CONSTANT_DESCENT:                                if (!baselineAnchoredToTop) {                                    maxAscent = Math.max(maxAscent,                                            springMax - springPref + baseline);                                }                                break;                            default: // CENTER_OFFSET and OTHER, not resizable                                break;                        }                    }                } else {                    // Not aligned along the baseline, or no baseline.                    nonBaselineMax = Math.max(nonBaselineMax, springMax);                }            }            return Math.max(nonBaselineMax, maxAscent + maxDescent);        }         private int calculateMinSize() {            int minAscent = 0;            int minDescent = 0;            int nonBaselineMin = 0;            if (baselineAnchoredToTop) {                minAscent = prefAscent;            } else {                minDescent = prefDescent;            }            for (Spring spring : springs) {                int springMin = spring.getMinimumSize(VERTICAL);                int baseline;                if ((spring.getAlignment() == null ||                        spring.getAlignment() == Alignment.BASELINE) &&                        (baseline = spring.getBaseline()) >= 0) {                    int springPref = spring.getPreferredSize(VERTICAL);                    BaselineResizeBehavior brb = spring.                            getBaselineResizeBehavior();                    switch (brb) {                        case CONSTANT_ASCENT:                            if (baselineAnchoredToTop) {                                minDescent = Math.max(springMin - baseline,                                        minDescent);                            } else {                                minAscent = Math.max(baseline, minAscent);                            }                            break;                        case CONSTANT_DESCENT:                            if (!baselineAnchoredToTop) {                                minAscent = Math.max(                                        baseline - (springPref - springMin),                                        minAscent);                            } else {                                minDescent = Math.max(springPref - baseline,                                        minDescent);                            }                            break;                        default:                            // CENTER_OFFSET and OTHER are !resizable, use                            // the preferred size.                            minAscent = Math.max(baseline, minAscent);                            minDescent = Math.max(springPref - baseline,                                    minDescent);                            break;                    }                } else {                    // Not aligned along the baseline, or no baseline.                    nonBaselineMin = Math.max(nonBaselineMin, springMin);                }            }            return Math.max(nonBaselineMin, minAscent + minDescent);        }         /**         * Lays out springs that have a baseline along the baseline.  All         * others are centered.         */        private void baselineLayout(int origin, int size) {            int ascent;            int descent;            if (baselineAnchoredToTop) {                ascent = prefAscent;                descent = size - ascent;            } else {                ascent = size - prefDescent;                descent = prefDescent;            }            for (Spring spring : springs) {                Alignment alignment = spring.getAlignment();                if (alignment == null || alignment == Alignment.BASELINE) {                    int baseline = spring.getBaseline();                    if (baseline >= 0) {                        int springMax = spring.getMaximumSize(VERTICAL);                        int springPref = spring.getPreferredSize(VERTICAL);                        int height = springPref;                        int y;                        switch(spring.getBaselineResizeBehavior()) {                            case CONSTANT_ASCENT:                                y = origin + ascent - baseline;                                height = Math.min(descent, springMax -                                        baseline) + baseline;                                break;                            case CONSTANT_DESCENT:                                height = Math.min(ascent, springMax -                                        springPref + baseline) +                                        (springPref - baseline);                                y = origin + ascent +                                        (springPref - baseline) - height;                                break;                            default: // CENTER_OFFSET & OTHER, not resizable                                y = origin + ascent - baseline;                                break;                        }                        spring.setSize(VERTICAL, y, height);                    } else {                        setChildSize(spring, VERTICAL, origin, size);                    }                } else {                    setChildSize(spring, VERTICAL, origin, size);                }            }        }         int getBaseline() {            if (springs.size() > 1) {                // Force the baseline to be calculated                getPreferredSize(VERTICAL);                return prefAscent;            } else if (springs.size() == 1) {                return springs.get(0).getBaseline();            }            return -1;        }         BaselineResizeBehavior getBaselineResizeBehavior() {            if (springs.size() == 1) {                return springs.get(0).getBaselineResizeBehavior();            }            if (baselineAnchoredToTop) {                return BaselineResizeBehavior.CONSTANT_ASCENT;            }            return BaselineResizeBehavior.CONSTANT_DESCENT;        }         // If the axis is VERTICAL, throws an IllegalStateException        private void checkAxis(int axis) {            if (axis == HORIZONTAL) {                throw new IllegalStateException(                        "Baseline must be used along vertical axis");            }        }    }      private final class ComponentSpring extends Spring {        private Component component;        private int origin;         // min/pref/max are either a value >= 0 or one of        // DEFAULT_SIZE or PREFERRED_SIZE        private final int min;        private final int pref;        private final int max;         // Baseline for the component, computed as necessary.        private int baseline = -1;         // Whether or not the size has been requested yet.        private boolean installed;         private ComponentSpring(Component component, int min, int pref,                int max) {            this.component = component;            if (component == null) {                throw new IllegalArgumentException(                        "Component must be non-null");            }             checkSize(min, pref, max, true);             this.min = min;            this.max = max;            this.pref = pref;             // getComponentInfo makes sure component is a child of the            // Container GroupLayout is the LayoutManager for.            getComponentInfo(component);        }         int calculateMinimumSize(int axis) {            if (isLinked(axis)) {                return getLinkSize(axis, MIN_SIZE);            }            return calculateNonlinkedMinimumSize(axis);        }         int calculatePreferredSize(int axis) {            if (isLinked(axis)) {                return getLinkSize(axis, PREF_SIZE);            }            int min = getMinimumSize(axis);            int pref = calculateNonlinkedPreferredSize(axis);            int max = getMaximumSize(axis);            return Math.min(max, Math.max(min, pref));        }         int calculateMaximumSize(int axis) {            if (isLinked(axis)) {                return getLinkSize(axis, MAX_SIZE);            }            return Math.max(getMinimumSize(axis),                    calculateNonlinkedMaximumSize(axis));        }         boolean isVisible() {            return getComponentInfo(getComponent()).isVisible();        }         int calculateNonlinkedMinimumSize(int axis) {            if (!isVisible()) {                return 0;            }

Lines 2501–3000 of 3745. Previous lines Load more