GSplitPane.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;

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.HierarchyEvent;
import java.awt.event.HierarchyListener;
import java.util.ArrayList;
import java.util.List;
import java.util.prefs.Preferences;
import javax.swing.AbstractButton;
import javax.swing.JSplitPane;
import javax.swing.border.EmptyBorder;
import net.sf.gridarta.MainControl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class GSplitPane extends JSplitPane {

    @NotNull
    private static final String MIN = "min";

    @NotNull
    private static final String MAX = "max";

    private static final long serialVersionUID = 1L;

    @NotNull
    private static final Preferences PREFERENCES = Preferences.userNodeForPackage(MainControl.class);

    @NotNull
    private final String preferencesKey;

    @NotNull
    private final List<ActionListener> actionListeners = new ArrayList<>();

    @Nullable
    private final String defaultDividerLocation;

    @NotNull
    private final HierarchyListener hierarchyListener = new HierarchyListener() {

        @Override
        public void hierarchyChanged(final HierarchyEvent e) {
            if ((e.getChangeFlags() & (long) HierarchyEvent.SHOWING_CHANGED) != 0L && isShowing()) {
                removeHierarchyListener(hierarchyListener);
                if (defaultDividerLocation == null) { // should not happen
                    // ignore
                } else if (defaultDividerLocation.equals(MIN)) {
                    if (!actionListeners.isEmpty()) {
                        actionListeners.get(0).actionPerformed(new ActionEvent(GSplitPane.this, 0, ""));
                    }
                } else if (defaultDividerLocation.equals(MAX)) {
                    if (!actionListeners.isEmpty()) {
                        actionListeners.get(1).actionPerformed(new ActionEvent(GSplitPane.this, 0, ""));
                    }
                } else {
                    try {
                        setDividerLocation(Integer.parseInt(defaultDividerLocation));
                    } catch (final NumberFormatException ignored) {
                        // ignore
                    }
                }
            }
        }
    };

    public GSplitPane(final int newOrientation, @NotNull final Component newLeftComponent, @NotNull final Component newRightComponent, @NotNull final String preferencesKey, final int defaultDividerLocation) {
        super(newOrientation, newLeftComponent, newRightComponent);
        this.preferencesKey = preferencesKey;
        setOneTouchExpandable(true);
        this.defaultDividerLocation = PREFERENCES.get(preferencesKey, defaultDividerLocation == -1 ? null : Integer.toString(defaultDividerLocation));

        // Hacks to circumvent undesired behavior when maximizing/de-maximizing
        // the application's main window: without this code, the minimized or
        // maximized state (oneTouchExpandable) does not stick and cannot be
        // restored when the editor is restarted.
        //
        // This code walks the component hierarchy trying to find the
        // oneTouchExpandable buttons. The contained ActionListeners are
        // replaced with a proxy that shows the left/right component as
        // appropriate for the action.
        setBorder(new EmptyBorder(0, 0, 0, 0));
        for (final Component component : getComponents()) {
            if (component != newLeftComponent && component != newRightComponent) {
                if (component instanceof Container) {
                    final Container container = (Container) component;
                    for (final Component component2 : container.getComponents()) {
                        if (component2 instanceof AbstractButton) {
                            final AbstractButton button = (AbstractButton) component2;
                            for (final ActionListener actionListener : button.getActionListeners()) {
                                if (actionListener.getClass().getName().endsWith("$OneTouchActionHandler")) {
                                    actionListeners.add(actionListener);
                                    button.removeActionListener(actionListener);
                                    if (actionListeners.size() == 1) {
                                        button.addActionListener(new ActionListener() {

                                            @Override
                                            public void actionPerformed(@NotNull final ActionEvent e) {
                                                getRightComponent().setVisible(true);
                                                actionListener.actionPerformed(e);
                                            }

                                        });
                                    } else {
                                        button.addActionListener(new ActionListener() {

                                            @Override
                                            public void actionPerformed(@NotNull final ActionEvent e) {
                                                getLeftComponent().setVisible(true);
                                                actionListener.actionPerformed(e);
                                            }

                                        });
                                    }
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
        if (actionListeners.size() != 2) {
            actionListeners.clear();
        }
        //noinspection VariableNotUsedInsideIf
        if (this.defaultDividerLocation != null) {
            addHierarchyListener(hierarchyListener);
        }
    }

    public void saveLocation() {
        final int dividerLocation = getDividerLocation();
        if (dividerLocation != -1) {
            final String value;
            switch (getState(dividerLocation)) {
            case -1:
                value = MIN;
                break;

            default:
                value = Integer.toString(dividerLocation);
                break;

            case +1:
                value = MAX;
                break;
            }
            PREFERENCES.put(preferencesKey, value);
        }
    }

    @Override
    public void setDividerLocation(final int location) {
        super.setDividerLocation(location);
        final int state = getState(location);
        getLeftComponent().setVisible(state != -1);
        getRightComponent().setVisible(state != +1);
    }

    private int getState(final int dividerLocation) {
        final Dimension leftSize = leftComponent.getMinimumSize();
        final Dimension rightSize = rightComponent.getMinimumSize();
        final int minLimit = getOrientation() == HORIZONTAL_SPLIT ? leftSize.width : leftSize.height;
        final int maxLimit = getOrientation() == HORIZONTAL_SPLIT ? getWidth() - rightSize.width - getDividerSize() : getHeight() - rightSize.height - getDividerSize();
        if (dividerLocation < minLimit) {
            return -1;
        } else if (dividerLocation > maxLimit) {
            return +1;
        } else {
            return 0;
        }
    }

}