GridLayoutAlgorithm.java

/*******************************************************************************
 * Copyright 2005, CHISEL Group, University of Victoria, Victoria, BC, Canada.
 * 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:
 *     The Chisel Group, University of Victoria
 *******************************************************************************/
package org.eclipse.zest.layouts.algorithms;

import java.util.Arrays;

import org.eclipse.zest.layouts.LayoutStyles;
import org.eclipse.zest.layouts.dataStructures.InternalNode;
import org.eclipse.zest.layouts.dataStructures.InternalRelationship;


/**
 * @version 2.0
 * @author Ian Bull
 * @author Casey Best and Rob Lintern
 */
public class GridLayoutAlgorithm extends AbstractLayoutAlgorithm {
	
	private static final double PADDING_PERCENTAGE = 0.95;

	protected int rowPadding = 0;
	
	public void setLayoutArea(double x, double y, double width, double height) {
		throw new RuntimeException("Operation not implemented");
	}
	
    int rows, cols, numChildren; 
    double colWidth, rowHeight, offsetX, offsetY;
    int totalProgress;
    double h, w;
    
    /**
     * Initializes the grid layout.
     * @param styles
     * @see LayoutStyles
     */
	public GridLayoutAlgorithm(int styles) {
		super(styles);
	}
	
	/**
	 * Inititalizes the grid layout with no style.
	 */
	public GridLayoutAlgorithm() {
		this(LayoutStyles.NONE);
	}

    
    protected int getCurrentLayoutStep() {
    	// TODO: This isn't right
    	return 0;
    }
    
    protected int getTotalNumberOfLayoutSteps() {
    	return totalProgress;
    }

    /**
     * 
     */
	protected void preLayoutAlgorithm(InternalNode[] entitiesToLayout, InternalRelationship[] relationshipsToConsider, double x, double y, double width, double height) {
		
		// TODO: Filter unwanted entities and relationships
		//super.applyLayout (entitiesToLayout, relationshipsToConsider, boundsX, boundsY, boundsWidth, boundsHeight);
		// now begin
		numChildren = entitiesToLayout.length;
		if (numChildren < 1) return;
		
		int[] colsAndRows = calculateNumberOfRowsAndCols(numChildren, x, y, width, height);
		cols = colsAndRows[0];
		rows = colsAndRows[1];

		totalProgress = rows + 2;
		fireProgressEvent (1, totalProgress);

		// sort the entities
		if (comparator != null) {
            Arrays.sort(entitiesToLayout, comparator);
		} else {
			Arrays.sort(entitiesToLayout);
		}
		fireProgressEvent (2, totalProgress);

		// Calculate row height and column width
		colWidth = width/cols;	
		rowHeight = height/rows;	

		// Calculate amount to scale children
		double [] nodeSize = calculateNodeSize (colWidth, rowHeight);
		w = nodeSize[0];
		h = nodeSize[1];
		offsetX = (colWidth - w)/2.0; // half of the space between columns
		offsetY = (rowHeight - h)/2.0; // half of the space between rows
	}
	
	/**
	 * Use this algorithm to layout the given entities, using the given relationships and bounds.
	 * The entities will be placed in the same order as they are passed in, unless a comparator
	 * is supplied.  
	 * 
	 * @param entitiesToLayout Apply the algorithm to these entities
	 * @param relationshipsToConsider Only consider these relationships when applying the algorithm.
	 * @param boundsX The left side of the bounds in which the layout can place the entities.
	 * @param boundsY The top side of the bounds in which the layout can place the entities.
	 * @param boundsWidth The width of the bounds in which the layout can place the entities.
	 * @param boundsHeight The height of the bounds in which the layout can place the entities.
	 * @throws RuntimeException Thrown if entitiesToLayout doesn't contain all of the endpoints for each relationship in relationshipsToConsider
	 */
	protected synchronized void applyLayoutInternal(InternalNode[] entitiesToLayout, InternalRelationship[] relationshipsToConsider, double boundsX, double boundsY, double boundsWidth, double boundsHeight) {
		
		int index = 0;
		for( int i = 0; i < rows; i++ ) {
			for( int j = 0; j < cols; j++ ) {
				if( (i*cols + j) < numChildren ) {
					// find new position for child
					double xmove = boundsX + j * colWidth + offsetX;
					double ymove = boundsY + i * rowHeight + offsetY;
					InternalNode sn = entitiesToLayout[index++];
					sn.setInternalLocation( xmove, ymove );
					sn.setInternalSize( Math.max(w, MIN_ENTITY_SIZE), Math.max(h, MIN_ENTITY_SIZE) );
				}
			}
			fireProgressEvent (2 + i, totalProgress);
		}	
		updateLayoutLocations(entitiesToLayout);
		fireProgressEvent (totalProgress, totalProgress);
	}
	
	protected void postLayoutAlgorithm(InternalNode[] entitiesToLayout, InternalRelationship[] relationshipsToConsider) {
		
	}

	/**
	 * Calculates and returns an array containing the number of columns, followed by the number of rows
	 */
	protected int[] calculateNumberOfRowsAndCols (int numChildren, double boundX, double boundY, double boundWidth, double boundHeight) {
		if (getEntityAspectRatio() == 1.0) {
			return calculateNumberOfRowsAndCols_square (numChildren, boundX, boundY, boundWidth, boundHeight);
		} else {
			return calculateNumberOfRowsAndCols_rectangular (numChildren);
		}
	}
	
	protected int[] calculateNumberOfRowsAndCols_square (int numChildren, double boundX, double boundY, double boundWidth, double boundHeight) {
		int rows = Math.max (1, (int) Math.sqrt(numChildren * boundHeight/boundWidth));
		int cols = Math.max (1, (int) Math.sqrt(numChildren * boundWidth/boundHeight));
		
		// if space is taller than wide, adjust rows first
		if (boundWidth <= boundHeight) {
			//decrease number of rows and columns until just enough or not enough
			while (rows*cols > numChildren) {
				if (rows > 1) 
					rows--;
				if (rows*cols > numChildren)
					if (cols > 1) 
						cols--;
			}			
			//increase number of rows and columns until just enough
			while (rows*cols < numChildren) {
				rows++;
				if (rows*cols < numChildren)
					cols++;
			}
		} else {
			//decrease number of rows and columns until just enough or not enough
			while (rows*cols > numChildren) {
				if (cols > 1) 
					cols--;
				if (rows*cols > numChildren)
					if (rows > 1) 
						rows--;
			}			
			//increase number of rows and columns until just enough
			while (rows*cols < numChildren) {
				cols++;
				if (rows*cols < numChildren)
					rows++;
			}
		}
		int[] result = {cols, rows};
		return result;
	}
	
	protected int [] calculateNumberOfRowsAndCols_rectangular (int numChildren) {
		int rows =  Math.max (1, (int)Math.ceil(Math.sqrt(numChildren)));
		int cols = Math.max (1, (int)Math.ceil(Math.sqrt(numChildren)));		
		int[] result = {cols, rows};
		return result;
	}
	
	
	protected double [] calculateNodeSize (double colWidth, double rowHeight) {
		double childW = Math.max (MIN_ENTITY_SIZE, PADDING_PERCENTAGE*colWidth);	
		double childH = Math.max (MIN_ENTITY_SIZE, PADDING_PERCENTAGE*(rowHeight - rowPadding));	
		double whRatio = colWidth/rowHeight;
		if (whRatio < getEntityAspectRatio()) {
			childH = childW/getEntityAspectRatio();		
		} else {
			childW = childH*getEntityAspectRatio();
		}
		double [] result = {childW, childH};
		return result;
	}
	
	/**
	 * Increases the padding between rows in the grid
	 * @param rowPadding Value will not be set if less than 0.
	 */
    public void setRowPadding(int rowPadding) {
        if (rowPadding < 0 ) {
            return;
        }
        this.rowPadding = rowPadding;
    }

	protected boolean isValidConfiguration(boolean asynchronous, boolean continueous) {
		if ( asynchronous && continueous ) return false;
		else if ( asynchronous && !continueous ) return true;
		else if ( !asynchronous && continueous ) return false;
		else if ( !asynchronous && !continueous ) return true;
		
		return false;
	}

}