org.eclipse.swt.widgets.Shell Maven / Gradle / Ivy
/*******************************************************************************
* Copyright (c) 2002, 2012 Innoopract Informationssysteme GmbH 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:
* Innoopract Informationssysteme GmbH - initial API and implementation
* EclipseSource - ongoing development
* Rüdiger Herrmann - bug 335112
******************************************************************************/
package org.eclipse.swt.widgets;
import org.eclipse.rap.rwt.internal.theme.IThemeAdapter;
import org.eclipse.rap.rwt.lifecycle.ProcessActionRunner;
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.events.ShellListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.internal.widgets.IDisplayAdapter;
import org.eclipse.swt.internal.widgets.IShellAdapter;
import org.eclipse.swt.internal.widgets.MenuHolder;
import org.eclipse.swt.internal.widgets.shellkit.ShellThemeAdapter;
/**
* Instances of this class represent the "windows"
* which the desktop or "window manager" is managing.
* Instances that do not have a parent (that is, they
* are built using the constructor, which takes a
* Display as the argument) are described
* as top level shells. Instances that do have
* a parent are described as secondary or
* dialog shells.
*
* Instances are always displayed in one of the maximized,
* minimized or normal states:
*
* -
* When an instance is marked as maximized, the
* window manager will typically resize it to fill the
* entire visible area of the display, and the instance
* is usually put in a state where it can not be resized
* (even if it has style
RESIZE) until it is
* no longer maximized.
* -
* When an instance is in the normal state (neither
* maximized or minimized), its appearance is controlled by
* the style constants which were specified when it was created
* and the restrictions of the window manager (see below).
*
-
* When an instance has been marked as minimized,
* its contents (client area) will usually not be visible,
* and depending on the window manager, it may be
* "iconified" (that is, replaced on the desktop by a small
* simplified representation of itself), relocated to a
* distinguished area of the screen, or hidden. Combinations
* of these changes are also possible.
*
*
*
* The modality of an instance may be specified using
* style bits. The modality style bits are used to determine
* whether input is blocked for other shells on the display.
* The PRIMARY_MODAL style allows an instance to block
* input to its parent. The APPLICATION_MODAL style
* allows an instance to block input to every other shell in the
* display. The SYSTEM_MODAL style allows an instance
* to block input to all shells, including shells belonging to
* different applications.
*
* Note: The styles supported by this class are treated
* as HINTs, since the window manager for the
* desktop on which the instance is visible has ultimate
* control over the appearance and behavior of decorations
* and modality. For example, some window managers only
* support resizable windows and will always assume the
* RESIZE style, even if it is not set. In addition, if a
* modality style is not supported, it is "upgraded" to a
* more restrictive modality style that is supported. For
* example, if PRIMARY_MODAL is not supported,
* it would be upgraded to APPLICATION_MODAL.
* A modality style may also be "downgraded" to a less
* restrictive style. For example, most operating systems
* no longer support SYSTEM_MODAL because
* it can freeze up the desktop, so this is typically
* downgraded to APPLICATION_MODAL.
*
* - Styles:
* - BORDER, CLOSE, MIN, MAX, NO_TRIM, RESIZE, TITLE, ON_TOP, TOOL, SHEET
* - APPLICATION_MODAL, MODELESS, PRIMARY_MODAL, SYSTEM_MODAL
* - Events:
* - Activate, Close, Deactivate, Deiconify, Iconify
*
* Class SWT provides two "convenience constants"
* for the most commonly required style combinations:
*
* SHELL_TRIM-
* the result of combining the constants which are required
* to produce a typical application top level shell: (that
* is,
CLOSE | TITLE | MIN | MAX | RESIZE)
*
* DIALOG_TRIM-
* the result of combining the constants which are required
* to produce a typical application dialog shell: (that
* is,
TITLE | CLOSE | BORDER)
*
*
*
*
* Note: Only one of the styles APPLICATION_MODAL, MODELESS,
* PRIMARY_MODAL and SYSTEM_MODAL may be specified.
*
* IMPORTANT: This class is not intended to be subclassed.
*
*
* @see SWT
*/
public class Shell extends Decorations {
private static final int MODE_NONE = 0;
private static final int MODE_MAXIMIZED = 1;
private static final int MODE_MINIMIZED = 2;
private static final int MODE_FULLSCREEN = 4;
private static final int INITIAL_SIZE_PERCENT = 60;
private static final int MIN_WIDTH_LIMIT = 80;
private class ShellAdapter implements IShellAdapter {
public Control getActiveControl() {
return Shell.this.lastActive;
}
public void setActiveControl( Control control ) {
Shell.this.setActiveControl( control );
}
public Rectangle getMenuBounds() {
return Shell.this.getMenuBounds();
}
public void setBounds( Rectangle bounds ) {
Shell.this.setBounds( bounds, false );
}
public ToolTip[] getToolTips() {
return Shell.this.getToolTips();
}
}
private Control lastActive;
private transient IShellAdapter shellAdapter;
private String text;
private int alpha;
private Button defaultButton;
private Button saveDefault;
private Control savedFocus; // TODO [rh] move to Decorations when exist
private Rectangle savedBounds;
private int mode;
private boolean modified;
private int minWidth;
private int minHeight;
private ToolTip[] toolTips;
private Shell( Display display, Shell parent, int style, int handle ) {
super( checkParent( parent ) );
if( display != null ) {
this.display = display;
} else {
this.display = Display.getCurrent();
if( this.display == null ) {
this.display = Display.getDefault();
}
}
text = "";
alpha = 0xFF;
mode = MODE_NONE;
this.style = checkStyle( style );
state |= HIDDEN;
minWidth = MIN_WIDTH_LIMIT;
minHeight = getMinHeightLimit();
this.display.addShell( this );
reskinWidget();
createWidget();
setInitialSize();
}
/**
* Constructs a new instance of this class. This is equivalent
* to calling Shell((Display) null).
*
* @exception SWTException
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent
* - ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass
*
*
* @since 1.3
*/
public Shell() {
this( ( Display )null );
}
/**
* Constructs a new instance of this class given only the style value
* describing its behavior and appearance. This is equivalent to calling
* Shell((Display) null, style).
*
* The style value is either one of the style constants defined in class
* SWT which is applicable to instances of this class, or must
* be built by bitwise OR'ing together (that is, using the
* int "|" operator) two or more of those SWT
* style constants. The class description lists the style constants that are
* applicable to the class. Style bits are also inherited from superclasses.
*
*
* @param style the style of control to construct
* @exception SWTException
*
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the parent
* - ERROR_INVALID_SUBCLASS - if this class is not an
* allowed subclass
*
* @see SWT#BORDER
* @see SWT#CLOSE
* @see SWT#MIN
* @see SWT#MAX
* @see SWT#RESIZE
* @see SWT#TITLE
* @see SWT#NO_TRIM
* @see SWT#SHELL_TRIM
* @see SWT#DIALOG_TRIM
*
*
* @see SWT#APPLICATION_MODAL
*
* @see SWT#SHEET
*/
public Shell( int style ) {
this( ( Display )null, style );
}
/**
* Constructs a new instance of this class given only the display
* to create it on. It is created with style SWT.SHELL_TRIM.
*
* Note: Currently, null can be passed in for the display argument.
* This has the effect of creating the shell on the currently active
* display if there is one. If there is no current display, the
* shell is created on a "default" display. Passing in null as
* the display argument is not considered to be good coding style,
* and may not be supported in a future release of SWT.
*
*
* @param display the display to create the shell on
*
* @exception SWTException
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent
* - ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass
*
*/
public Shell( Display display ) {
this( display, SWT.SHELL_TRIM );
}
/**
* Constructs a new instance of this class given the display
* to create it on and a style value describing its behavior
* and appearance.
*
* The style value is either one of the style constants defined in
* class SWT which is applicable to instances of this
* class, or must be built by bitwise OR'ing together
* (that is, using the int "|" operator) two or more
* of those SWT style constants. The class description
* lists the style constants that are applicable to the class.
* Style bits are also inherited from superclasses.
*
* Note: Currently, null can be passed in for the display argument.
* This has the effect of creating the shell on the currently active
* display if there is one. If there is no current display, the
* shell is created on a "default" display. Passing in null as
* the display argument is not considered to be good coding style,
* and may not be supported in a future release of SWT.
*
*
* @param display the display to create the shell on
* @param style the style of control to construct
*
* @exception SWTException
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent
* - ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass
*
*
* @see SWT#BORDER
* @see SWT#CLOSE
* @see SWT#MIN
* @see SWT#MAX
* @see SWT#RESIZE
* @see SWT#TITLE
* @see SWT#NO_TRIM
* @see SWT#SHELL_TRIM
* @see SWT#DIALOG_TRIM
* @see SWT#MODELESS
* @see SWT#PRIMARY_MODAL
* @see SWT#APPLICATION_MODAL
* @see SWT#SYSTEM_MODAL
* @see SWT#SHEET
*/
public Shell( Display display, int style ) {
this( display, null, style, 0 );
}
/**
* Constructs a new instance of this class given only its
* parent. It is created with style SWT.DIALOG_TRIM.
*
* Note: Currently, null can be passed in for the parent.
* This has the effect of creating the shell on the currently active
* display if there is one. If there is no current display, the
* shell is created on a "default" display. Passing in null as
* the parent is not considered to be good coding style,
* and may not be supported in a future release of SWT.
*
*
* @param parent a shell which will be the parent of the new instance
*
* @exception IllegalArgumentException
* - ERROR_INVALID_ARGUMENT - if the parent is disposed
*
* @exception SWTException
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent
* - ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass
*
*/
public Shell( Shell parent ) {
this( parent, SWT.DIALOG_TRIM );
}
/**
* Constructs a new instance of this class given its parent
* and a style value describing its behavior and appearance.
*
* The style value is either one of the style constants defined in
* class SWT which is applicable to instances of this
* class, or must be built by bitwise OR'ing together
* (that is, using the int "|" operator) two or more
* of those SWT style constants. The class description
* lists the style constants that are applicable to the class.
* Style bits are also inherited from superclasses.
*
* Note: Currently, null can be passed in for the parent.
* This has the effect of creating the shell on the currently active
* display if there is one. If there is no current display, the
* shell is created on a "default" display. Passing in null as
* the parent is not considered to be good coding style,
* and may not be supported in a future release of SWT.
*
*
* @param parent a shell which will be the parent of the new instance
* @param style the style of control to construct
*
* @exception IllegalArgumentException
* - ERROR_INVALID_ARGUMENT - if the parent is disposed
*
* @exception SWTException
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent
* - ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass
*
*
* @see SWT#BORDER
* @see SWT#CLOSE
* @see SWT#MIN
* @see SWT#MAX
* @see SWT#RESIZE
* @see SWT#TITLE
* @see SWT#NO_TRIM
* @see SWT#SHELL_TRIM
* @see SWT#DIALOG_TRIM
* @see SWT#ON_TOP
* @see SWT#TOOL
* @see SWT#SHEET
*
*
* @see SWT#APPLICATION_MODAL
*
*/
public Shell( Shell parent, int style ) {
this( parent != null ? parent.display : null, parent, style, 0 );
}
@Override
Shell internalGetShell() {
return this;
}
/**
* Returns an array containing all shells which are
* descendents of the receiver.
*
* @return the dialog shells
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*/
public Shell[] getShells() {
checkWidget();
return internalGetShells();
}
private Shell[] internalGetShells() {
int count = 0;
Shell[] shells = display.getShells();
for( int i = 0; i < shells.length; i++ ) {
Control shell = shells[ i ];
do {
shell = shell.parent;
} while( shell != null && shell != this );
if( shell == this ) {
count++;
}
}
int index = 0;
Shell[] result = new Shell[ count ];
for( int i = 0; i < shells.length; i++ ) {
Control shell = shells[ i ];
do {
shell = shell.parent;
} while( shell != null && shell != this );
if( shell == this ) {
result[ index++ ] = shells[ i ];
}
}
return result;
}
/**
* If the receiver is visible, moves it to the top of the
* drawing order for the display on which it was created
* (so that all other shells on that display, which are not
* the receiver's children will be drawn behind it) and asks
* the window manager to make the shell active
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @see Control#moveAbove
* @see Control#setFocus
* @see Control#setVisible
* @see Display#getActiveShell
*
* @see Shell#setDefaultButton(Button)
* @see Shell#open
* @see Shell#setActive
*/
public void setActive() {
checkWidget();
if( isVisible() ) {
display.setActiveShell( this );
}
}
/**
* If the receiver is visible, moves it to the top of the drawing order for
* the display on which it was created (so that all other shells on that
* display, which are not the receiver's children will be drawn behind it) and
* forces the window manager to make the shell active.
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that
* created the receiver
*
* @since 1.2
* @see Control#moveAbove
* @see Control#setFocus
* @see Control#setVisible
* @see Display#getActiveShell
*
* @see Shell#open
* @see Shell#setActive
*/
public void forceActive() {
checkWidget();
setActive();
}
/////////////////////
// Shell measurements
// TODO [rst] Move to class Decorations, as soon as it exists
@Override
public Rectangle getClientArea() {
checkWidget();
Rectangle bounds = getBounds();
Rectangle padding = getPadding();
int hTopTrim;
hTopTrim = getTitleBarMargin().height;
hTopTrim += getTitleBarHeight();
hTopTrim += getMenuBarHeight();
int border = getBorderWidth();
return new Rectangle( padding.x,
hTopTrim + padding.y,
bounds.width - padding.width - border * 2,
bounds.height - hTopTrim - padding.height - border * 2 );
}
// TODO [rst] Move to class Decorations, as soon as it exists
@Override
public Rectangle computeTrim( int x, int y, int width, int height ) {
checkWidget();
int hTopTrim;
hTopTrim = getTitleBarMargin().height;
hTopTrim += getTitleBarHeight();
hTopTrim += getMenuBarHeight();
Rectangle padding = getPadding();
int border = getBorderWidth();
Rectangle rect = new Rectangle( x - padding.x - border,
y - hTopTrim - padding.y - border,
width + padding.width + border * 2,
height + hTopTrim + padding.height + border * 2 );
return rect;
}
private void setInitialSize() {
int width = display.getBounds().width * INITIAL_SIZE_PERCENT / 100;
int height = display.getBounds().height * INITIAL_SIZE_PERCENT / 100;
bounds = new Rectangle( 0, 0, width, height );
}
private int getMinHeightLimit() {
int result = getTitleBarMargin().height;
result += getTitleBarHeight();
result += 2 * getBorderWidth();
return result;
}
private Rectangle getMenuBounds() {
Rectangle result = null;
if( getMenuBar() == null ) {
result = new Rectangle( 0, 0, 0, 0 );
} else {
Rectangle bounds = getBounds();
int hTop = ( style & SWT.TITLE ) != 0 ? 1 : 0;
hTop += getTitleBarHeight();
Rectangle padding = getPadding();
int border = getBorderWidth();
result = new Rectangle( padding.x,
hTop + padding.y,
bounds.width - padding.width - border * 2,
getMenuBarHeight() );
}
return result;
}
@Override
public int getBorderWidth() {
return getFullScreen() ? 0 : super.getBorderWidth();
}
private int getTitleBarHeight() {
int result = 0;
if( !getFullScreen() ) {
ShellThemeAdapter themeAdapter = ( ShellThemeAdapter )getAdapter( IThemeAdapter.class );
result = themeAdapter.getTitleBarHeight( this );
}
return result;
}
private Rectangle getTitleBarMargin() {
Rectangle result = new Rectangle( 0, 0, 0, 0 );
if( !getFullScreen() ) {
ShellThemeAdapter themeAdapter = ( ShellThemeAdapter )getAdapter( IThemeAdapter.class );
result = themeAdapter.getTitleBarMargin( this );
}
return result;
}
private int getMenuBarHeight() {
ShellThemeAdapter themeAdapter = ( ShellThemeAdapter )getAdapter( IThemeAdapter.class );
return themeAdapter.getMenuBarHeight( this );
}
@Override
Composite findDeferredControl() {
return layoutCount > 0 ? this : null;
}
@Override
void updateMode() {
mode &= ~MODE_MAXIMIZED;
mode &= ~MODE_MINIMIZED;
mode &= ~MODE_FULLSCREEN;
}
/////////////////////
// Adaptable override
@Override
@SuppressWarnings("unchecked")
public T getAdapter( Class adapter ) {
T result;
if( adapter == IShellAdapter.class ) {
if( shellAdapter == null ) {
shellAdapter = new ShellAdapter();
}
result = ( T )shellAdapter;
} else {
result = super.getAdapter( adapter );
}
return result;
}
/////////////
// Enablement
@Override
public void setEnabled( boolean enabled ) {
checkWidget();
if( getEnabled() != enabled ) {
super.setEnabled( enabled );
if( enabled ) {
if( !restoreFocus() ) {
traverseGroup( true );
}
}
}
}
@Override
public boolean isEnabled() {
checkWidget();
return getEnabled();
}
/////////////
// Visibility
@Override
public boolean isVisible() {
checkWidget();
return getVisible();
}
@Override
public void setVisible( boolean visible ) {
checkWidget();
boolean wasVisible = getVisible();
super.setVisible( visible );
// Emulate OS behavior: in SWT, a layout is triggered during
// Shell#setVisible(true)
if( visible && !wasVisible && !isDisposed() ) {
changed( getChildren() );
layout( true, true );
}
}
/**
* Moves the receiver to the top of the drawing order for
* the display on which it was created (so that all other
* shells on that display, which are not the receiver's
* children will be drawn behind it), marks it visible,
* sets the focus and asks the window manager to make the
* shell active.
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @see Control#moveAbove
* @see Control#setFocus
* @see Control#setVisible
* @see Display#getActiveShell
*
* @see Shell#setDefaultButton(Button)
* @see Shell#setActive
* @see Shell#forceActive
*/
public void open() {
checkWidget();
// Order of setActiveShell/bringToTop/setVisible is crucial
display.setActiveShell( this );
bringToTop();
setVisible( true );
if( !restoreFocus() && !traverseGroup( true ) ) {
setFocus();
}
}
/**
* Requests that the window manager close the receiver in
* the same way it would be closed when the user clicks on
* the "close box" or performs some other platform specific
* key or mouse combination that indicates the window
* should be removed.
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @see SWT#Close
* @see Shell#dispose()
*/
public void close() {
checkWidget();
ProcessActionRunner.add( new Runnable() {
public void run() {
Event event = new Event();
notifyListeners( SWT.Close, event );
if( event.doit ) {
Shell.this.dispose();
}
}
} );
}
///////////////////////////
// Title bar text and image
/**
* Sets the receiver's text, which is the string that the
* window manager will typically display as the receiver's
* title, to the argument, which must not be null.
*
* @param text the new text
*
* @exception IllegalArgumentException
* - ERROR_NULL_ARGUMENT - if the text is null
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*/
// TODO [rh] move to Decorations
public void setText( String text ) {
checkWidget();
if( text == null ) {
error( SWT.ERROR_NULL_ARGUMENT );
}
this.text = text;
}
/**
* Returns the receiver's text, which is the string that the
* window manager will typically display as the receiver's
* title. If the text has not previously been set,
* returns an empty string.
*
* @return the text
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*/
// TODO [rh] move to Decorations
public String getText() {
checkWidget();
return text;
}
//////////////////////////////
// Methods for default button
/**
* If the argument is not null, sets the receiver's default
* button to the argument, and if the argument is null, sets
* the receiver's default button to the first button which
* was set as the receiver's default button (called the
* saved default button). If no default button had
* previously been set, or the saved default button was
* disposed, the receiver's default button will be set to
* null.
*
* The default button is the button that is selected when
* the receiver is active and the user presses ENTER.
*
*
* @param button the new default button
*
* @exception IllegalArgumentException
* - ERROR_INVALID_ARGUMENT - if the button has been disposed
* - ERROR_INVALID_PARENT - if the control is not in the same widget tree
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*/
// TODO [rst] move to class Decorations as soon as it exists
public void setDefaultButton( Button button ) {
checkWidget();
if( button != null ) {
if( button.isDisposed() ) {
error( SWT.ERROR_INVALID_ARGUMENT );
}
if( button.getShell() != this ) {
error( SWT.ERROR_INVALID_PARENT );
}
}
setDefaultButton( button, true );
}
// TODO [rst] move to class Decorations as soon as it exists
void setDefaultButton( Button button, boolean save ) {
if( button == null ) {
if( defaultButton == saveDefault ) {
if( save ) {
saveDefault = null;
}
return;
}
} else {
if( ( button.getStyle() & SWT.PUSH ) == 0 ) {
return;
}
if( button == defaultButton ) {
if( save ) {
saveDefault = defaultButton;
}
return;
}
}
if( defaultButton != null && !defaultButton.isDisposed() ) {
defaultButton.setDefault( false );
}
defaultButton = button;
if( defaultButton == null ) {
defaultButton = saveDefault;
}
if( defaultButton != null && !defaultButton.isDisposed() ) {
defaultButton.setDefault( true );
}
if( save ) {
saveDefault = defaultButton;
}
if( saveDefault != null && saveDefault.isDisposed() ) {
saveDefault = null;
}
}
void updateDefaultButton( final Control focusControl, final boolean set ) {
if( focusControl instanceof Button ) {
ProcessActionRunner.add( new Runnable() {
public void run() {
Button defaultButton = set ? ( Button )focusControl : null;
setDefaultButton( defaultButton, false );
}
} );
}
}
/**
* Returns the receiver's default button if one had
* previously been set, otherwise returns null.
*
* @return the default button or null
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @see Shell#setDefaultButton(Button)
*/
// TODO [rst] move to class Decorations as soon as it exists
public Button getDefaultButton() {
checkWidget();
Button result = null;
if( defaultButton != null && !defaultButton.isDisposed() ) {
result = defaultButton;
}
return result;
}
/**
* Sets the receiver's alpha value.
*
* This operation may not be available on some
* platforms.
*
* @param alpha the alpha value
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @since 1.1
*/
public void setAlpha( int alpha ) {
checkWidget();
this.alpha = alpha & 0xFF;
}
/**
* Returns the receiver's alpha value.
*
* @return the alpha value
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @since 1.1
*/
public int getAlpha() {
checkWidget();
return alpha;
}
/**
* Sets the receiver's modified state as specified by the argument.
*
* @param modified the new modified state for the receiver
*
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @since 1.3
*/
public void setModified ( boolean modified ) {
checkWidget();
this.modified = modified;
}
/**
* Gets the receiver's modified state.
*
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @since 1.3
*/
public boolean getModified () {
checkWidget();
return modified;
}
/**
* Sets the receiver's minimum size to the size specified by the arguments.
* If the new minimum size is larger than the current size of the receiver,
* the receiver is resized to the new minimum size.
*
* @param width the new minimum width for the receiver
* @param height the new minimum height for the receiver
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @since 1.3
*/
public void setMinimumSize( int width, int height ) {
checkWidget();
minWidth = Math.max( MIN_WIDTH_LIMIT, width );
minHeight = Math.max( getMinHeightLimit(), height );
Point size = getSize();
int newWidth = Math.max( size.x, minWidth );
int newHeight = Math.max( size.y, minHeight );
if( newWidth != size.x || newHeight != size.y ) {
setSize( newWidth, newHeight );
}
}
/**
* Sets the receiver's minimum size to the size specified by the argument.
* If the new minimum size is larger than the current size of the receiver,
* the receiver is resized to the new minimum size.
*
* @param size the new minimum size for the receiver
*
* @exception IllegalArgumentException
* - ERROR_NULL_ARGUMENT - if the point is null
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @since 1.3
*/
public void setMinimumSize( Point size ) {
checkWidget();
if( size == null ) {
error( SWT.ERROR_NULL_ARGUMENT );
}
setMinimumSize( size.x, size.y );
}
/**
* Returns a point describing the minimum receiver's size. The
* x coordinate of the result is the minimum width of the receiver.
* The y coordinate of the result is the minimum height of the
* receiver.
*
* @return the receiver's size
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @since 1.3
*/
public Point getMinimumSize() {
checkWidget();
return new Point( minWidth, minHeight );
}
@Override
public void setBounds( Rectangle bounds ) {
int newWidth = Math.max( bounds.width, minWidth );
int newHeight = Math.max( bounds.height, minHeight );
super.setBounds( new Rectangle( bounds.x, bounds.y, newWidth, newHeight ) );
}
/**
* Returns the instance of the ToolBar object representing the tool bar that can appear on the
* trim of the shell. This will return null if the platform does not support tool
* bars that not part of the content area of the shell, or if the style of the shell does not
* support a tool bar.
*
*
* @return a ToolBar object representing the window's tool bar or null.
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @since 1.4
*/
public ToolBar getToolBar() {
checkWidget();
return null;
}
// ///////////////////////////////////////////////
// Event listener registration and deregistration
/**
* Adds the listener to the collection of listeners who will
* be notified when operations are performed on the receiver,
* by sending the listener one of the messages defined in the
* ShellListener interface.
*
* @param listener the listener which should be notified
*
* @exception IllegalArgumentException
* - ERROR_NULL_ARGUMENT - if the listener is null
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @see ShellListener
* @see #removeShellListener
*/
public void addShellListener( ShellListener listener ) {
checkWidget();
if( listener == null ) {
error( SWT.ERROR_NULL_ARGUMENT );
}
TypedListener typedListener = new TypedListener( listener );
addListener( SWT.Close, typedListener );
addListener( SWT.Activate, typedListener );
addListener( SWT.Deactivate, typedListener );
}
/**
* Removes the listener from the collection of listeners who will
* be notified when operations are performed on the receiver.
*
* @param listener the listener which should no longer be notified
*
* @exception IllegalArgumentException
* - ERROR_NULL_ARGUMENT - if the listener is null
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @see ShellListener
* @see #addShellListener
*/
public void removeShellListener( ShellListener listener ) {
checkWidget();
if( listener == null ) {
error( SWT.ERROR_NULL_ARGUMENT );
}
removeListener( SWT.Close, listener );
removeListener( SWT.Activate, listener );
removeListener( SWT.Deactivate, listener );
}
///////////
// Disposal
@Override
void releaseChildren() {
super.releaseChildren();
Shell[] dialogShells = internalGetShells();
for( int i = 0; i < dialogShells.length; i++ ) {
dialogShells[ i ].dispose();
}
Menu[] menus = MenuHolder.getMenus( this );
for( int i = 0; i < menus.length; i++ ) {
menus[ i ].dispose();
}
if( toolTips != null ) {
for( int i = 0; i < toolTips.length; i++ ) {
if( toolTips[ i ] != null ) {
toolTips[ i ].dispose();
}
}
}
}
@Override
void releaseParent() {
// Do not call super.releaseParent()
// This method would try to remove a child-shell from its ControlHolder
// but shells are currently not added to the ControlHolder of its parent
display.removeShell( this );
}
////////////////////////////////////////////////////////////
// Methods to maintain activeControl and send ActivateEvents
void setActiveControl( Control activateControl ) {
Control control = activateControl;
if( control != null && control.isDisposed() ) {
control = null;
}
if( lastActive != null && lastActive.isDisposed() ) {
lastActive = null;
}
if( lastActive != control ) {
// Compute the list of controls to be activated and deactivated by finding
// the first common parent control.
Control[] activate = ( control == null ) ? new Control[ 0 ] : control.getPath();
Control[] deactivate = lastActive == null ? new Control[ 0 ] : lastActive.getPath();
lastActive = control;
int index = 0;
int length = Math.min( activate.length, deactivate.length );
while( index < length && activate[ index ] == deactivate[ index ] ) {
index++;
}
// It is possible (but unlikely), that application code could have
// destroyed some of the widgets. If this happens, keep processing those
// widgets that are not disposed.
for( int i = deactivate.length - 1; i >= index; --i ) {
if( !deactivate[ i ].isDisposed() ) {
deactivate[ i ].notifyListeners( SWT.Deactivate, new Event() );
}
}
for( int i = activate.length - 1; i >= index; --i ) {
if( !activate[ i ].isDisposed() ) {
activate[ i ].notifyListeners( SWT.Activate, new Event() );
}
}
}
}
/////////////////////////
// Focus handling methods
// TODO [rh] move to Decorations as soon as exists
final void setSavedFocus( Control control ) {
savedFocus = control;
}
// TODO [rh] move to Decorations as soon as exists
final Control getSavedFocus() {
return savedFocus;
}
// TODO [rh] move to Decorations as soon as exists
final void saveFocus() {
Control control = display.getFocusControl();
if( control != null && control != this && this == control.getShell() ) {
setSavedFocus( control );
}
}
// TODO [rh] move to Decorations as soon as exists
final boolean restoreFocus() {
if( savedFocus != null && savedFocus.isDisposed() ) {
savedFocus = null;
}
boolean result = false;
if( savedFocus != null && savedFocus.setSavedFocus() ) {
result = true;
}
return result;
}
private void bringToTop() {
Object adapter = display.getAdapter( IDisplayAdapter.class );
IDisplayAdapter displayAdapter = ( IDisplayAdapter )adapter;
displayAdapter.setFocusControl( this );
// When a Shell is opened client-side the widget that is currently focused
// loses its focus. This is unwanted in the case that the request that
// opened the Shell sets the focus to some widget after opening the Shell.
// The fix is to force the DisplayLCA to issue JavaScript that sets the
// focus on the server-side focused widget.
displayAdapter.invalidateFocus();
}
////////////////
// Tab traversal
private boolean traverseGroup( boolean next ) {
// TODO [rh] fake implementation
boolean result = false;
if( getChildren().length > 0 ) {
result = getChildren()[ 0 ].forceFocus();
}
return result;
}
//////////////////////
// minimize / maximize
// TODO [rst] Move these methods to class Decorations when implemented
/**
* Sets the minimized stated of the receiver.
* If the argument is true causes the receiver
* to switch to the minimized state, and if the argument is
* false and the receiver was previously minimized,
* causes the receiver to switch back to either the maximized
* or normal states.
*
* @param minimized the new maximized state
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @see #setMaximized
*/
public void setMinimized( boolean minimized ) {
checkWidget();
if( minimized ) {
mode |= MODE_MINIMIZED;
} else {
if( ( mode & MODE_MINIMIZED ) != 0 ) {
setActive();
}
mode &= ~MODE_MINIMIZED;
}
}
/**
* Sets the maximized state of the receiver.
* If the argument is true causes the receiver
* to switch to the maximized state, and if the argument is
* false and the receiver was previously maximized,
* causes the receiver to switch back to either the minimized
* or normal states.
*
* @param maximized the new maximized state
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @see #setMinimized
*/
public void setMaximized( boolean maximized ) {
checkWidget();
if( ( mode & MODE_FULLSCREEN ) == 0 ) {
if( maximized ) {
if( ( mode & MODE_MAXIMIZED ) == 0 ) {
setActive();
savedBounds = getBounds();
setBounds( display.getBounds(), false );
}
mode |= MODE_MAXIMIZED;
mode &= ~MODE_MINIMIZED;
} else {
if( ( mode & MODE_MAXIMIZED ) != 0 ) {
setBounds( savedBounds, false );
}
mode &= ~MODE_MAXIMIZED;
}
}
}
/**
* Returns true if the receiver is currently
* minimized, and false otherwise.
*
*
* @return the minimized state
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @see #setMinimized
*/
public boolean getMinimized() {
checkWidget();
return ( mode & MODE_MINIMIZED ) != 0;
}
/**
* Returns true if the receiver is currently
* maximized, and false otherwise.
*
*
* @return the maximized state
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @see #setMaximized
*/
public boolean getMaximized() {
checkWidget();
return ( mode & MODE_FULLSCREEN ) == 0
&& ( mode & MODE_MINIMIZED ) == 0
&& ( mode & MODE_MAXIMIZED ) != 0;
}
/**
* Sets the full screen state of the receiver.
* If the argument is true causes the receiver
* to switch to the full screen state, and if the argument is
* false and the receiver was previously switched
* into full screen state, causes the receiver to switch back
* to either the maximized or normal states.
*
* Note: The result of intermixing calls to setFullScreen(true),
* setMaximized(true) and setMinimized(true) will
* vary by platform. Typically, the behavior will match the platform user's
* expectations, but not always. This should be avoided if possible.
*
*
* @param fullScreen the new fullscreen state
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @since 1.3
*/
public void setFullScreen( boolean fullScreen ) {
checkWidget();
if( ( ( mode & MODE_FULLSCREEN ) != 0 ) != fullScreen ) {
if( fullScreen ) {
setActive();
if( ( mode & MODE_MAXIMIZED ) == 0 ) {
savedBounds = getBounds();
}
setBounds( display.getBounds(), false );
mode |= MODE_FULLSCREEN;
mode &= ~MODE_MINIMIZED;
} else {
if( ( mode & MODE_MAXIMIZED ) == 0 ) {
setBounds( savedBounds, false );
}
mode &= ~MODE_FULLSCREEN;
}
layout();
}
}
/**
* Returns true if the receiver is currently
* in fullscreen state, and false otherwise.
*
*
* @return the fullscreen state
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
*
*
* @since 1.3
*/
public boolean getFullScreen() {
checkWidget();
return ( mode & MODE_FULLSCREEN ) != 0;
}
///////////////////
// ToolTips support
void createToolTip( ToolTip toolTip ) {
int id = 0;
if( toolTips == null ) {
toolTips = new ToolTip[ 4 ];
}
while( id < toolTips.length && toolTips[ id ] != null ) {
id++;
}
if( id == toolTips.length ) {
ToolTip[] newToolTips = new ToolTip[ toolTips.length + 4 ];
System.arraycopy( toolTips, 0, newToolTips, 0, toolTips.length );
toolTips = newToolTips;
}
toolTips[ id ] = toolTip;
}
void destroyToolTip( ToolTip toolTip ) {
boolean found = false;
for( int i = 0; !found && i < toolTips.length; i++ ) {
if( toolTips[ i ] == toolTip ) {
toolTips[ i ] = null;
found = true;
}
}
}
private ToolTip[] getToolTips() {
ToolTip[] result;
if( toolTips == null ) {
result = new ToolTip[ 0 ];
} else {
int count = 0;
for( int i = 0; i < toolTips.length; i++ ) {
if( toolTips[ i ] != null ) {
count++;
}
}
result = new ToolTip[ count ];
int index = 0;
for( int i = 0; i < toolTips.length; i++ ) {
if( toolTips[ i ] != null ) {
result[ index ] = toolTips[ i ];
index++;
}
}
}
return result;
}
///////////////////
// Widget overrides
// TODO [rh] move to class Decorations as soon as it exists
@Override
String getNameText() {
return getText();
}
///////////////////
// check... methods
// TODO [rh] move to class Decorations as soon as it exists
static int Decorations_checkStyle( int style ) {
int result = style;
if( ( result & SWT.NO_TRIM ) != 0 ) {
int trim = ( SWT.CLOSE
| SWT.TITLE
| SWT.MIN
| SWT.MAX
| SWT.RESIZE
| SWT.BORDER );
result &= ~trim;
}
if( ( result & ( /* SWT.MENU | */ SWT.MIN | SWT.MAX | SWT.CLOSE ) ) != 0 ) {
result |= SWT.TITLE;
}
if( ( result & ( SWT.MIN | SWT.MAX ) ) != 0 ) {
result |= SWT.CLOSE;
}
return result;
}
private static int checkStyle( int style ) {
return Decorations_checkStyle( style );
}
private static Shell checkParent( Shell parent ) {
if( parent != null && parent.isDisposed() ) {
SWT.error( SWT.ERROR_INVALID_ARGUMENT );
}
return parent;
}
///////////////////
// Skinning support
@Override
void reskinChildren( int flags ) {
Shell[] shells = getShells();
for( int i = 0; i < shells.length; i++ ) {
Shell shell = shells[ i ];
if( shell != null ) {
shell.reskin( flags );
}
}
super.reskinChildren( flags );
}
}