| /******************************************************************************* |
| * 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 |
| * Randy Hudson <hudsonr@us.ibm.com> |
| * - Fix for bug 19524 - Resizing WorkbenchWindow resizes Views |
| * Cagatay Kavukcuoglu <cagatayk@acm.org> |
| * - Fix for bug 10025 - Resizing views should not use height ratios |
| * Matthew Hatem Matthew_Hatem@notesdev.ibm.com Bug 189953 |
| *******************************************************************************/ |
| package org.eclipse.ui.internal; |
| |
| import java.util.ArrayList; |
| |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.jface.util.Geometry; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Sash; |
| import org.eclipse.ui.IPageLayout; |
| |
| /** |
| * Implementation of a tree node. The node represents a |
| * sash and it allways has two children. |
| */ |
| public class LayoutTreeNode extends LayoutTree { |
| |
| static class ChildSizes { |
| int left; |
| int right; |
| boolean resizable = true; |
| |
| public ChildSizes (int l, int r, boolean resize) { |
| left = l; |
| right = r; |
| resizable = resize; |
| } |
| } |
| |
| /* The node children witch may be another node or a leaf */ |
| private LayoutTree children[] = new LayoutTree[2]; |
| |
| /** |
| * Initialize this tree with its sash. |
| */ |
| public LayoutTreeNode(LayoutPartSash sash) { |
| super(sash); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.LayoutTree#flushChildren() |
| */ |
| public void flushChildren() { |
| super.flushChildren(); |
| |
| children[0].flushChildren(); |
| children[1].flushChildren(); |
| } |
| |
| /** |
| * Traverses the tree to find the part that intersects the given point |
| * |
| * @param toFind |
| * @return the part that intersects the given point |
| */ |
| public LayoutPart findPart(Point toFind) { |
| if (!children[0].isVisible()) { |
| if (!children[1].isVisible()) { |
| return null; |
| } |
| |
| return children[1].findPart(toFind); |
| } else { |
| if (!children[1].isVisible()) { |
| return children[0].findPart(toFind); |
| } |
| } |
| |
| LayoutPartSash sash = getSash(); |
| |
| Rectangle bounds = sash.getBounds(); |
| |
| if (sash.isVertical()) { |
| if (toFind.x < bounds.x + (bounds.width / 2)) { |
| return children[0].findPart(toFind); |
| } |
| return children[1].findPart(toFind); |
| } else { |
| if (toFind.y < bounds.y + (bounds.height / 2)) { |
| return children[0].findPart(toFind); |
| } |
| return children[1].findPart(toFind); |
| } |
| } |
| |
| /** |
| * Add the relation ship between the children in the list |
| * and returns the left children. |
| */ |
| public LayoutPart computeRelation(ArrayList relations) { |
| PartSashContainer.RelationshipInfo r = new PartSashContainer.RelationshipInfo(); |
| r.relative = children[0].computeRelation(relations); |
| r.part = children[1].computeRelation(relations); |
| r.left = getSash().getLeft(); |
| r.right = getSash().getRight(); |
| r.relationship = getSash().isVertical() ? IPageLayout.RIGHT |
| : IPageLayout.BOTTOM; |
| relations.add(0, r); |
| return r.relative; |
| } |
| |
| /** |
| * Dispose all Sashs in this tree |
| */ |
| public void disposeSashes() { |
| children[0].disposeSashes(); |
| children[1].disposeSashes(); |
| getSash().dispose(); |
| } |
| |
| /** |
| * Find a LayoutPart in the tree and return its sub-tree. Returns |
| * null if the child is not found. |
| */ |
| public LayoutTree find(LayoutPart child) { |
| LayoutTree node = children[0].find(child); |
| if (node != null) { |
| return node; |
| } |
| node = children[1].find(child); |
| return node; |
| } |
| |
| /** |
| * Find the part that is in the bottom right position. |
| */ |
| public LayoutPart findBottomRight() { |
| if (children[1].isVisible()) { |
| return children[1].findBottomRight(); |
| } |
| return children[0].findBottomRight(); |
| } |
| |
| /** |
| * Go up in the tree finding a parent that is common of both children. |
| * Return the subtree. |
| */ |
| public LayoutTreeNode findCommonParent(LayoutPart child1, LayoutPart child2) { |
| return findCommonParent(child1, child2, false, false); |
| } |
| |
| /** |
| * Go up in the tree finding a parent that is common of both children. |
| * Return the subtree. |
| */ |
| LayoutTreeNode findCommonParent(LayoutPart child1, LayoutPart child2, |
| boolean foundChild1, boolean foundChild2) { |
| if (!foundChild1) { |
| foundChild1 = find(child1) != null; |
| } |
| if (!foundChild2) { |
| foundChild2 = find(child2) != null; |
| } |
| if (foundChild1 && foundChild2) { |
| return this; |
| } |
| if (parent == null) { |
| return null; |
| } |
| return parent |
| .findCommonParent(child1, child2, foundChild1, foundChild2); |
| } |
| |
| /** |
| * Find a sash in the tree and return its sub-tree. Returns |
| * null if the sash is not found. |
| */ |
| public LayoutTreeNode findSash(LayoutPartSash sash) { |
| if (this.getSash() == sash) { |
| return this; |
| } |
| LayoutTreeNode node = children[0].findSash(sash); |
| if (node != null) { |
| return node; |
| } |
| node = children[1].findSash(sash); |
| if (node != null) { |
| return node; |
| } |
| return null; |
| } |
| |
| /** |
| * Sets the elements in the array of sashes with the |
| * Left,Rigth,Top and Botton sashes. The elements |
| * may be null depending whether there is a shash |
| * beside the <code>part</code> |
| */ |
| void findSashes(LayoutTree child, PartPane.Sashes sashes) { |
| Sash sash = (Sash) getSash().getControl(); |
| boolean leftOrTop = children[0] == child; |
| if (sash != null) { |
| LayoutPartSash partSash = getSash(); |
| //If the child is in the left, the sash |
| //is in the rigth and so on. |
| if (leftOrTop) { |
| if (partSash.isVertical()) { |
| if (sashes.right == null) { |
| sashes.right = sash; |
| } |
| } else { |
| if (sashes.bottom == null) { |
| sashes.bottom = sash; |
| } |
| } |
| } else { |
| if (partSash.isVertical()) { |
| if (sashes.left == null) { |
| sashes.left = sash; |
| } |
| } else { |
| if (sashes.top == null) { |
| sashes.top = sash; |
| } |
| } |
| } |
| } |
| if (getParent() != null) { |
| getParent().findSashes(this, sashes); |
| } |
| } |
| |
| /** |
| * Returns the sash of this node. |
| */ |
| public LayoutPartSash getSash() { |
| return (LayoutPartSash) part; |
| } |
| |
| private int getSashSize() { |
| return getSash().getSashSize(); |
| } |
| |
| /** |
| * Returns true if this tree has visible parts otherwise returns false. |
| */ |
| public boolean isVisible() { |
| return children[0].isVisible() || children[1].isVisible(); |
| } |
| |
| /** |
| * Remove the child and this node from the tree |
| */ |
| LayoutTree remove(LayoutTree child) { |
| getSash().dispose(); |
| if (parent == null) { |
| //This is the root. Return the other child to be the new root. |
| if (children[0] == child) { |
| children[1].setParent(null); |
| return children[1]; |
| } |
| children[0].setParent(null); |
| return children[0]; |
| } |
| |
| LayoutTreeNode oldParent = parent; |
| if (children[0] == child) { |
| oldParent.replaceChild(this, children[1]); |
| } else { |
| oldParent.replaceChild(this, children[0]); |
| } |
| return oldParent; |
| } |
| |
| /** |
| * Replace a child with a new child and sets the new child's parent. |
| */ |
| void replaceChild(LayoutTree oldChild, LayoutTree newChild) { |
| if (children[0] == oldChild) { |
| children[0] = newChild; |
| } else if (children[1] == oldChild) { |
| children[1] = newChild; |
| } |
| newChild.setParent(this); |
| if (!children[0].isVisible() || !children[0].isVisible()) { |
| getSash().dispose(); |
| } |
| |
| flushCache(); |
| } |
| |
| /** |
| * Go up from the subtree and return true if all the sash are |
| * in the direction specified by <code>isVertical</code> |
| */ |
| public boolean sameDirection(boolean isVertical, LayoutTreeNode subTree) { |
| boolean treeVertical = getSash().isVertical(); |
| if (treeVertical != isVertical) { |
| return false; |
| } |
| while (subTree != null) { |
| if (this == subTree) { |
| return true; |
| } |
| if (subTree.children[0].isVisible() |
| && subTree.children[1].isVisible()) { |
| if (subTree.getSash().isVertical() != isVertical) { |
| return false; |
| } |
| } |
| subTree = subTree.getParent(); |
| } |
| return true; |
| } |
| |
| public int doComputePreferredSize(boolean width, int availableParallel, int availablePerpendicular, int preferredParallel) { |
| assertValidSize(availablePerpendicular); |
| assertValidSize(availableParallel); |
| assertValidSize(preferredParallel); |
| |
| // If one child is invisible, defer to the other child |
| if (!children[0].isVisible()) { |
| return children[1].computePreferredSize(width, availableParallel, availablePerpendicular, preferredParallel); |
| } |
| |
| if (!children[1].isVisible()) { |
| return children[0].computePreferredSize(width, availableParallel, availablePerpendicular, preferredParallel); |
| } |
| |
| if (availableParallel == 0) { |
| return 0; |
| } |
| |
| // If computing the dimension perpendicular to our sash |
| if (width == getSash().isVertical()) { |
| // Compute the child sizes |
| ChildSizes sizes = computeChildSizes(availableParallel, availablePerpendicular, |
| getSash().getLeft(), getSash().getRight(), preferredParallel); |
| |
| // Return the sum of the child sizes plus the sash size |
| return add(sizes.left, add(sizes.right, getSashSize())); |
| } else { |
| // Computing the dimension parallel to the sash. We will compute and return the preferred size |
| // of whichever child is closest to the ideal size. |
| |
| ChildSizes sizes; |
| // First compute the dimension of the child sizes perpendicular to the sash |
| sizes = computeChildSizes(availablePerpendicular, availableParallel, |
| getSash().getLeft(), getSash().getRight(), availablePerpendicular); |
| |
| // Use this information to compute the dimension of the child sizes parallel to the sash. |
| // Return the preferred size of whichever child is largest |
| int leftSize = children[0].computePreferredSize(width, availableParallel, sizes.left, preferredParallel); |
| |
| // Compute the preferred size of the right child |
| int rightSize = children[1].computePreferredSize(width, availableParallel, sizes.right, preferredParallel); |
| |
| // Return leftSize or rightSize: whichever one is largest |
| int result = rightSize; |
| if (leftSize > rightSize) { |
| result = leftSize; |
| } |
| |
| assertValidSize(result); |
| |
| return result; |
| } |
| } |
| |
| /** |
| * Computes the pixel sizes of this node's children, given the available |
| * space for this node. Note that "width" and "height" actually refer |
| * to the distance perpendicular and parallel to the sash respectively. |
| * That is, their meaning is reversed when computing a horizontal sash. |
| * |
| * @param width the pixel width of a vertical node, or the pixel height |
| * of a horizontal node (INFINITE if unbounded) |
| * @param height the pixel height of a vertical node, or the pixel width |
| * of a horizontal node (INFINITE if unbounded) |
| * @return a struct describing the pixel sizes of the left and right children |
| * (this is a width for horizontal nodes and a height for vertical nodes) |
| */ |
| ChildSizes computeChildSizes(int width, int height, int left, int right, int preferredWidth) { |
| Assert.isTrue(children[0].isVisible()); |
| Assert.isTrue(children[1].isVisible()); |
| assertValidSize(width); |
| assertValidSize(height); |
| assertValidSize(preferredWidth); |
| Assert.isTrue(left >= 0); |
| Assert.isTrue(right >= 0); |
| Assert.isTrue(preferredWidth >= 0); |
| Assert.isTrue(preferredWidth <= width); |
| boolean vertical = getSash().isVertical(); |
| |
| if (width <= getSashSize()) { |
| return new ChildSizes(0,0, false); |
| } |
| |
| if (width == INFINITE) { |
| if (preferredWidth == INFINITE) { |
| return new ChildSizes(children[0].computeMaximumSize(vertical, height), |
| children[1].computeMaximumSize(vertical, height), false); |
| } |
| |
| if (preferredWidth == 0) { |
| return new ChildSizes(children[0].computeMinimumSize(vertical, height), |
| children[1].computeMinimumSize(vertical, height), false); |
| } |
| } |
| |
| int total = left + right; |
| |
| // Use all-or-none weighting |
| double wLeft = left, wRight = right; |
| switch (getCompressionBias()) { |
| case -1: |
| wLeft = 0.0; |
| break; |
| case 1: |
| wRight = 0.0; |
| break; |
| default: |
| break; |
| } |
| double wTotal = wLeft + wRight; |
| |
| // Subtract the SASH_WIDTH from preferredWidth and width. From here on, we'll deal with the |
| // width available to the controls and neglect the space used by the sash. |
| preferredWidth = Math.max(0, subtract(preferredWidth, getSashSize())); |
| width = Math.max(0, subtract(width, getSashSize())); |
| |
| int redistribute = subtract(preferredWidth, total); |
| |
| // Compute the minimum and maximum sizes for each child |
| int leftMinimum = children[0].computeMinimumSize(vertical, height); |
| int rightMinimum = children[1].computeMinimumSize(vertical, height); |
| int leftMaximum = children[0].computeMaximumSize(vertical, height); |
| int rightMaximum = children[1].computeMaximumSize(vertical, height); |
| |
| // Keep track of the available space for each child, given the minimum size of the other child |
| int leftAvailable = Math.min(leftMaximum, Math.max(0, subtract(width, rightMinimum))); |
| int rightAvailable = Math.min(rightMaximum, Math.max(0, subtract(width, leftMinimum))); |
| |
| // Figure out the ideal size of the left child |
| int idealLeft = Math.max(leftMinimum, Math.min(preferredWidth, |
| left + (int) Math.round(redistribute * wLeft / wTotal))); |
| |
| // If the right child can't use all its available space, let the left child fill it in |
| idealLeft = Math.max(idealLeft, preferredWidth - rightAvailable); |
| // Ensure the left child doesn't get larger than its available space |
| idealLeft = Math.min(idealLeft, leftAvailable); |
| |
| // Check if the left child would prefer to be a different size |
| idealLeft = children[0].computePreferredSize(vertical, leftAvailable, height, idealLeft); |
| |
| // Ensure that the left child is larger than its minimum size |
| idealLeft = Math.max(idealLeft, leftMinimum); |
| idealLeft = Math.min(idealLeft, leftAvailable); |
| |
| // Compute the right child width |
| int idealRight = Math.max(rightMinimum, preferredWidth - idealLeft); |
| |
| rightAvailable = Math.max(0, Math.min(rightAvailable, subtract(width, idealLeft))); |
| idealRight = Math.min(idealRight, rightAvailable); |
| idealRight = children[1].computePreferredSize(vertical, rightAvailable, height, idealRight); |
| idealRight = Math.max(idealRight, rightMinimum); |
| |
| return new ChildSizes(idealLeft, idealRight, leftMaximum > leftMinimum |
| && rightMaximum > rightMinimum |
| && leftMinimum + rightMinimum < width); |
| } |
| |
| protected int doGetSizeFlags(boolean width) { |
| if (!children[0].isVisible()) { |
| return children[1].getSizeFlags(width); |
| } |
| |
| if (!children[1].isVisible()) { |
| return children[0].getSizeFlags(width); |
| } |
| |
| int leftFlags = children[0].getSizeFlags(width); |
| int rightFlags = children[1].getSizeFlags(width); |
| |
| return ((leftFlags | rightFlags) & ~SWT.MAX) | (leftFlags & rightFlags & SWT.MAX); |
| } |
| |
| /** |
| * Resize the parts on this tree to fit in <code>bounds</code>. |
| */ |
| public void doSetBounds(Rectangle bounds) { |
| if (!children[0].isVisible()) { |
| children[1].setBounds(bounds); |
| getSash().setVisible(false); |
| return; |
| } |
| if (!children[1].isVisible()) { |
| children[0].setBounds(bounds); |
| getSash().setVisible(false); |
| return; |
| } |
| |
| bounds = Geometry.copy(bounds); |
| |
| boolean vertical = getSash().isVertical(); |
| |
| // If this is a horizontal sash, flip coordinate systems so |
| // that we can eliminate special cases |
| if (!vertical) { |
| Geometry.flipXY(bounds); |
| } |
| |
| ChildSizes childSizes = computeChildSizes(bounds.width, bounds.height, getSash().getLeft(), getSash().getRight(), bounds.width); |
| |
| getSash().setVisible(true); |
| getSash().setEnabled(childSizes.resizable); |
| |
| Rectangle leftBounds = new Rectangle(bounds.x, bounds.y, childSizes.left, bounds.height); |
| Rectangle sashBounds = new Rectangle(leftBounds.x + leftBounds.width, bounds.y, this.getSashSize(), bounds.height); |
| Rectangle rightBounds = new Rectangle(sashBounds.x + sashBounds.width, bounds.y, childSizes.right, bounds.height); |
| |
| if (!vertical) { |
| Geometry.flipXY(leftBounds); |
| Geometry.flipXY(sashBounds); |
| Geometry.flipXY(rightBounds); |
| } |
| |
| getSash().setBounds(sashBounds); |
| children[0].setBounds(leftBounds); |
| children[1].setBounds(rightBounds); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.LayoutTree#createControl(org.eclipse.swt.widgets.Composite) |
| */ |
| public void createControl(Composite parent) { |
| children[0].createControl(parent); |
| children[1].createControl(parent); |
| getSash().createControl(parent); |
| |
| super.createControl(parent); |
| } |
| |
| //Added by hudsonr@us.ibm.com - bug 19524 |
| |
| public boolean isCompressible() { |
| return children[0].isCompressible() || children[1].isCompressible(); |
| } |
| |
| /** |
| * Returns 0 if there is no bias. Returns -1 if the first child should be of |
| * fixed size, and the second child should be compressed. Returns 1 if the |
| * second child should be of fixed size. |
| * @return the bias |
| */ |
| public int getCompressionBias() { |
| boolean left = children[0].isCompressible(); |
| boolean right = children[1].isCompressible(); |
| if (left == right) { |
| return 0; |
| } |
| if (right) { |
| return -1; |
| } |
| return 1; |
| } |
| |
| boolean isLeftChild(LayoutTree toTest) { |
| return children[0] == toTest; |
| } |
| |
| LayoutTree getChild(boolean left) { |
| int index = left ? 0 : 1; |
| return (children[index]); |
| } |
| |
| /** |
| * Sets a child in this node |
| */ |
| void setChild(boolean left, LayoutPart part) { |
| LayoutTree child = new LayoutTree(part); |
| setChild(left, child); |
| flushCache(); |
| } |
| |
| /** |
| * Sets a child in this node |
| */ |
| void setChild(boolean left, LayoutTree child) { |
| int index = left ? 0 : 1; |
| children[index] = child; |
| child.setParent(this); |
| flushCache(); |
| } |
| |
| /** |
| * Returns a string representation of this object. |
| */ |
| public String toString() { |
| String s = "<null>\n";//$NON-NLS-1$ |
| if (part.getControl() != null) { |
| s = "<@" + part.getControl().hashCode() + ">\n";//$NON-NLS-2$//$NON-NLS-1$ |
| } |
| String result = "["; //$NON-NLS-1$ |
| if (children[0].getParent() != this) { |
| result = result + "{" + children[0] + "}" + s;//$NON-NLS-2$//$NON-NLS-1$ |
| } else { |
| result = result + children[0] + s; |
| } |
| |
| if (children[1].getParent() != this) { |
| result = result + "{" + children[1] + "}]";//$NON-NLS-2$//$NON-NLS-1$ |
| } else { |
| result = result + children[1] + "]";//$NON-NLS-1$ |
| } |
| return result; |
| } |
| |
| /** |
| * Create the sashes if the children are visible |
| * and dispose it if they are not. |
| */ |
| // public void updateSashes(Composite parent) { |
| // if (parent == null) |
| // return; |
| // children[0].updateSashes(parent); |
| // children[1].updateSashes(parent); |
| // if (children[0].isVisible() && children[1].isVisible()) |
| // getSash().createControl(parent); |
| // else |
| // getSash().dispose(); |
| // } |
| |
| /** |
| * Writes a description of the layout to the given string buffer. |
| * This is used for drag-drop test suites to determine if two layouts are the |
| * same. Like a hash code, the description should compare as equal iff the |
| * layouts are the same. However, it should be user-readable in order to |
| * help debug failed tests. Although these are english readable strings, |
| * they should not be translated or equality tests will fail. |
| * |
| * @param buf |
| */ |
| public void describeLayout(StringBuffer buf) { |
| if (!(children[0].isVisible())) { |
| if (!children[1].isVisible()) { |
| return; |
| } |
| |
| children[1].describeLayout(buf); |
| return; |
| } |
| |
| if (!children[1].isVisible()) { |
| children[0].describeLayout(buf); |
| return; |
| } |
| |
| buf.append("("); //$NON-NLS-1$ |
| children[0].describeLayout(buf); |
| |
| buf.append(getSash().isVertical() ? "|" : "-"); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| children[1].describeLayout(buf); |
| buf.append(")"); //$NON-NLS-1$ |
| } |
| |
| } |
