WrapLayout.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2019-2020 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.sleuthkit.autopsy.guiutils;

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import javax.swing.JScrollPane;
import javax.swing.SwingUtilities;

public class WrapLayout implements LayoutManager, java.io.Serializable {

    private static final long serialVersionUID = 1L;

    private int horizontalGap = 0;

    private int verticalGap = 0;

    private boolean alignOnBaseline = false;

    private final Set<Component> oppositeAlignedItems = new HashSet<>();

    public WrapLayout() {
        this(5, 5);
    }

    public WrapLayout(int verticalGap, int horizontalGap) {
        this.verticalGap = verticalGap;
        this.horizontalGap = horizontalGap;
    }

    public void setOppositeAligned(Collection<Component> oppAlignedComponents) {
        this.oppositeAlignedItems.clear();
        this.oppositeAlignedItems.addAll(oppAlignedComponents);
    }

    public Collection<Component> getOppositeAlignedItems() {
        return Collections.unmodifiableCollection(oppositeAlignedItems);
    }

    public int getHorizontalGap() {
        return horizontalGap;
    }

    public void setHorizontalGap(int horizontalGap) {
        this.horizontalGap = horizontalGap;
    }

    public int getVerticalGap() {
        return verticalGap;
    }

    public void setVerticalGap(int verticalGap) {
        this.verticalGap = verticalGap;
    }

    public void setAlignOnBaseline(boolean alignOnBaseline) {
        this.alignOnBaseline = alignOnBaseline;
    }

    public boolean isAlignOnBaseline() {
        return alignOnBaseline;
    }

    @Override
    public void addLayoutComponent(String name, Component comp) {
        //Empty
    }

    @Override
    public void removeLayoutComponent(Component comp) {
        //Empty
    }

    private int getComponentY(int rowY, boolean alignBaseline, int rowHeight,
            int itemHeight) {
        return alignBaseline
                ? rowY + rowHeight - itemHeight
                : rowY;
    }

    private int getComponentX(int leftX, int rightX, boolean ltr, int xPos,
            int componentWidth) {
        return ltr ? leftX + xPos : rightX - xPos - componentWidth;
    }

    private int setComponentDims(Component comp, boolean alignBaseline,
            boolean ltr, int rowY, int rowHeight, int leftX, int rightX,
            int xPos) {

        Dimension d = comp.getPreferredSize();
        comp.setSize(d);

        int x = getComponentX(leftX, rightX, ltr, xPos, d.width);
        int y = getComponentY(rowY, alignBaseline, rowHeight, d.height);
        comp.setLocation(x, y);

        return d.width;
    }

    @Override
    public void layoutContainer(Container target) {
        ParentDimensions targetDims = getTargetDimensions(target);
        List<Component> components = Arrays.asList(target.getComponents());
        List<WrapLayoutRow> rows = getAllRows(components, true, targetDims.getInnerWidth());

        boolean ltr = target.getComponentOrientation().isLeftToRight();
        boolean useBaseline = isAlignOnBaseline();

        int rowY = targetDims.getInsets().top + getVerticalGap();
        int leftX = targetDims.getInsets().left + getHorizontalGap();
        int rightX = targetDims.getOuterWidth() - targetDims.getInsets().right - getHorizontalGap();

        for (WrapLayoutRow row : rows) {
            int rowHeight = row.getHeight();

            int curX = 0;
            if (row.getComponents() != null) {
                for (Component origComp : row.getComponents()) {
                    curX += setComponentDims(origComp, useBaseline, ltr, rowY, rowHeight, leftX, rightX, curX) + getHorizontalGap();
                }
            }

            if (row.getOppositeAligned() != null) {
                curX = 0;
                // reverse opposite aligned for layout purposes since flipping ltr
                Collections.reverse(row.getOppositeAligned());
                for (Component oppAlignedComp : row.getOppositeAligned()) {
                    curX += setComponentDims(oppAlignedComp, useBaseline, !ltr, rowY, rowHeight, leftX, rightX, curX) + getHorizontalGap();
                }
            }

            rowY += rowHeight + getVerticalGap();
        }
    }

    @Override
    public Dimension preferredLayoutSize(Container target) {
        return layoutSize(target, true);
    }

    @Override
    public Dimension minimumLayoutSize(Container target) {
        Dimension minimum = layoutSize(target, false);
        minimum.width -= (getHorizontalGap() + 1);
        return minimum;
    }

    private static class ParentDimensions {

        private final int outerWidth;
        private final int innerWidth;
        private final Insets insets;

        ParentDimensions(int outerWidth, int innerWidth, Insets insets) {
            this.outerWidth = outerWidth;
            this.innerWidth = innerWidth;
            this.insets = insets;
        }

        int getOuterWidth() {
            return outerWidth;
        }

        int getInnerWidth() {
            return innerWidth;
        }

        Insets getInsets() {
            return insets;
        }
    }

    private ParentDimensions getTargetDimensions(Container target) {
        Container container = target;

        while (container.getSize().width == 0 && container.getParent() != null) {
            container = container.getParent();
        }

        int targetWidth = container.getSize().width;

        if (targetWidth == 0) {
            targetWidth = Integer.MAX_VALUE;
        }

        Insets insets = container.getInsets();
        int horizontalInsetsAndGap = insets.left + insets.right + (getHorizontalGap() * 2);
        int maxWidth = targetWidth - horizontalInsetsAndGap;

        return new ParentDimensions(targetWidth, maxWidth, insets);
    }

    private Dimension layoutSize(Container target, boolean preferred) {
        ParentDimensions targetDims = getTargetDimensions(target);
        List<Component> components = Arrays.asList(target.getComponents());
        List<WrapLayoutRow> rows = getAllRows(components, preferred, targetDims.getInnerWidth());

        Integer containerHeight = rows.stream().map((r) -> r.getHeight()).reduce(0, Integer::sum);
        // add in vertical gap between rows
        if (rows.size() > 1) {
            containerHeight += (rows.size() - 1) * getVerticalGap();
        }

        containerHeight += targetDims.getInsets().top + targetDims.getInsets().bottom;

        Integer containerWidth = rows.stream().map((r) -> r.getWidth()).reduce(0, Math::max);
        containerWidth += targetDims.getInsets().left + targetDims.getInsets().right + (getHorizontalGap() * 2);

        //  When using a scroll pane or the DecoratedLookAndFeel we need to
        //  make sure the preferred size is less than the size of the
        //  target containter so shrinking the container size works
        //  correctly. Removing the horizontal gap is an easy way to do this.
        Container scrollPane = SwingUtilities.getAncestorOfClass(JScrollPane.class, target);

        if (scrollPane != null && target.isValid()) {
            containerWidth -= (getHorizontalGap() + 1);
        }

        return new Dimension(containerWidth, containerHeight);
    }

    private class WrapLayoutRow {

        private final List<Component> components;
        private final List<Component> oppositeAligned;
        private final int height;
        private final int width;

        WrapLayoutRow(List<Component> components, List<Component> oppositeAligned,
                int height, int width) {
            this.components = components;
            this.oppositeAligned = oppositeAligned;
            this.height = height;
            this.width = width;
        }

        List<Component> getComponents() {
            return components;
        }

        List<Component> getOppositeAligned() {
            return oppositeAligned;
        }

        int getHeight() {
            return height;
        }

        int getWidth() {
            return width;
        }

    }

    private List<WrapLayoutRow> getAllRows(List<Component> components,
            boolean preferred, int maxWidth) {
        List<Component> originalComp
                = components
                        .stream()
                        .filter((comp) -> !this.oppositeAlignedItems.contains(comp))
                        .collect(Collectors.toList());

        List<WrapLayoutRow> originalRowSet = getRowSet(originalComp, preferred, maxWidth);

        List<Component> oppositeAlignedComp
                = components
                        .stream()
                        .filter((comp) -> this.oppositeAlignedItems.contains(comp))
                        .collect(Collectors.toList());

        // go in reverse order and then revert so we can use same getRowSet method
        Collections.reverse(oppositeAlignedComp);
        List<WrapLayoutRow> oppositeRowSet = getRowSet(oppositeAlignedComp, preferred, maxWidth)
                .stream()
                .map((WrapLayoutRow row) -> {
                    Collections.reverse(row.getComponents());
                    return new WrapLayoutRow(null, row.getComponents(), row.getHeight(), row.getWidth());
                })
                .collect(Collectors.toList());
        Collections.reverse(oppositeRowSet);

        List<WrapLayoutRow> toReturn = new ArrayList<>();

        // if there is a row of components that will have both normal and opposite aligned
        // components, create the corresponding row.
        if (!originalRowSet.isEmpty() && !oppositeRowSet.isEmpty()) {
            WrapLayoutRow lastOrig = originalRowSet.get(originalRowSet.size() - 1);
            WrapLayoutRow firstOpp = oppositeRowSet.get(0);

            int proposedRowWidth = lastOrig.getWidth() + firstOpp.getWidth() + getHorizontalGap();
            if (proposedRowWidth <= maxWidth) {
                WrapLayoutRow middleRow = new WrapLayoutRow(lastOrig.getComponents(), firstOpp.getOppositeAligned(),
                        Math.max(lastOrig.getHeight(), firstOpp.getHeight()), proposedRowWidth);

                toReturn.addAll(originalRowSet.subList(0, originalRowSet.size() - 1));
                toReturn.add(middleRow);
                toReturn.addAll(oppositeRowSet.subList(1, oppositeRowSet.size()));
                return toReturn;
            }
        }

        toReturn.addAll(originalRowSet);
        toReturn.addAll(oppositeRowSet);
        return toReturn;
    }

    private List<WrapLayoutRow> getRowSet(List<Component> components,
            boolean preferred, int maxWidth) {
        List<WrapLayoutRow> rows = new ArrayList<>();

        List<Component> rowComponents = new ArrayList<>();
        int rowWidth = 0;
        int rowHeight = 0;

        for (Component m : components) {
            if (m.isVisible()) {
                Dimension d = preferred ? m.getPreferredSize() : m.getMinimumSize();

                //  Can't add the component to current row. Start a new row.
                if (rowWidth + d.width > maxWidth) {
                    rows.add(new WrapLayoutRow(rowComponents, null, rowHeight, rowWidth));
                    rowComponents = new ArrayList<>();
                    rowWidth = 0;
                    rowHeight = 0;
                }

                //  Add a horizontal gap for all components after the first
                if (rowWidth != 0) {
                    rowWidth += getHorizontalGap();
                }

                rowComponents.add(m);
                rowWidth += d.width;
                rowHeight = Math.max(rowHeight, d.height);
            }
        }

        if (!rowComponents.isEmpty()) {
            rows.add(new WrapLayoutRow(rowComponents, null, rowHeight, rowWidth));
        }

        return rows;
    }
}