/*******************************************************************************
* Copyright (c) 2000, 2007 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
* Cagatay Kavukcuoglu <cagatayk@acm.org>
* - Fix for bug 10025 - Resizing views should not use height ratios
*******************************************************************************/
package org.eclipse.ui.internal;
import org.eclipse.ui.ISizeProvider;
/**
* A presentation part is used to build the presentation for the workbench.
* Common subclasses are pane and folder.
*/
abstract public class LayoutPart implements ISizeProvider {
// protected ILayoutContainer container;
//
// protected String id;
//
// public static final String PROP_VISIBILITY = "PROP_VISIBILITY"; //$NON-NLS-1$
//
// /**
// * Number of times deferUpdates(true) has been called without a
// * corresponding deferUpdates(false)
// */
// private int deferCount = 0;
//
// /**
// * PresentationPart constructor comment.
// */
// public LayoutPart(String id) {
// super();
// this.id = id;
// }
//
// /**
// * When a layout part closes, focus will return to a previously active
// part.
// * This method determines whether this part should be considered for
// * activation when another part closes. If a group of parts are all
// closing
// * at the same time, they will all return false from this method while
// * closing to ensure that the parent does not activate a part that is in
// the
// * process of closing. Parts will also return false from this method if
// they
// * are minimized, closed fast views, obscured by zoom, etc.
// *
// * @return true iff the parts in this container may be given focus when
// the
// * active part is closed
// */
// public boolean allowsAutoFocus() {
// if (container != null) {
// return container.allowsAutoFocus();
// }
// return true;
// }
//
// /**
// * Creates the SWT control
// */
// abstract public void createControl(Composite parent);
//
// /**
// * Disposes the SWT control
// */
// public void dispose() {
// }
//
// /**
// * Gets the presentation bounds.
// */
// public Rectangle getBounds() {
// return new Rectangle(0, 0, 0, 0);
// }
//
// /**
// * Gets the parent for this part.
// * <p>
// * In general, this is non-null if the object has been added to a
// container
// * and the container's widgetry exists. The exception to this rule is
// * PartPlaceholders created when restoring a ViewStack using restoreState,
// * which point to the ViewStack even if its widgetry doesn't exist yet.
// * Returns null in the remaining cases.
// * </p>
// * <p>
// * TODO: change the semantics of this method to always point to the parent
// * container, regardless of whether its widgetry exists. Locate and
// refactor
// * code that is currently depending on the special cases.
// * </p>
// */
// public ILayoutContainer getContainer() {
// return container;
// }
//
// /**
// * Get the part control. This method may return null.
// */
// abstract public Control getControl();
//
// /**
// * Gets the ID for this part.
// */
// public String getID() {
// return id;
// }
//
// /**
// * Returns the compound ID for this part. The compound ID is of the form:
// * primaryId [':' + secondaryId]
// *
// * @return the compound ID for this part.
// */
// public String getCompoundId() {
// return getID();
// }
//
// public boolean isCompressible() {
// return false;
// }
//
// /**
// * Gets the presentation size.
// */
// public Point getSize() {
// Rectangle r = getBounds();
// Point ptSize = new Point(r.width, r.height);
// return ptSize;
// }
//
// /**
// * @see
// org.eclipse.ui.presentations.StackPresentation#getSizeFlags(boolean)
// *
// * @since 3.1
// */
// public int getSizeFlags(boolean horizontal) {
// return SWT.MIN;
// }
//
// /**
// * @see
// org.eclipse.ui.presentations.StackPresentation#computePreferredSize(boolean,
// * int, int, int)
// *
// * @since 3.1
// */
// public int computePreferredSize(boolean width, int availableParallel,
// int availablePerpendicular, int preferredParallel) {
//
// return preferredParallel;
// }
//
// public IDropTarget getDropTarget(Object draggedObject,
// Point displayCoordinates) {
// return null;
// }
//
// public boolean isDocked() {
// Shell s = getShell();
// if (s == null) {
// return false;
// }
//
// return s.getData() instanceof IWorkbenchWindow;
// }
//
// public Shell getShell() {
// // Control ctrl = getControl();
// // if (!SwtUtil.isDisposed(ctrl)) {
// // return ctrl.getShell();
// // }
// return null;
// }
//
// /**
// * Returns the workbench window window for a part.
// *
// * @return the workbench window, or <code>null</code> if there's no window
// * associated with this part.
// */
// public IWorkbenchWindow getWorkbenchWindow() {
// // Shell s = getShell();
// // if (s == null) {
// // return null;
// // }
// // Object data = s.getData();
// // if (data instanceof IWorkbenchWindow) {
// // return (IWorkbenchWindow) data;
// // } else if (data instanceof DetachedWindow) {
// // return ((DetachedWindow) data).getWorkbenchPage()
// // .getWorkbenchWindow();
// // }
//
// return null;
//
// }
//
// /**
// * Move the control over another one.
// */
// public void moveAbove(Control refControl) {
// }
//
// /**
// * Reparent a part.
// */
// public void reparent(Composite newParent) {
// Control control = getControl();
// if ((control == null) || (control.getParent() == newParent)) {
// return;
// }
//
// if (control.isReparentable()) {
// // make control small in case it is not resized with other controls
// // control.setBounds(0, 0, 0, 0);
// // By setting the control to disabled before moving it,
// // we ensure that the focus goes away from the control and its
// // children
// // and moves somewhere else
// boolean enabled = control.getEnabled();
// control.setEnabled(false);
// control.setParent(newParent);
// control.setEnabled(enabled);
// control.moveAbove(null);
// }
// }
//
// /**
// * Returns true if this part was set visible. This returns whatever was
// last
// * passed into setVisible, but does not necessarily indicate that the part
// * can be seen (ie: one of its ancestors may be invisible)
// */
// public boolean getVisible() {
// // Control ctrl = getControl();
// // if (!SwtUtil.isDisposed(ctrl)) {
// // return ctrl.getVisible();
// // }
// return false;
// }
//
// /**
// * Returns true if this part can be seen. Returns false if the part or any
// * of its ancestors are invisible.
// */
// public boolean isVisible() {
// Control ctrl = getControl();
// if (ctrl != null && !ctrl.isDisposed()) {
// return ctrl.isVisible();
// }
// return false;
// }
//
// /**
// * Shows the receiver if <code>visible</code> is true otherwise hide it.
// */
// public void setVisible(boolean makeVisible) {
// Control ctrl = getControl();
// // if (!SwtUtil.isDisposed(ctrl)) {
// // if (makeVisible == ctrl.getVisible()) {
// // return;
// // }
// //
// // if (!makeVisible && isFocusAncestor(ctrl)) {
// // // Workaround for Bug 60970 [EditorMgmt] setActive() called on
// // // an editor when it does not have focus.
// // // Force focus on the shell so that when ctrl is hidden,
// // // SWT does not try to send focus elsewhere, which may cause
// // // some other part to be activated, which affects the part
// // // activation order and can cause flicker.
// // ctrl.getShell().forceFocus();
// // }
// //
// // ctrl.setVisible(makeVisible);
// // }
// }
//
// /**
// * Returns <code>true</code> if the given control or any of its
// descendents
// * has focus.
// */
// private boolean isFocusAncestor(Control ctrl) {
// Control f = ctrl.getDisplay().getFocusControl();
// while (f != null && f != ctrl) {
// f = f.getParent();
// }
// return f == ctrl;
// }
//
// /**
// * Sets the presentation bounds.
// */
// public void setBounds(Rectangle r) {
// // Control ctrl = getControl();
// // if (!SwtUtil.isDisposed(ctrl)) {
// // ctrl.setBounds(r);
// // }
// }
//
// /**
// * Sets the parent for this part.
// */
// public void setContainer(ILayoutContainer container) {
//
// this.container = container;
//
// if (container != null) {
// setZoomed(container.childIsZoomed(this));
// }
// }
//
// /**
// * Sets focus to this part.
// */
// public void setFocus() {
// }
//
// /**
// * Sets the part ID.
// */
// public void setID(String str) {
// id = str;
// }
//
// /*
// * (non-Javadoc)
// *
// * @see org.eclipse.ui.internal.IWorkbenchDragDropPart#getPart()
// */
// public LayoutPart getPart() {
// return this;
// }
//
// public void childRequestZoomIn(LayoutPart toZoom) {
//
// }
//
// public void childRequestZoomOut() {
//
// }
//
// public final void requestZoomOut() {
// ILayoutContainer container = getContainer();
// if (container != null) {
// container.childRequestZoomOut();
// }
// }
//
// public final void requestZoomIn() {
// ILayoutContainer container = getContainer();
// if (container != null) {
// container.childRequestZoomIn(this);
// }
// }
//
// public final boolean isObscuredByZoom() {
// ILayoutContainer container = getContainer();
//
// if (container != null) {
// return container.childObscuredByZoom(this);
// }
//
// return false;
// }
//
// public boolean childObscuredByZoom(LayoutPart toTest) {
// return false;
// }
//
// public boolean childIsZoomed(LayoutPart childToTest) {
// return false;
// }
//
// public void setZoomed(boolean isZoomed) {
//
// }
//
// /**
// * deferUpdates(true) disables widget updates until a corresponding call
// to
// * deferUpdates(false). Exactly what gets deferred is the decision of each
// * LayoutPart, however the part may only defer operations in a manner that
// * does not affect the final result. That is, the state of the receiver
// * after the final call to deferUpdates(false) must be exactly the same as
// * it would have been if nothing had been deferred.
// *
// * @param shouldDefer
// * true iff events should be deferred
// */
// public final void deferUpdates(boolean shouldDefer) {
// if (shouldDefer) {
// if (deferCount == 0) {
// startDeferringEvents();
// }
// deferCount++;
// } else {
// if (deferCount > 0) {
// deferCount--;
// if (deferCount == 0) {
// handleDeferredEvents();
// }
// }
// }
// }
//
// /**
// * This is called when deferUpdates(true) causes UI events for this part
// to
// * be deferred. Subclasses can overload to initialize any data structures
// * that they will use to collect deferred events.
// */
// protected void startDeferringEvents() {
//
// }
//
// /**
// * Immediately processes all UI events which were deferred due to a call
// to
// * deferUpdates(true). This is called when the last call is made to
// * deferUpdates(false). Subclasses should overload this method if they
// defer
// * some or all UI processing during deferUpdates.
// */
// protected void handleDeferredEvents() {
//
// }
//
// /**
// * Subclasses can call this method to determine whether UI updates should
// be
// * deferred. Returns true iff there have been any calls to
// * deferUpdates(true) without a corresponding call to deferUpdates(false).
// * Any operation which is deferred based on the result of this method
// should
// * be performed later within handleDeferredEvents().
// *
// * @return true iff updates should be deferred.
// */
// protected final boolean isDeferred() {
// return deferCount > 0;
// }
//
// /**
// * 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 do not
// * need to be translated.
// *
// * @param buf
// */
// public void describeLayout(StringBuffer buf) {
//
// }
//
// /**
// * Returns an id representing this part, suitable for use in a
// placeholder.
// *
// * @since 3.0
// */
// public String getPlaceHolderId() {
// return getID();
// }
//
// public void resizeChild(LayoutPart childThatChanged) {
//
// }
//
// public void flushLayout() {
// ILayoutContainer container = getContainer();
// if (getContainer() != null) {
// container.resizeChild(this);
// }
// }
//
// /**
// * Returns true iff the given part can be added to this ILayoutContainer
// *
// * @param toAdd
// * @return
// * @since 3.1
// */
// public boolean allowsAdd(LayoutPart toAdd) {
// return false;
// }
//
// /**
// * Tests the integrity of this object. Throws an exception if the object's
// * state is not internally consistent. For use in test suites.
// */
// public void testInvariants() {
// }
}