DirectionLayout.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.Insets;
import java.awt.LayoutManager2;
import java.io.Serializable;
import net.sf.gridarta.model.direction.Direction;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class DirectionLayout implements LayoutManager2, Serializable {

    private static final long serialVersionUID = 1L;

    @NotNull
    private static final Direction[] DAIMONIN_TO_DIRECTION_MAP = new Direction[10];

    static {
        addDirection(Direction.NORTH);
        addDirection(Direction.EAST);
        addDirection(Direction.SOUTH);
        addDirection(Direction.WEST);
        addDirection(Direction.NORTH_EAST);
        addDirection(Direction.SOUTH_EAST);
        addDirection(Direction.SOUTH_WEST);
        addDirection(Direction.NORTH_WEST);
        addDirection(Direction.UP);
        addDirection(Direction.DOWN);
    }

    @NotNull
    private static final Dimension EMPTY = new Dimension(0, 0);

    private static void addDirection(@NotNull final Direction direction) {
        DAIMONIN_TO_DIRECTION_MAP[direction.ordinal()] = direction;
    }

    private final int hGap;

    private final int vGap;

    @Nullable
    private Component cNW;

    @Nullable
    private Component cN;

    @Nullable
    private Component cNE;

    @Nullable
    private Component cE;

    @Nullable
    private Component cSE;

    @Nullable
    private Component cS;

    @Nullable
    private Component cSW;

    @Nullable
    private Component cW;

    @Nullable
    private Component cC;

    @Nullable
    private Component cU;

    @Nullable
    private Component cD;

    public DirectionLayout() {
        this(0, 0);
    }

    private DirectionLayout(final int hGap, final int vGap) {
        this.hGap = hGap;
        this.vGap = vGap;
    }

    @SuppressWarnings("ChainOfInstanceofChecks")
    @Override
    public void addLayoutComponent(@NotNull final Component comp, @Nullable final Object constraints) {
        if (constraints == null) {
            cC = comp;
            return;
        }
        final Direction direction;
        if (constraints instanceof Integer) {
            direction = getDirectionFromDaimonin((Integer) constraints);
        } else if (!(constraints instanceof Direction)) {
            throw new IllegalArgumentException("DirectionLayout does not support " + constraints.getClass().getName() + " constraints.");
        } else {
            direction = (Direction) constraints;
        }
        synchronized (comp.getTreeLock()) {
            switch (direction) {
            case NORTH:
                cN = comp;
                break;
            case EAST:
                cE = comp;
                break;
            case SOUTH:
                cS = comp;
                break;
            case WEST:
                cW = comp;
                break;
            case NORTH_EAST:
                cNE = comp;
                break;
            case SOUTH_EAST:
                cSE = comp;
                break;
            case SOUTH_WEST:
                cSW = comp;
                break;
            case NORTH_WEST:
                cNW = comp;
                break;
            case UP:
                cU = comp;
                break;
            case DOWN:
                cD = comp;
                break;
            default:
                assert false;
                break;
            }
        }
    }

    @Override
    public void addLayoutComponent(@NotNull final String name, @NotNull final Component comp) {
        throw new IllegalArgumentException("DirectionLayout does not support String constraints.");
    }

    @Override
    @SuppressWarnings("ObjectEquality")
    public void removeLayoutComponent(@NotNull final Component comp) {
        synchronized (comp.getTreeLock()) {
            if (cC == comp) {
                cC = null;
            } else if (cN == comp) {
                cN = null;
            } else if (cE == comp) {
                cE = null;
            } else if (cS == comp) {
                cS = null;
            } else if (cW == comp) {
                cW = null;
            } else if (cNE == comp) {
                cNE = null;
            } else if (cSE == comp) {
                cSE = null;
            } else if (cSW == comp) {
                cSW = null;
            } else if (cNW == comp) {
                cNW = null;
            } else if (cU == comp) {
                cU = null;
            } else if (cD == comp) {
                cD = null;
            }
        }
    }

    @NotNull
    @Override
    public Dimension minimumLayoutSize(@NotNull final Container parent) {
        synchronized (parent.getTreeLock()) {
            final Dimension dim = new Dimension(0, 0); // return dimension
            final Dimension dC = getMinimumSize(cC);
            final Dimension dN = getMinimumSize(cN);
            final Dimension dE = getMinimumSize(cE);
            final Dimension dS = getMinimumSize(cS);
            final Dimension dW = getMinimumSize(cW);
            final Dimension dNE = getMinimumSize(cNE);
            final Dimension dSE = getMinimumSize(cSE);
            final Dimension dSW = getMinimumSize(cSW);
            final Dimension dNW = getMinimumSize(cNW);
            final Dimension dU = getMinimumSize(cU);
            final Dimension dD = getMinimumSize(cD);
            dim.height = vGap * 4 + dNW.height + max(dW.height, dN.height) + max(dSW.height, dC.height, dNE.height) + max(dS.height, dE.height) + dSE.height + max(dU.height, dD.height);
            dim.width = max(hGap * 2 + dSW.width + max(dNW.width, dC.width, dSE.width) + dNE.width, hGap + max(dW.width, dS.width) + max(dN.width, dE.width), max(dNW.width, dSE.width));
            final Insets insets = parent.getInsets();
            dim.width += insets.left + insets.right;
            dim.height += insets.top + insets.bottom;
            return dim;
        }
    }

    @NotNull
    private static Dimension getMinimumSize(@Nullable final Component component) {
        return component == null ? EMPTY : component.getMinimumSize();
    }

    @NotNull
    @Override
    public Dimension preferredLayoutSize(final Container parent) {
        synchronized (parent.getTreeLock()) {
            final Dimension dim = new Dimension(0, 0); // return dimension
            final Dimension dC = getPreferredSize(cC);
            final Dimension dN = getPreferredSize(cN);
            final Dimension dE = getPreferredSize(cE);
            final Dimension dS = getPreferredSize(cS);
            final Dimension dW = getPreferredSize(cW);
            final Dimension dNE = getPreferredSize(cNE);
            final Dimension dSE = getPreferredSize(cSE);
            final Dimension dSW = getPreferredSize(cSW);
            final Dimension dNW = getPreferredSize(cNW);
            final Dimension dU = getMinimumSize(cU);
            final Dimension dD = getMinimumSize(cD);
            dim.height = vGap * 4 + dNW.height + max(dW.height, dN.height) + max(dSW.height, dC.height, dNE.height) + max(dS.height, dE.height) + dSE.height + max(dU.height, dD.height);
            dim.width = hGap * 2 + dSW.width + max(dNW.width, dC.width, dSE.width) + dNE.width;
            final Insets insets = parent.getInsets();
            dim.width += insets.left + insets.right;
            dim.height += insets.top + insets.bottom;
            return dim;
        }
    }

    @NotNull
    private static Dimension getPreferredSize(@Nullable final Component component) {
        return component == null ? EMPTY : component.getMinimumSize();
    }

    @NotNull
    @Override
    public Dimension maximumLayoutSize(@NotNull final Container target) {
        return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
    }

    @Override
    public float getLayoutAlignmentX(@NotNull final Container target) {
        return 0.5f;
    }

    @Override
    public float getLayoutAlignmentY(@NotNull final Container target) {
        return 0.5f;
    }

    @Override
    public void invalidateLayout(@NotNull final Container target) {
        /* Do Nothing, like BorderLayout. */
    }

    @Override
    public void layoutContainer(@NotNull final Container parent) {
        synchronized (parent.getTreeLock()) {
            final Dimension size = parent.getSize();
            final Insets padding = parent.getInsets();
            final int innerWidth = size.width - padding.left - padding.right;
            final int innerHeight = size.height - padding.top - padding.bottom;
            int rows = 0;
            //noinspection VariableNotUsedInsideIf
            if (cNW != null) {
                rows++;
            }
            if (cW != null || cN != null) {
                rows++;
            }
            if (cSW != null || cC != null || cNE != null) {
                rows++;
            }
            if (cS != null || cE != null) {
                rows++;
            }
            //noinspection VariableNotUsedInsideIf
            if (cSE != null) {
                rows++;
            }
            if (cU != null || cD != null) {
                rows++;
            }
            if (rows <= 0) {
                return;
            }
            final int colWidth = (innerWidth - hGap * 2) / 3;
            final int rowHeight = (innerHeight - vGap * (rows - 1)) / rows;
            int top = padding.top;
            final int left = padding.left;
            if (cNW != null) {
                cNW.setBounds(left + colWidth + hGap, top, colWidth, rowHeight);
                top += rowHeight + vGap;
            }
            if (cW != null || cN != null) {
                if (cW != null) {
                    cW.setBounds(left + ((colWidth + hGap) / 2), top, colWidth, rowHeight);
                }
                if (cN != null) {
                    cN.setBounds(left + ((colWidth + hGap) * 3 / 2), top, colWidth, rowHeight);
                }
                top += rowHeight + vGap;
            }
            if (cSW != null || cC != null || cNE != null) {
                if (cSW != null) {
                    cSW.setBounds(left, top, colWidth, rowHeight);
                }
                if (cC != null) {
                    cC.setBounds(left + colWidth + hGap, top, colWidth, rowHeight);
                }
                if (cNE != null) {
                    cNE.setBounds(left + ((colWidth + hGap) * 2), top, colWidth, rowHeight);
                }
                top += rowHeight + vGap;
            }
            if (cS != null || cE != null) {
                if (cS != null) {
                    cS.setBounds(left + ((colWidth + hGap) / 2), top, colWidth, rowHeight);
                }
                if (cE != null) {
                    cE.setBounds(left + ((colWidth + hGap) * 3 / 2), top, colWidth, rowHeight);
                }
                top += rowHeight + vGap;
            }
            if (cSE != null) {
                cSE.setBounds(left + colWidth + hGap, top, colWidth, rowHeight);
                top += rowHeight + vGap;
            }
            if (cU != null || cD != null) {
                if (cU != null) {
                    cU.setBounds(left + ((colWidth + hGap) / 2), top, colWidth, rowHeight);
                }
                if (cD != null) {
                    cD.setBounds(left + ((colWidth + hGap) * 3 / 2), top, colWidth, rowHeight);
                }
                top += rowHeight + vGap;
            }
        }
    }

    @NotNull
    @Override
    public String toString() {
        return getClass().getName() + "[hGap=" + hGap + ",vGap=" + vGap + ']';
    }

    private static int max(@NotNull final int... numbers) {
        int ret = Integer.MIN_VALUE;
        for (final int number : numbers) {
            if (number > ret) {
                ret = number;
            }
        }
        return ret;
    }

    @NotNull
    private static Direction getDirectionFromDaimonin(final int daimoninDirection) {
        return DAIMONIN_TO_DIRECTION_MAP[daimoninDirection];
    }

}