org.eclipse.ui.internal.LayoutPart Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of workbench Show documentation
Show all versions of workbench Show documentation
This plug-in contains the bulk of the Workbench implementation, and depends on JFace, SWT, and Core Runtime. It cannot be used independently from org.eclipse.ui. Workbench client plug-ins should not depend directly on this plug-in.
The newest version!
/*******************************************************************************
* 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
* - 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.
*
* 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.
*
*
* 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.
*
*/
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 null 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 visible 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 true 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() {
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy