return padding;        }         String getMatchDescription() {            if (targets != null) {                return "leading: " + targets.toString();            }            if (sources != null) {                return "trailing: " + sources.toString();            }            return "--";        }    }      // LinkInfo contains the set of ComponentInfosthat are linked along a    // particular axis.    private static class LinkInfo {        private final int axis;        private final List<ComponentInfo> linked;        private int size;         LinkInfo(int axis) {            linked = new ArrayList<ComponentInfo>();            size = UNSET;            this.axis = axis;        }         public void add(ComponentInfo child) {            LinkInfo childMaster = child.getLinkInfo(axis, false);            if (childMaster == null) {                linked.add(child);                child.setLinkInfo(axis, this);            } else if (childMaster != this) {                linked.addAll(childMaster.linked);                for (ComponentInfo childInfo : childMaster.linked) {                    childInfo.setLinkInfo(axis, this);                }            }            clearCachedSize();        }         public void remove(ComponentInfo info) {            linked.remove(info);            info.setLinkInfo(axis, null);            if (linked.size() == 1) {                linked.get(0).setLinkInfo(axis, null);            }            clearCachedSize();        }         public void clearCachedSize() {            size = UNSET;        }         public int getSize(int axis) {            if (size == UNSET) {                size = calculateLinkedSize(axis);            }            return size;        }         private int calculateLinkedSize(int axis) {            int size = 0;            for (ComponentInfo info : linked) {                ComponentSpring spring;                if (axis == HORIZONTAL) {                    spring = info.horizontalSpring;                } else {                    assert (axis == VERTICAL);                    spring = info.verticalSpring;                }                size = Math.max(size,                        spring.calculateNonlinkedPreferredSize(axis));            }            return size;        }    }     /**     * Tracks the horizontal/vertical Springs for a Component.     * This class is also used to handle Springs that have their sizes     * linked.     */    private class ComponentInfo {        // Component being layed out        private Component component;         ComponentSpring horizontalSpring;        ComponentSpring verticalSpring;         // If the component's size is linked to other components, the        // horizontalMaster and/or verticalMaster reference the group of        // linked components.        private LinkInfo horizontalMaster;        private LinkInfo verticalMaster;         private boolean visible;        private Boolean honorsVisibility;         ComponentInfo(Component component) {            this.component = component;            updateVisibility();        }         public void dispose() {            // Remove horizontal/vertical springs            removeSpring(horizontalSpring);            horizontalSpring = null;            removeSpring(verticalSpring);            verticalSpring = null;            // Clean up links            if (horizontalMaster != null) {                horizontalMaster.remove(this);            }            if (verticalMaster != null) {                verticalMaster.remove(this);            }        }         void setHonorsVisibility(Boolean honorsVisibility) {            this.honorsVisibility = honorsVisibility;        }         private void removeSpring(Spring spring) {            if (spring != null) {                ((Group)spring.getParent()).springs.remove(spring);            }        }         public boolean isVisible() {            return visible;        }         /**         * Updates the cached visibility.         *         * @return true if the visibility changed         */        boolean updateVisibility() {            boolean honorsVisibility;            if (this.honorsVisibility == null) {                honorsVisibility = GroupLayout.this.getHonorsVisibility();            } else {                honorsVisibility = this.honorsVisibility;            }            boolean newVisible = (honorsVisibility) ?                component.isVisible() : true;            if (visible != newVisible) {                visible = newVisible;                return true;            }            return false;        }         public void setBounds(Insets insets, int parentWidth, boolean ltr) {            int x = horizontalSpring.getOrigin();            int w = horizontalSpring.getSize();            int y = verticalSpring.getOrigin();            int h = verticalSpring.getSize();             if (!ltr) {                x = parentWidth - x - w;            }            component.setBounds(x + insets.left, y + insets.top, w, h);        }         public void setComponent(Component component) {            this.component = component;            if (horizontalSpring != null) {                horizontalSpring.setComponent(component);            }            if (verticalSpring != null) {                verticalSpring.setComponent(component);            }        }         public Component getComponent() {            return component;        }         /**         * Returns true if this component has its size linked to         * other components.         */        public boolean isLinked(int axis) {            if (axis == HORIZONTAL) {                return horizontalMaster != null;            }            assert (axis == VERTICAL);            return (verticalMaster != null);        }         private void setLinkInfo(int axis, LinkInfo linkInfo) {            if (axis == HORIZONTAL) {                horizontalMaster = linkInfo;            } else {                assert (axis == VERTICAL);                verticalMaster = linkInfo;            }        }         public LinkInfo getLinkInfo(int axis) {            return getLinkInfo(axis, true);        }         private LinkInfo getLinkInfo(int axis, boolean create) {            if (axis == HORIZONTAL) {                if (horizontalMaster == null && create) {                    // horizontalMaster field is directly set by adding                    // us to the LinkInfo.                    new LinkInfo(HORIZONTAL).add(this);                }                return horizontalMaster;            } else {                assert (axis == VERTICAL);                if (verticalMaster == null && create) {                    // verticalMaster field is directly set by adding                    // us to the LinkInfo.                    new LinkInfo(VERTICAL).add(this);                }                return verticalMaster;            }        }         public void clearCachedSize() {            if (horizontalMaster != null) {                horizontalMaster.clearCachedSize();            }            if (verticalMaster != null) {                verticalMaster.clearCachedSize();            }        }         int getLinkSize(int axis, int type) {            if (axis == HORIZONTAL) {                return horizontalMaster.getSize(axis);            } else {                assert (axis == VERTICAL);                return verticalMaster.getSize(axis);            }        }     }}

Lines 3501–3745 of 3745. Previous lines