bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/TrimmedPartLayout.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2008, 2014 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
  *******************************************************************************/
 package org.eclipse.e4.ui.workbench.renderers.swt;

 import org.eclipse.swt.SWT;
 import org.eclipse.swt.graphics.Point;
 import org.eclipse.swt.graphics.Rectangle;
 import org.eclipse.swt.layout.FillLayout;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Layout;

 /**
  * This arranges its controls into 5 'slots' defined by its composite children
  * <ol>
  * <li>Top: spans the entire width and abuts the top of the container</li>
  * <li>Bottom: spans the entire width and abuts the bottom of the container</li>
  * <li>Left: spans the space between 'top' and 'bottom' and abuts the left of
  * the container</li>
  * <li>Right: spans the space between 'top' and 'bottom' and abuts the right of
  * the container</li>
  * <li>Center: fills the area remaining once the other controls have been
  * positioned</li>
  * </ol>
  *
  * <strong>NOTE:</strong> <i>All</i> the child controls must exist. Also,
  * computeSize is not implemented because we expect this to be used in
  * situations (i.e. shells) where the outer bounds are always 'set', not
  * computed. Also, the interior structure of the center may contain overlapping
  * controls so it may not be capable of performing the calculation.
  *
  * @author emoffatt
  *
  */
 public class TrimmedPartLayout extends Layout {

 	/**
 	 * gutterBottom specifies the number of pixels of vertical margin that will
 	 * be placed between the bottom trim component and the bottom edge of the
 	 * client area. If there is no bottom trim component, the gutter serves as a
 	 * margin.
 	 *
 	 * The default value is 0.
 	 */
 	public int gutterBottom = 0;

 	/**
 	 * gutterLeft specifies the number of pixels of horizontal margin that will
 	 * be placed between the left trim component and the left edge of the client
 	 * area. If there is no left trim component, the gutter serves as a margin.
 	 *
 	 * The default value is 0.
 	 */
 	public int gutterLeft = 0;

 	/**
 	 * gutterTop specifies the number of pixels of vertical margin that will be
 	 * placed between the top trim component and the top edge of the client
 	 * area. If there is no top trim component, the gutter serves as a margin.
 	 *
 	 * The default value is 0.
 	 */
 	public int gutterTop = 0;

 	/**
 	 * gutterRight specifies the number of pixels of horizontal margin that will
 	 * be placed between the right trim component and the right edge of the
 	 * client area. If there is no right trim component, the gutter serves as a
 	 * margin.
 	 *
 	 * The default value is 0.
 	 */
 	public int gutterRight = 0;

 	public Composite top;
 	public Composite bottom;
 	public Composite left;
 	public Composite right;
 	public Composite clientArea;

 	/**
 	 * This layout is used to support parts that want trim for their containing
 	 * composites.
 	 *
 	 * @param trimOwner
 	 */
 	public TrimmedPartLayout(Composite parent) {
 		clientArea = new Composite(parent, SWT.NONE);
 		clientArea.setLayout(new FillLayout());
 	}

 	@Override
 	protected Point computeSize(Composite composite, int wHint, int hHint,
 			boolean flushCache) {
 		// We can't actually compute a size so return a default
 		return new Point(SWT.DEFAULT, SWT.DEFAULT);
 	}

 	@Override
 	protected void layout(Composite composite, boolean flushCache) {
 		Rectangle ca = composite.getClientArea();
 		Rectangle caRect = new Rectangle(ca.x, ca.y, ca.width, ca.height);

 		// 'Top' spans the entire area
 		if (top != null && top.isVisible()) {
 			Point topSize = top.computeSize(caRect.width, SWT.DEFAULT, true);
 			caRect.y += topSize.y;
 			caRect.height -= topSize.y;

 			// Don't layout unless we've changed
 			Rectangle newBounds = new Rectangle(ca.x, ca.y, caRect.width,
 					topSize.y);
 			if (!newBounds.equals(top.getBounds())) {
 				top.setBounds(newBounds);
 			}
 		}
 		// Include the gutter whether there is a top area or not.
 		caRect.y += gutterTop;
 		caRect.height -= gutterTop;

 		// 'Bottom' spans the entire area
 		if (bottom != null && bottom.isVisible()) {
 			Point bottomSize = bottom.computeSize(caRect.width, SWT.DEFAULT,
 					true);
 			caRect.height -= bottomSize.y;

 			// Don't layout unless we've changed
 			Rectangle newBounds = new Rectangle(caRect.x, caRect.y
 					+ caRect.height, caRect.width, bottomSize.y);
 			if (!newBounds.equals(bottom.getBounds())) {
 				bottom.setBounds(newBounds);
 			}
 		}
 		caRect.height -= gutterBottom;

 		// 'Left' spans between 'top' and 'bottom'
 		if (left != null && left.isVisible()) {
 			Point leftSize = left.computeSize(SWT.DEFAULT, caRect.height, true);
 			caRect.x += leftSize.x;
 			caRect.width -= leftSize.x;

 			// Don't layout unless we've changed
 			Rectangle newBounds = new Rectangle(caRect.x - leftSize.x,
 					caRect.y, leftSize.x, caRect.height);
 			if (!newBounds.equals(left.getBounds())) {
 				left.setBounds(newBounds);
 			}
 		}
 		caRect.x += gutterLeft;
 		caRect.width -= gutterLeft;

 		// 'Right' spans between 'top' and 'bottom'
 		if (right != null && right.isVisible()) {
 			Point rightSize = right.computeSize(SWT.DEFAULT, caRect.height,
 					true);
 			caRect.width -= rightSize.x;

 			// Don't layout unless we've changed
 			Rectangle newBounds = new Rectangle(caRect.x + caRect.width,
 					caRect.y, rightSize.x, caRect.height);
 			if (!newBounds.equals(right.getBounds())) {
 				right.setBounds(newBounds);
 			}
 		}
 		caRect.width -= gutterRight;

 		// Don't layout unless we've changed
 		if (!caRect.equals(clientArea.getBounds())) {
 			clientArea.setBounds(caRect);
 		}
 	}

 	/**
 	 * @param top2
 	 * @param b
 	 * @return
 	 */
 	public Composite getTrimComposite(Composite parent, int side) {
 		if (side == SWT.TOP) {
 			if (top == null) {
 				top = new Composite(parent, SWT.NONE);
 				top.setLayout(new TrimBarLayout(true));
 				top.addDisposeListener(e -> top = null);
 			}
 			return top;
 		} else if (side == SWT.BOTTOM) {
 			if (bottom == null) {
 				bottom = new Composite(parent, SWT.NONE);
 				bottom.setLayout(new TrimBarLayout(true));
 				bottom.addDisposeListener(e -> bottom = null);
 			}
 			return bottom;
 		} else if (side == SWT.LEFT) {
 			if (left == null) {
 				left = new Composite(parent, SWT.NONE);
 				left.setLayout(new TrimBarLayout(false));
 				left.addDisposeListener(e -> left = null);
 			}
 			return left;
 		} else if (side == SWT.RIGHT) {
 			if (right == null) {
 				right = new Composite(parent, SWT.NONE);
 				right.setLayout(new TrimBarLayout(false));
 				right.addDisposeListener(e -> right = null);
 			}
 			return right;
 		}

 		// Unknown location
 		return null;
 	}

 	public Rectangle getTrimRect(int side) {
 		Rectangle caBounds = clientArea.getBounds();
 		caBounds = Display.getCurrent().map(clientArea.getParent(), null,
 				caBounds);

 		if (side == SWT.TOP) {
 			if (top != null) {
 				Rectangle b = top.getBounds();
 				b = top.getDisplay().map(top.getParent(), null, b);
 				return b;
 			}

 			// Fake one
 			caBounds.height = 25;
 			return caBounds;
 		}
 		if (side == SWT.BOTTOM) {
 			if (bottom != null) {
 				Rectangle b = bottom.getBounds();
 				b = bottom.getDisplay().map(bottom.getParent(), null, b);
 				return b;
 			}

 			// Fake one
 			caBounds.y = (caBounds.y + caBounds.height) - 25;
 			caBounds.height = 25;
 			return caBounds;
 		}
 		if (side == SWT.LEFT) {
 			if (left != null && left.getChildren().length > 0) {
 				Rectangle b = left.getBounds();
 				b = left.getDisplay().map(left.getParent(), null, b);
 				return b;
 			}

 			// Fake one
 			caBounds.width = 25;
 			return caBounds;
 		}
 		if (side == SWT.RIGHT) {
 			if (right != null && right.getChildren().length > 0) {
 				Rectangle b = right.getBounds();
 				b = right.getDisplay().map(right.getParent(), null, b);
 				return b;
 			}

 			// Fake one
 			caBounds.x = (caBounds.x + caBounds.width) - 25;
 			caBounds.width = 25;
 			return caBounds;
 		}
 		return null;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2008, 2014 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
	*******************************************************************************/
	package org.eclipse.e4.ui.workbench.renderers.swt;

	import org.eclipse.swt.SWT;
	import org.eclipse.swt.graphics.Point;
	import org.eclipse.swt.graphics.Rectangle;
	import org.eclipse.swt.layout.FillLayout;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.Layout;

	/**
	* This arranges its controls into 5 'slots' defined by its composite children
	* <ol>
	* <li>Top: spans the entire width and abuts the top of the container</li>
	* <li>Bottom: spans the entire width and abuts the bottom of the container</li>
	* <li>Left: spans the space between 'top' and 'bottom' and abuts the left of
	* the container</li>
	* <li>Right: spans the space between 'top' and 'bottom' and abuts the right of
	* the container</li>
	* <li>Center: fills the area remaining once the other controls have been
	* positioned</li>
	* </ol>
	*
	* <strong>NOTE:</strong> <i>All</i> the child controls must exist. Also,
	* computeSize is not implemented because we expect this to be used in
	* situations (i.e. shells) where the outer bounds are always 'set', not
	* computed. Also, the interior structure of the center may contain overlapping
	* controls so it may not be capable of performing the calculation.
	*
	* @author emoffatt
	*
	*/
	public class TrimmedPartLayout extends Layout {

	/**
	* gutterBottom specifies the number of pixels of vertical margin that will
	* be placed between the bottom trim component and the bottom edge of the
	* client area. If there is no bottom trim component, the gutter serves as a
	* margin.
	*
	* The default value is 0.
	*/
	public int gutterBottom = 0;

	/**
	* gutterLeft specifies the number of pixels of horizontal margin that will
	* be placed between the left trim component and the left edge of the client
	* area. If there is no left trim component, the gutter serves as a margin.
	*
	* The default value is 0.
	*/
	public int gutterLeft = 0;

	/**
	* gutterTop specifies the number of pixels of vertical margin that will be
	* placed between the top trim component and the top edge of the client
	* area. If there is no top trim component, the gutter serves as a margin.
	*
	* The default value is 0.
	*/
	public int gutterTop = 0;

	/**
	* gutterRight specifies the number of pixels of horizontal margin that will
	* be placed between the right trim component and the right edge of the
	* client area. If there is no right trim component, the gutter serves as a
	* margin.
	*
	* The default value is 0.
	*/
	public int gutterRight = 0;

	public Composite top;
	public Composite bottom;
	public Composite left;
	public Composite right;
	public Composite clientArea;

	/**
	* This layout is used to support parts that want trim for their containing
	* composites.
	*
	* @param trimOwner
	*/
	public TrimmedPartLayout(Composite parent) {
	clientArea = new Composite(parent, SWT.NONE);
	clientArea.setLayout(new FillLayout());
	}

	@Override
	protected Point computeSize(Composite composite, int wHint, int hHint,
	boolean flushCache) {
	// We can't actually compute a size so return a default
	return new Point(SWT.DEFAULT, SWT.DEFAULT);
	}

	@Override
	protected void layout(Composite composite, boolean flushCache) {
	Rectangle ca = composite.getClientArea();
	Rectangle caRect = new Rectangle(ca.x, ca.y, ca.width, ca.height);

	// 'Top' spans the entire area
	if (top != null && top.isVisible()) {
	Point topSize = top.computeSize(caRect.width, SWT.DEFAULT, true);
	caRect.y += topSize.y;
	caRect.height -= topSize.y;

	// Don't layout unless we've changed
	Rectangle newBounds = new Rectangle(ca.x, ca.y, caRect.width,
	topSize.y);
	if (!newBounds.equals(top.getBounds())) {
	top.setBounds(newBounds);
	}
	}
	// Include the gutter whether there is a top area or not.
	caRect.y += gutterTop;
	caRect.height -= gutterTop;

	// 'Bottom' spans the entire area
	if (bottom != null && bottom.isVisible()) {
	Point bottomSize = bottom.computeSize(caRect.width, SWT.DEFAULT,
	true);
	caRect.height -= bottomSize.y;

	// Don't layout unless we've changed
	Rectangle newBounds = new Rectangle(caRect.x, caRect.y
	+ caRect.height, caRect.width, bottomSize.y);
	if (!newBounds.equals(bottom.getBounds())) {
	bottom.setBounds(newBounds);
	}
	}
	caRect.height -= gutterBottom;

	// 'Left' spans between 'top' and 'bottom'
	if (left != null && left.isVisible()) {
	Point leftSize = left.computeSize(SWT.DEFAULT, caRect.height, true);
	caRect.x += leftSize.x;
	caRect.width -= leftSize.x;

	// Don't layout unless we've changed
	Rectangle newBounds = new Rectangle(caRect.x - leftSize.x,
	caRect.y, leftSize.x, caRect.height);
	if (!newBounds.equals(left.getBounds())) {
	left.setBounds(newBounds);
	}
	}
	caRect.x += gutterLeft;
	caRect.width -= gutterLeft;

	// 'Right' spans between 'top' and 'bottom'
	if (right != null && right.isVisible()) {
	Point rightSize = right.computeSize(SWT.DEFAULT, caRect.height,
	true);
	caRect.width -= rightSize.x;

	// Don't layout unless we've changed
	Rectangle newBounds = new Rectangle(caRect.x + caRect.width,
	caRect.y, rightSize.x, caRect.height);
	if (!newBounds.equals(right.getBounds())) {
	right.setBounds(newBounds);
	}
	}
	caRect.width -= gutterRight;

	// Don't layout unless we've changed
	if (!caRect.equals(clientArea.getBounds())) {
	clientArea.setBounds(caRect);
	}
	}

	/**
	* @param top2
	* @param b
	* @return
	*/
	public Composite getTrimComposite(Composite parent, int side) {
	if (side == SWT.TOP) {
	if (top == null) {
	top = new Composite(parent, SWT.NONE);
	top.setLayout(new TrimBarLayout(true));
	top.addDisposeListener(e -> top = null);
	}
	return top;
	} else if (side == SWT.BOTTOM) {
	if (bottom == null) {
	bottom = new Composite(parent, SWT.NONE);
	bottom.setLayout(new TrimBarLayout(true));
	bottom.addDisposeListener(e -> bottom = null);
	}
	return bottom;
	} else if (side == SWT.LEFT) {
	if (left == null) {
	left = new Composite(parent, SWT.NONE);
	left.setLayout(new TrimBarLayout(false));
	left.addDisposeListener(e -> left = null);
	}
	return left;
	} else if (side == SWT.RIGHT) {
	if (right == null) {
	right = new Composite(parent, SWT.NONE);
	right.setLayout(new TrimBarLayout(false));
	right.addDisposeListener(e -> right = null);
	}
	return right;
	}

	// Unknown location
	return null;
	}

	public Rectangle getTrimRect(int side) {
	Rectangle caBounds = clientArea.getBounds();
	caBounds = Display.getCurrent().map(clientArea.getParent(), null,
	caBounds);

	if (side == SWT.TOP) {
	if (top != null) {
	Rectangle b = top.getBounds();
	b = top.getDisplay().map(top.getParent(), null, b);
	return b;
	}

	// Fake one
	caBounds.height = 25;
	return caBounds;
	}
	if (side == SWT.BOTTOM) {
	if (bottom != null) {
	Rectangle b = bottom.getBounds();
	b = bottom.getDisplay().map(bottom.getParent(), null, b);
	return b;
	}

	// Fake one
	caBounds.y = (caBounds.y + caBounds.height) - 25;
	caBounds.height = 25;
	return caBounds;
	}
	if (side == SWT.LEFT) {
	if (left != null && left.getChildren().length > 0) {
	Rectangle b = left.getBounds();
	b = left.getDisplay().map(left.getParent(), null, b);
	return b;
	}

	// Fake one
	caBounds.width = 25;
	return caBounds;
	}
	if (side == SWT.RIGHT) {
	if (right != null && right.getChildren().length > 0) {
	Rectangle b = right.getBounds();
	b = right.getDisplay().map(right.getParent(), null, b);
	return b;
	}

	// Fake one
	caBounds.x = (caBounds.x + caBounds.width) - 25;
	caBounds.width = 25;
	return caBounds;
	}
	return null;
	}
	}