root/dwt/layout/GridLayout.d

/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
module dwt.layout.GridLayout;

import dwt.layout.GridData;
import dwt.DWT;
import dwt.graphics.Point;
import dwt.graphics.Rectangle;
import dwt.widgets.Control;
import dwt.widgets.Composite;
import dwt.widgets.Layout;
import dwt.widgets.Scrollable;

import dwt.dwthelper.System;

import tango.util.Convert;
import Math = tango.math.Math;
import dwt.dwthelper.utils;


/**
 * Instances of this class lay out the control children of a
 * <code>Composite</code> in a grid.
 * <p>
 * <code>GridLayout</code> has a number of configuration fields, and the
 * controls it lays out can have an associated layout data object, called
 * <code>GridData</code>. The power of <code>GridLayout</code> lies in the
 * ability to configure <code>GridData</code> for each control in the layout.
 * </p>
 * <p>
 * The following code creates a shell managed by a <code>GridLayout</code>
 * with 3 columns:
 * <pre>
 *      Display display = new Display();
 *      Shell shell = new Shell(display);
 *      GridLayout gridLayout = new GridLayout();
 *      gridLayout.numColumns = 3;
 *      shell.setLayout(gridLayout);
 * </pre>
 * The <code>numColumns</code> field is the most important field in a
 * <code>GridLayout</code>. Widgets are laid out in columns from left
 * to right, and a new row is created when <code>numColumns</code> + 1
 * controls are added to the <code>Composite<code>.
 * </p>
 *
 * @see GridData
 * @see <a href="http://www.eclipse.org/swt/snippets/#gridlayout">GridLayout snippets</a>
 * @see <a href="http://www.eclipse.org/swt/examples.php">DWT Example: LayoutExample</a>
 * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
 */
public final class GridLayout : Layout {

    /**
     * numColumns specifies the number of cell columns in the layout.
     * If numColumns has a value less than 1, the layout will not
     * set the size and position of any controls.
     *
     * The default value is 1.
     */
    public int numColumns = 1;

    /**
     * makeColumnsEqualWidth specifies whether all columns in the layout
     * will be forced to have the same width.
     *
     * The default value is false.
     */
    public bool makeColumnsEqualWidth = false;

    /**
     * marginWidth specifies the number of pixels of horizontal margin
     * that will be placed along the left and right edges of the layout.
     *
     * The default value is 5.
     */
    public int marginWidth = 5;

    /**
     * marginHeight specifies the number of pixels of vertical margin
     * that will be placed along the top and bottom edges of the layout.
     *
     * The default value is 5.
     */
    public int marginHeight = 5;

    /**
     * marginLeft specifies the number of pixels of horizontal margin
     * that will be placed along the left edge of the layout.
     *
     * The default value is 0.
     *
     * @since 3.1
     */
    public int marginLeft = 0;

    /**
     * marginTop specifies the number of pixels of vertical margin
     * that will be placed along the top edge of the layout.
     *
     * The default value is 0.
     *
     * @since 3.1
     */
    public int marginTop = 0;

    /**
     * marginRight specifies the number of pixels of horizontal margin
     * that will be placed along the right edge of the layout.
     *
     * The default value is 0.
     *
     * @since 3.1
     */
    public int marginRight = 0;

    /**
     * marginBottom specifies the number of pixels of vertical margin
     * that will be placed along the bottom edge of the layout.
     *
     * The default value is 0.
     *
     * @since 3.1
     */
    public int marginBottom = 0;

    /**
     * horizontalSpacing specifies the number of pixels between the right
     * edge of one cell and the left edge of its neighbouring cell to
     * the right.
     *
     * The default value is 5.
     */
    public int horizontalSpacing = 5;

    /**
     * verticalSpacing specifies the number of pixels between the bottom
     * edge of one cell and the top edge of its neighbouring cell underneath.
     *
     * The default value is 5.
     */
    public int verticalSpacing = 5;

/**
 * Constructs a new instance of this class.
 */
public this () {}

/**
 * Constructs a new instance of this class given the
 * number of columns, and whether or not the columns
 * should be forced to have the same width.
 * If numColumns has a value less than 1, the layout will not
 * set the size and position of any controls.
 *
 * @param numColumns the number of columns in the grid
 * @param makeColumnsEqualWidth whether or not the columns will have equal width
 *
 * @since 2.0
 */
public this (int numColumns, bool makeColumnsEqualWidth) {
    this.numColumns = numColumns;
    this.makeColumnsEqualWidth = makeColumnsEqualWidth;
}

override protected Point computeSize (Composite composite, int wHint, int hHint, bool flushCache_) {
    Point size = layout (composite, false, 0, 0, wHint, hHint, flushCache_);
    if (wHint !is DWT.DEFAULT) size.x = wHint;
    if (hHint !is DWT.DEFAULT) size.y = hHint;
    return size;
}

override protected bool flushCache (Control control) {
    Object data = control.getLayoutData ();
    if (data !is null) (cast(GridData) data).flushCache ();
    return true;
}

GridData getData (Control [][] grid, int row, int column, int rowCount, int columnCount, bool first) {
    Control control = grid [row] [column];
    if (control !is null) {
        GridData data = cast(GridData) control.getLayoutData ();
        int hSpan = Math.max (1, Math.min (data.horizontalSpan, columnCount));
        int vSpan = Math.max (1, data.verticalSpan);
        int i = first ? row + vSpan - 1 : row - vSpan + 1;
        int j = first ? column + hSpan - 1 : column - hSpan + 1;
        if (0 <= i && i < rowCount) {
            if (0 <= j && j < columnCount) {
                if (control is grid [i][j]) return data;
            }
        }
    }
    return null;
}

override protected void layout (Composite composite, bool flushCache_) {
    Rectangle rect = composite.getClientArea ();
    layout (composite, true, rect.x, rect.y, rect.width, rect.height, flushCache_);
}

Point layout (Composite composite, bool move, int x, int y, int width, int height, bool flushCache_) {
    if (numColumns < 1) {
        return new Point (marginLeft + marginWidth * 2 + marginRight, marginTop + marginHeight * 2 + marginBottom);
    }
    Control [] children = composite.getChildren ();
    int count = 0;
    for (int i=0; i<children.length; i++) {
        Control control = children [i];
        GridData data = cast(GridData) control.getLayoutData ();
        if (data is null || !data.exclude) {
            children [count++] = children [i];
        }
    }
    if (count is 0) {
        return new Point (marginLeft + marginWidth * 2 + marginRight, marginTop + marginHeight * 2 + marginBottom);
    }
    for (int i=0; i<count; i++) {
        Control child = children [i];
        GridData data = cast(GridData) child.getLayoutData ();
        if (data is null) child.setLayoutData (data = new GridData ());
        if (flushCache_) data.flushCache ();
        data.computeSize (child, data.widthHint, data.heightHint, flushCache_);
        if (data.grabExcessHorizontalSpace && data.minimumWidth > 0) {
            if (data.cacheWidth < data.minimumWidth) {
                int trim = 0;
                //TEMPORARY CODE
                if ( auto sa = cast(Scrollable)child ) {
                    Rectangle rect = sa.computeTrim (0, 0, 0, 0);
                    trim = rect.width;
                } else {
                    trim = child.getBorderWidth () * 2;
                }
                data.cacheWidth = data.cacheHeight = DWT.DEFAULT;
                data.computeSize (child, Math.max (0, data.minimumWidth - trim), data.heightHint, false);
            }
        }
        if (data.grabExcessVerticalSpace && data.minimumHeight > 0) {
            data.cacheHeight = Math.max (data.cacheHeight, data.minimumHeight);
        }
    }

    /* Build the grid */
    int row = 0, column = 0, rowCount = 0, columnCount = numColumns;
    Control [][] grid = new Control [][]( 4, columnCount );
    for (int i=0; i<count; i++) {
        Control child = children [i];
        GridData data = cast(GridData) child.getLayoutData ();
        int hSpan = Math.max (1, Math.min (data.horizontalSpan, columnCount));
        int vSpan = Math.max (1, data.verticalSpan);
        while (true) {
            int lastRow = row + vSpan;
            if (lastRow >= grid.length) {
                Control [][] newGrid = new Control[][]( lastRow + 4, columnCount );
                SimpleType!(Control[]).arraycopy (grid, 0, newGrid, 0, grid.length);
                grid = newGrid;
            }
            if (grid [row] is null) {
                grid [row] = new Control [columnCount];
            }
            while (column < columnCount && grid [row] [column] !is null) {
                column++;
            }
            int endCount = column + hSpan;
            if (endCount <= columnCount) {
                int index = column;
                while (index < endCount && grid [row] [index] is null) {
                    index++;
                }
                if (index is endCount) break;
                column = index;
            }
            if (column + hSpan >= columnCount) {
                column = 0;
                row++;
            }
        }
        for (int j=0; j<vSpan; j++) {
            if (grid [row + j] is null) {
                grid [row + j] = new Control [columnCount];
            }
            for (int k=0; k<hSpan; k++) {
                grid [row + j] [column + k] = child;
            }
        }
        rowCount = Math.max (rowCount, row + vSpan);
        column += hSpan;
    }

    /* Column widths */
    int availableWidth = width - horizontalSpacing * (columnCount - 1) - (marginLeft + marginWidth * 2 + marginRight);
    int expandCount = 0;
    int [] widths = new int [columnCount];
    int [] minWidths = new int [columnCount];
    bool [] expandColumn = new bool [columnCount];
    for (int j=0; j<columnCount; j++) {
        for (int i=0; i<rowCount; i++) {
            GridData data = getData (grid, i, j, rowCount, columnCount, true);
            if (data !is null) {
                int hSpan = Math.max (1, Math.min (data.horizontalSpan, columnCount));
                if (hSpan is 1) {
                    int w = data.cacheWidth + data.horizontalIndent;
                    widths [j] = Math.max (widths [j], w);
                    if (data.grabExcessHorizontalSpace) {
                        if (!expandColumn [j]) expandCount++;
                        expandColumn [j] = true;
                    }
                    if (!data.grabExcessHorizontalSpace || data.minimumWidth !is 0) {
                        w = !data.grabExcessHorizontalSpace || data.minimumWidth is DWT.DEFAULT ? data.cacheWidth : data.minimumWidth;
                        w += data.horizontalIndent;
                        minWidths [j] = Math.max (minWidths [j], w);
                    }
                }
            }
        }
        for (int i=0; i<rowCount; i++) {
            GridData data = getData (grid, i, j, rowCount, columnCount, false);
            if (data !is null) {
                int hSpan = Math.max (1, Math.min (data.horizontalSpan, columnCount));
                if (hSpan > 1) {
                    int spanWidth = 0, spanMinWidth = 0, spanExpandCount = 0;
                    for (int k=0; k<hSpan; k++) {
                        spanWidth += widths [j-k];
                        spanMinWidth += minWidths [j-k];
                        if (expandColumn [j-k]) spanExpandCount++;
                    }
                    if (data.grabExcessHorizontalSpace && spanExpandCount is 0) {
                        expandCount++;
                        expandColumn [j] = true;
                    }
                    int w = data.cacheWidth + data.horizontalIndent - spanWidth - (hSpan - 1) * horizontalSpacing;
                    if (w > 0) {
                        if (makeColumnsEqualWidth) {
                            int equalWidth = (w + spanWidth) / hSpan;
                            int remainder = (w + spanWidth) % hSpan, last = -1;
                            for (int k = 0; k < hSpan; k++) {
                                widths [last=j-k] = Math.max (equalWidth, widths [j-k]);
                            }
                            if (last > -1) widths [last] += remainder;
                        } else {
                            if (spanExpandCount is 0) {
                                widths [j] += w;
                            } else {
                                int delta = w / spanExpandCount;
                                int remainder = w % spanExpandCount, last = -1;
                                for (int k = 0; k < hSpan; k++) {
                                    if (expandColumn [j-k]) {
                                        widths [last=j-k] += delta;
                                    }
                                }
                                if (last > -1) widths [last] += remainder;
                            }
                        }
                    }
                    if (!data.grabExcessHorizontalSpace || data.minimumWidth !is 0) {
                        w = !data.grabExcessHorizontalSpace || data.minimumWidth is DWT.DEFAULT ? data.cacheWidth : data.minimumWidth;
                        w += data.horizontalIndent - spanMinWidth - (hSpan - 1) * horizontalSpacing;
                        if (w > 0) {
                            if (spanExpandCount is 0) {
                                minWidths [j] += w;
                            } else {
                                int delta = w / spanExpandCount;
                                int remainder = w % spanExpandCount, last = -1;
                                for (int k = 0; k < hSpan; k++) {
                                    if (expandColumn [j-k]) {
                                        minWidths [last=j-k] += delta;
                                    }
                                }
                                if (last > -1) minWidths [last] += remainder;
                            }
                        }
                    }
                }
            }
        }
    }
    if (makeColumnsEqualWidth) {
        int minColumnWidth = 0;
        int columnWidth = 0;
        for (int i=0; i<columnCount; i++) {
            minColumnWidth = Math.max (minColumnWidth, minWidths [i]);
            columnWidth = Math.max (columnWidth, widths [i]);
        }
        columnWidth = width is DWT.DEFAULT || expandCount is 0 ? columnWidth : Math.max (minColumnWidth, availableWidth / columnCount);
        for (int i=0; i<columnCount; i++) {
            expandColumn [i] = expandCount > 0;
            widths [i] = columnWidth;
        }
    } else {
        if (width !is DWT.DEFAULT && expandCount > 0) {
            int totalWidth = 0;
            for (int i=0; i<columnCount; i++) {
                totalWidth += widths [i];
            }
            int c = expandCount;
            int delta = (availableWidth - totalWidth) / c;
            int remainder = (availableWidth - totalWidth) % c;
            int last = -1;
            while (totalWidth !is availableWidth) {
                for (int j=0; j<columnCount; j++) {
                    if (expandColumn [j]) {
                        if (widths [j] + delta > minWidths [j]) {
                            widths [last = j] = widths [j] + delta;
                        } else {
                            widths [j] = minWidths [j];
                            expandColumn [j] = false;
                            c--;
                        }
                    }
                }
                if (last > -1) widths [last] += remainder;

                for (int j=0; j<columnCount; j++) {
                    for (int i=0; i<rowCount; i++) {
                        GridData data = getData (grid, i, j, rowCount, columnCount, false);
                        if (data !is null) {
                            int hSpan = Math.max (1, Math.min (data.horizontalSpan, columnCount));
                            if (hSpan > 1) {
                                if (!data.grabExcessHorizontalSpace || data.minimumWidth !is 0) {
                                    int spanWidth = 0, spanExpandCount = 0;
                                    for (int k=0; k<hSpan; k++) {
                                        spanWidth += widths [j-k];
                                        if (expandColumn [j-k]) spanExpandCount++;
                                    }
                                    int w = !data.grabExcessHorizontalSpace || data.minimumWidth is DWT.DEFAULT ? data.cacheWidth : data.minimumWidth;
                                    w += data.horizontalIndent - spanWidth - (hSpan - 1) * horizontalSpacing;
                                    if (w > 0) {
                                        if (spanExpandCount is 0) {
                                            widths [j] += w;
                                        } else {
                                            int delta2 = w / spanExpandCount;
                                            int remainder2 = w % spanExpandCount, last2 = -1;
                                            for (int k = 0; k < hSpan; k++) {
                                                if (expandColumn [j-k]) {
                                                    widths [last2=j-k] += delta2;
                                                }
                                            }
                                            if (last2 > -1) widths [last2] += remainder2;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if (c is 0) break;
                totalWidth = 0;
                for (int i=0; i<columnCount; i++) {
                    totalWidth += widths [i];
                }
                delta = (availableWidth - totalWidth) / c;
                remainder = (availableWidth - totalWidth) % c;
                last = -1;
            }
        }
    }

    /* Wrapping */
    GridData [] flush = null;
    int flushLength = 0;
    if (width !is DWT.DEFAULT) {
        for (int j=0; j<columnCount; j++) {
            for (int i=0; i<rowCount; i++) {
                GridData data =