if (min >= 0) {                return min;            }            if (min == PREFERRED_SIZE) {                return calculateNonlinkedPreferredSize(axis);            }            assert (min == DEFAULT_SIZE);            return getSizeAlongAxis(axis, component.getMinimumSize());        }         int calculateNonlinkedPreferredSize(int axis) {            if (!isVisible()) {                return 0;            }            if (pref >= 0) {                return pref;            }            assert (pref == DEFAULT_SIZE || pref == PREFERRED_SIZE);            return getSizeAlongAxis(axis, component.getPreferredSize());        }         int calculateNonlinkedMaximumSize(int axis) {            if (!isVisible()) {                return 0;            }            if (max >= 0) {                return max;            }            if (max == PREFERRED_SIZE) {                return calculateNonlinkedPreferredSize(axis);            }            assert (max == DEFAULT_SIZE);            return getSizeAlongAxis(axis, component.getMaximumSize());        }         private int getSizeAlongAxis(int axis, Dimension size) {            return (axis == HORIZONTAL) ? size.width : size.height;        }         private int getLinkSize(int axis, int type) {            if (!isVisible()) {                return 0;            }            ComponentInfo ci = getComponentInfo(component);            return ci.getLinkSize(axis, type);        }         void setSize(int axis, int origin, int size) {            super.setSize(axis, origin, size);            this.origin = origin;            if (size == UNSET) {                baseline = -1;            }        }         int getOrigin() {            return origin;        }         void setComponent(Component component) {            this.component = component;        }         Component getComponent() {            return component;        }         int getBaseline() {            if (baseline == -1) {                Spring horizontalSpring = getComponentInfo(component).                        horizontalSpring;                int width = horizontalSpring.getPreferredSize(HORIZONTAL);                int height = getPreferredSize(VERTICAL);                if (width > 0 && height > 0) {                    baseline = component.getBaseline(width, height);                }            }            return baseline;        }         BaselineResizeBehavior getBaselineResizeBehavior() {            return getComponent().getBaselineResizeBehavior();        }         private boolean isLinked(int axis) {            return getComponentInfo(component).isLinked(axis);        }         void installIfNecessary(int axis) {            if (!installed) {                installed = true;                if (axis == HORIZONTAL) {                    getComponentInfo(component).horizontalSpring = this;                } else {                    getComponentInfo(component).verticalSpring = this;                }            }        }         @Override        boolean willHaveZeroSize(boolean treatAutopaddingAsZeroSized) {            return !isVisible();        }    }      /**     * Spring representing the preferred distance between two components.     */    private class PreferredGapSpring extends Spring {        private final JComponent source;        private final JComponent target;        private final ComponentPlacement type;        private final int pref;        private final int max;         PreferredGapSpring(JComponent source, JComponent target,                ComponentPlacement type, int pref, int max) {            this.source = source;            this.target = target;            this.type = type;            this.pref = pref;            this.max = max;        }         int calculateMinimumSize(int axis) {            return getPadding(axis);        }         int calculatePreferredSize(int axis) {            if (pref == DEFAULT_SIZE || pref == PREFERRED_SIZE) {                return getMinimumSize(axis);            }            int min = getMinimumSize(axis);            int max = getMaximumSize(axis);            return Math.min(max, Math.max(min, pref));        }         int calculateMaximumSize(int axis) {            if (max == PREFERRED_SIZE || max == DEFAULT_SIZE) {                return getPadding(axis);            }            return Math.max(getMinimumSize(axis), max);        }         private int getPadding(int axis) {            int position;            if (axis == HORIZONTAL) {                position = SwingConstants.EAST;            } else {                position = SwingConstants.SOUTH;            }            return getLayoutStyle0().getPreferredGap(source,                    target, type, position, host);        }         @Override        boolean willHaveZeroSize(boolean treatAutopaddingAsZeroSized) {            return false;        }    }      /**     * Spring represented a certain amount of space.     */    private class GapSpring extends Spring {        private final int min;        private final int pref;        private final int max;         GapSpring(int min, int pref, int max) {            checkSize(min, pref, max, false);            this.min = min;            this.pref = pref;            this.max = max;        }         int calculateMinimumSize(int axis) {            if (min == PREFERRED_SIZE) {                return getPreferredSize(axis);            }            return min;        }         int calculatePreferredSize(int axis) {            return pref;        }         int calculateMaximumSize(int axis) {            if (max == PREFERRED_SIZE) {                return getPreferredSize(axis);            }            return max;        }         @Override        boolean willHaveZeroSize(boolean treatAutopaddingAsZeroSized) {            return false;        }    }      /**     * Spring reprensenting the distance between any number of sources and     * targets.  The targets and sources are computed during layout.  An     * instance of this can either be dynamically created when     * autocreatePadding is true, or explicitly created by the developer.     */    private class AutoPreferredGapSpring extends Spring {        List<ComponentSpring> sources;        ComponentSpring source;        private List<AutoPreferredGapMatch> matches;        int size;        int lastSize;        private final int pref;        private final int max;        // Type of gap        private ComponentPlacement type;        private boolean userCreated;         private AutoPreferredGapSpring() {            this.pref = PREFERRED_SIZE;            this.max = PREFERRED_SIZE;            this.type = ComponentPlacement.RELATED;        }         AutoPreferredGapSpring(int pref, int max) {            this.pref = pref;            this.max = max;        }         AutoPreferredGapSpring(ComponentPlacement type, int pref, int max) {            this.type = type;            this.pref = pref;            this.max = max;            this.userCreated = true;        }         public void setSource(ComponentSpring source) {            this.source = source;        }         public void setSources(List<ComponentSpring> sources) {            this.sources = new ArrayList<ComponentSpring>(sources);        }         public void setUserCreated(boolean userCreated) {            this.userCreated = userCreated;        }         public boolean getUserCreated() {            return userCreated;        }         void unset() {            lastSize = getSize();            super.unset();            size = 0;        }         public void reset() {            size = 0;            sources = null;            source = null;            matches = null;        }         public void calculatePadding(int axis) {            size = UNSET;            int maxPadding = UNSET;            if (matches != null) {                LayoutStyle p = getLayoutStyle0();                int position;                if (axis == HORIZONTAL) {                    if (isLeftToRight()) {                        position = SwingConstants.EAST;                    } else {                        position = SwingConstants.WEST;                    }                } else {                    position = SwingConstants.SOUTH;                }                for (int i = matches.size() - 1; i >= 0; i--) {                    AutoPreferredGapMatch match = matches.get(i);                    maxPadding = Math.max(maxPadding,                            calculatePadding(p, position, match.source,                            match.target));                }            }            if (size == UNSET) {                size = 0;            }            if (maxPadding == UNSET) {                maxPadding = 0;            }            if (lastSize != UNSET) {                size += Math.min(maxPadding, lastSize);            }        }         private int calculatePadding(LayoutStyle p, int position,                ComponentSpring source,                ComponentSpring target) {            int delta = target.getOrigin() - (source.getOrigin() +                    source.getSize());            if (delta >= 0) {                int padding;                if ((source.getComponent() instanceof JComponent) &&                        (target.getComponent() instanceof JComponent)) {                    padding = p.getPreferredGap(                            (JComponent)source.getComponent(),                            (JComponent)target.getComponent(), type, position,                            host);                } else {                    padding = 10;                }                if (padding > delta) {                    size = Math.max(size, padding - delta);                }                return padding;            }            return 0;        }         public void addTarget(ComponentSpring spring, int axis) {            int oAxis = (axis == HORIZONTAL) ? VERTICAL : HORIZONTAL;            if (source != null) {                if (areParallelSiblings(source.getComponent(),                        spring.getComponent(), oAxis)) {                    addValidTarget(source, spring);                }            } else {                Component component = spring.getComponent();                for (int counter = sources.size() - 1; counter >= 0;                         counter--){                    ComponentSpring source = sources.get(counter);                    if (areParallelSiblings(source.getComponent(),                            component, oAxis)) {                        addValidTarget(source, spring);                    }                }            }        }         private void addValidTarget(ComponentSpring source,                ComponentSpring target) {            if (matches == null) {                matches = new ArrayList<AutoPreferredGapMatch>(1);            }            matches.add(new AutoPreferredGapMatch(source, target));        }         int calculateMinimumSize(int axis) {            return size;        }         int calculatePreferredSize(int axis) {            if (pref == PREFERRED_SIZE || pref == DEFAULT_SIZE) {                return size;            }            return Math.max(size, pref);        }         int calculateMaximumSize(int axis) {            if (max >= 0) {                return Math.max(getPreferredSize(axis), max);            }            return size;        }         String getMatchDescription() {            return (matches == null) ? "" : matches.toString();        }         public String toString() {            return super.toString() + getMatchDescription();        }         @Override        boolean willHaveZeroSize(boolean treatAutopaddingAsZeroSized) {            return treatAutopaddingAsZeroSized;        }    }      /**     * Represents two springs that should have autopadding inserted between     * them.     */    private final static class AutoPreferredGapMatch {        public final ComponentSpring source;        public final ComponentSpring target;         AutoPreferredGapMatch(ComponentSpring source, ComponentSpring target) {            this.source = source;            this.target = target;        }         private String toString(ComponentSpring spring) {            return spring.getComponent().getName();        }         public String toString() {            return "[" + toString(source) + "-" + toString(target) + "]";        }    }      /**     * An extension of AutopaddingSpring used for container level padding.     */    private class ContainerAutoPreferredGapSpring extends            AutoPreferredGapSpring {        private List<ComponentSpring> targets;         ContainerAutoPreferredGapSpring() {            super();            setUserCreated(true);        }         ContainerAutoPreferredGapSpring(int pref, int max) {            super(pref, max);            setUserCreated(true);        }         public void addTarget(ComponentSpring spring, int axis) {            if (targets == null) {                targets = new ArrayList<ComponentSpring>(1);            }            targets.add(spring);        }         public void calculatePadding(int axis) {            LayoutStyle p = getLayoutStyle0();            int maxPadding = 0;            int position;            size = 0;            if (targets != null) {                // Leading                if (axis == HORIZONTAL) {                    if (isLeftToRight()) {                        position = SwingConstants.WEST;                    } else {                        position = SwingConstants.EAST;                    }                } else {                    position = SwingConstants.SOUTH;                }                for (int i = targets.size() - 1; i >= 0; i--) {                    ComponentSpring targetSpring = targets.get(i);                    int padding = 10;                    if (targetSpring.getComponent() instanceof JComponent) {                        padding = p.getContainerGap(                                (JComponent)targetSpring.getComponent(),                                position, host);                        maxPadding = Math.max(padding, maxPadding);                        padding -= targetSpring.getOrigin();                    } else {                        maxPadding = Math.max(padding, maxPadding);                    }                    size = Math.max(size, padding);                }            } else {                // Trailing                if (axis == HORIZONTAL) {                    if (isLeftToRight()) {                        position = SwingConstants.EAST;                    } else {                        position = SwingConstants.WEST;                    }                } else {                    position = SwingConstants.SOUTH;                }                if (sources != null) {                    for (int i = sources.size() - 1; i >= 0; i--) {                        ComponentSpring sourceSpring = sources.get(i);                        maxPadding = Math.max(maxPadding,                                updateSize(p, sourceSpring, position));                    }                } else if (source != null) {                    maxPadding = updateSize(p, source, position);                }            }            if (lastSize != UNSET) {                size += Math.min(maxPadding, lastSize);            }        }         private int updateSize(LayoutStyle p, ComponentSpring sourceSpring,                int position) {            int padding = 10;            if (sourceSpring.getComponent() instanceof JComponent) {                padding = p.getContainerGap(                        (JComponent)sourceSpring.getComponent(), position,                        host);            }            int delta = Math.max(0, getParent().getSize() -                    sourceSpring.getSize() - sourceSpring.getOrigin());            size = Math.max(size, padding - delta);

Lines 3001–3500 of 3745. Previous lines Load more