/*******************************************************************************
* 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.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.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.ISizeProvider;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.internal.dnd.IDropTarget;
import org.eclipse.ui.internal.dnd.SwtUtil;
/**
* 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() {
}
}