BorderSplitPane.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 The Gridarta Developers.
 *
 * This program 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 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

package net.sf.gridarta.gui.utils.borderpanel;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.event.HierarchyEvent;
import java.awt.event.HierarchyListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.JSplitPane;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class BorderSplitPane extends Container {

    private static final long serialVersionUID = 1L;

    @NotNull
    private final Component component;

    @NotNull
    private final Location location;

    @NotNull
    private final Component[] optionalComponents = new Component[2];

    @NotNull
    private final JSplitPane splitPane;

    @NotNull
    private final JSplitPane splitPane2;

    private boolean showing;

    private int size = -1;

    private int size2;

    private boolean ignoreSizeChange;

    public BorderSplitPane(@NotNull final Component component, @NotNull final Location location, @NotNull final BorderSplitPaneListener borderSplitPaneListener, final int size2) {
        this.component = component;
        this.location = location;
        this.size2 = size2;
        splitPane = new JSplitPane(location.getSplitPaneOrientation(), true, null, null);
        splitPane.setOneTouchExpandable(false);
        splitPane.setResizeWeight(location.getSplitPaneResizeWeight());
        splitPane2 = new JSplitPane(location.getSplitPaneOppositeOrientation(), true, null, null);
        splitPane2.setOneTouchExpandable(false);
        splitPane2.setResizeWeight(0.5);
        setLayout(new BorderLayout());
        setOptionalComponent(null, false, 0, true);

        splitPane.addPropertyChangeListener(new PropertyChangeListener() {

            @Override
            public void propertyChange(final PropertyChangeEvent evt) {
                if (ignoreSizeChange) {
                    return;
                }
                if (optionalComponents[0] != null || optionalComponents[1] != null) {
                    //Property names are interned strings.
                    //noinspection StringEquality
                    if (evt.getPropertyName() == JSplitPane.DIVIDER_LOCATION_PROPERTY) {
                        final Object value = evt.getNewValue();
                        if (value != null && value instanceof Integer) {
                            final int newSize = (Integer) value;
                            final int splitPaneSize = getSplitPaneSize(newSize);
                            for (final Component optionalComponent : optionalComponents) {
                                if (optionalComponent != null) {
                                    borderSplitPaneListener.sizeChanged(optionalComponent, splitPaneSize);
                                }
                            }
                        }
                    }
                }
            }

        });

        splitPane2.addPropertyChangeListener(new PropertyChangeListener() {

            @Override
            public void propertyChange(final PropertyChangeEvent evt) {
                if (ignoreSizeChange) {
                    return;
                }
                if (optionalComponents[0] != null && optionalComponents[1] != null) {
                    //Property names are interned strings.
                    //noinspection StringEquality
                    if (evt.getPropertyName() == JSplitPane.DIVIDER_LOCATION_PROPERTY) {
                        final Object value = evt.getNewValue();
                        if (value != null && value instanceof Integer) {
                            final int newSize = (Integer) value;
                            BorderSplitPane.this.size2 = newSize;
                            borderSplitPaneListener.size2Changed(newSize);
                        }
                    }
                }
            }

        });

        final HierarchyListener hierarchyListener = new HierarchyListener() {

            @Override
            public void hierarchyChanged(final HierarchyEvent e) {
                if ((e.getChangeFlags() & (long) HierarchyEvent.SHOWING_CHANGED) != 0L && isShowing()) {
                    removeHierarchyListener(this);
                    assert !showing;
                    showing = true;
                    if (size != -1) {
                        setDividerSize(size);
                        size = -1;
                    }
                    setDividerSize2();
                }
            }

        };
        addHierarchyListener(hierarchyListener);
    }

    public void setOptionalComponent(@Nullable final Component optionalComponent, final boolean alternativeLocation, final int size) {
        setOptionalComponent(optionalComponent, alternativeLocation, size, false);
    }

    public final void setOptionalComponent(@Nullable final Component optionalComponent, final boolean alternativeLocation, final int size, final boolean force) {
        final int index = alternativeLocation ? 1 : 0;
        if (!force && optionalComponents[index] == optionalComponent) {
            return;
        }

        optionalComponents[index] = optionalComponent;

        final Component centerComponent;
        final boolean setSize2;
        if (optionalComponents[0] == null && optionalComponents[1] == null) {
            setSize2 = false;
            centerComponent = component;
        } else {
            centerComponent = splitPane;

            final Component tmp;
            if (optionalComponents[0] == null) {
                setSize2 = false;
                tmp = optionalComponents[1];
                assert tmp != null;
            } else if (optionalComponents[1] == null) {
                setSize2 = false;
                tmp = optionalComponents[0];
                assert tmp != null;
            } else {
                setSize2 = true;
                tmp = splitPane2;
                splitPane2.setTopComponent(optionalComponents[0]);
                splitPane2.setBottomComponent(optionalComponents[1]);
            }

            if (location.isTopOrLeft()) {
                splitPane.setTopComponent(tmp);
                splitPane.setBottomComponent(component);
            } else {
                splitPane.setTopComponent(component);
                splitPane.setBottomComponent(tmp);
            }
        }

        removeAll();
        add(centerComponent, BorderLayout.CENTER);
        ignoreSizeChange = true;
        try {
            validate();
        } finally {
            ignoreSizeChange = false;
        }

        final Component otherComponent = optionalComponents[1 - index];
        if (optionalComponent == null) {
            if (otherComponent == null) {
                // no resize
            } else {
                final Dimension preferredSizeTmp = otherComponent.getPreferredSize();
                final int preferredSize = getSplitPaneSize(preferredSizeTmp == null ? 50 : location.isTopOrBottom() ? preferredSizeTmp.height : preferredSizeTmp.width);
                setDividerSizeInt(preferredSize);
            }
        } else {
            if (otherComponent == null) {
                setDividerSizeInt(size);
            } else {
                final Dimension preferredSizeTmp = otherComponent.getPreferredSize();
                final int preferredSize = getSplitPaneSize(preferredSizeTmp == null ? 50 : location.isTopOrBottom() ? preferredSizeTmp.height : preferredSizeTmp.width);
                setDividerSizeInt(Math.max(size, preferredSize));
            }
        }

        if (setSize2) {
            setDividerSize2();
        }

        validate();
    }

    private void setDividerSizeInt(final int size) {
        if (showing) {
            setDividerSize(size);
        } else {
            this.size = size;
        }
    }

    private void setDividerSize(final int size) {
        splitPane.setDividerLocation(getSplitPaneSize(size));
    }

    private void setDividerSize2() {
        if (size2 == -1) {
            return;
        }
        splitPane2.setDividerLocation(size2);
    }

    private int getSplitPaneSize(final int size) {
        final Dimension preferredSize = getSplitPanePreferredSize();
        if (location.isTopOrBottom()) {
            preferredSize.height = size;
        } else {
            preferredSize.width = size;
        }
        setSplitPanePreferredSize(preferredSize);

        final int result;
        if (location.isTopOrLeft()) {
            result = size;
        } else {
            final int splitPaneSize = (location.isTopOrBottom() ? splitPane.getHeight() : splitPane.getWidth()) - splitPane.getDividerSize();
            result = Math.max(0, splitPaneSize - size);
        }
        return result;
    }

    @NotNull
    private Dimension getSplitPanePreferredSize() {
        for (final Component optionalComponent : optionalComponents) {
            if (optionalComponent != null) {
                final Dimension preferredSize = optionalComponent.getPreferredSize();
                if (preferredSize != null) {
                    return preferredSize;
                }
            }
        }

        for (final Component optionalComponent : optionalComponents) {
            if (optionalComponent != null) {
                return optionalComponent.getSize();
            }
        }

        return splitPane.getSize();
    }

    private void setSplitPanePreferredSize(@NotNull final Dimension preferredSize) {
        for (final Component optionalComponent : optionalComponents) {
            if (optionalComponent != null) {
                optionalComponent.setPreferredSize(preferredSize);
            }
        }
    }

}