/*******************************************************************************
* Copyright (c) 2002, 2015 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
******************************************************************************/
package org.eclipse.swt.widgets;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.rap.rwt.internal.lifecycle.ProcessActionRunner;
import org.eclipse.rap.rwt.internal.lifecycle.RemoteAdapter;
import org.eclipse.rap.rwt.internal.lifecycle.WidgetLCA;
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.internal.SerializableCompatibility;
import org.eclipse.swt.internal.widgets.ControlRemoteAdapter;
import org.eclipse.swt.internal.widgets.ICompositeAdapter;
import org.eclipse.swt.internal.widgets.compositekit.CompositeLCA;
/**
* Instances of this class are controls which are capable
* of containing other controls.
* <dl>
* <dt><b>Styles:</b></dt>
* <dd>NO_FOCUS, NO_RADIO_GROUP</dd>
* <dt><b>Events:</b></dt>
* <dd>(none)</dd>
* </dl>
* <p>
* This class may be subclassed by custom control implementors
* who are building controls that are constructed from aggregates
* of other controls.
* </p>
*/
public class Composite extends Scrollable {
private final ICompositeAdapter compositeAdapter;
private Layout layout;
int layoutCount;
private final List<Control> children;
private Control[] tabList;
int backgroundMode;
Composite( Composite parent ) {
// prevent instantiation from outside this package
super( parent );
children = new ArrayList<>();
compositeAdapter = new CompositeAdapter();
}
/**
* Constructs a new instance of this class given its parent
* and a style value describing its behavior and appearance.
* <p>
* The style value is either one of the style constants defined in
* class <code>SWT</code> which is applicable to instances of this
* class, or must be built by <em>bitwise OR</em>'ing together
* (that is, using the <code>int</code> "|" operator) two or more
* of those <code>SWT</code> style constants. The class description
* lists the style constants that are applicable to the class.
* Style bits are also inherited from superclasses.
* </p>
*
* @param parent a widget which will be the parent of the new instance (cannot be null)
* @param style the style of widget to construct
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>
* </ul>
*
* @see SWT#NO_FOCUS
* @see SWT#NO_RADIO_GROUP
* @see Widget#getStyle
*/
public Composite( Composite parent, int style ) {
super( parent, style );
children = new ArrayList<>();
compositeAdapter = new CompositeAdapter();
}
@Override
void initState() {
if( ( style & ( SWT.H_SCROLL | SWT.V_SCROLL ) ) == 0 ) {
addState( THEME_BACKGROUND );
}
}
/**
* Returns a (possibly empty) array containing the receiver's children.
* Children are returned in the order that they are drawn. The topmost
* control appears at the beginning of the array. Subsequent controls
* draw beneath this control and appear later in the array.
* <p>
* Note: This is not the actual structure used by the receiver
* to maintain its list of children, so modifying the array will
* not affect the receiver.
* </p>
*
* @return an array of children
*
* @see Control#moveAbove
* @see Control#moveBelow
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public Control[] getChildren() {
checkWidget();
return children.toArray( new Control[ 0 ] );
}
@Override
@SuppressWarnings("unchecked")
public <T> T getAdapter( Class<T> adapter ) {
if( adapter == ICompositeAdapter.class ) {
return ( T )compositeAdapter;
}
if( adapter == WidgetLCA.class ) {
return ( T )CompositeLCA.INSTANCE;
}
return super.getAdapter( adapter );
}
//////////////////
// Layout methods
/**
* Sets the layout which is associated with the receiver to be
* the argument which may be null.
*
* @param layout the receiver's new layout or null
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public void setLayout( Layout layout ) {
checkWidget();
this.layout = layout;
}
/**
* Returns layout which is associated with the receiver, or
* null if one has not been set.
*
* @return the receiver's layout or null
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public Layout getLayout() {
checkWidget();
return layout;
}
/**
* If the argument is <code>true</code>, causes subsequent layout
* operations in the receiver or any of its children to be ignored.
* No layout of any kind can occur in the receiver or any of its
* children until the flag is set to false.
* Layout operations that occurred while the flag was
* <code>true</code> are remembered and when the flag is set to
* <code>false</code>, the layout operations are performed in an
* optimized manner. Nested calls to this method are stacked.
*
* @param defer the new defer state
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @see #layout(boolean)
* @see #layout(Control[])
*
* @since 1.3
*/
public void setLayoutDeferred( boolean defer ) {
checkWidget();
if( !defer ) {
if( --layoutCount == 0 ) {
if( hasState( LAYOUT_CHILD ) || hasState( LAYOUT_NEEDED ) ) {
updateLayout( true, true );
}
}
} else {
layoutCount++;
}
}
/**
* Returns <code>true</code> if the receiver has deferred
* the performing of layout, and <code>false</code> otherwise.
*
* @return the receiver's deferred layout state
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @see #setLayoutDeferred(boolean)
* @see #isLayoutDeferred()
*/
public boolean getLayoutDeferred() {
checkWidget();
return layoutCount > 0;
}
/**
* Returns <code>true</code> if the receiver or any ancestor
* up to and including the receiver's nearest ancestor shell
* has deferred the performing of layouts. Otherwise, <code>false</code>
* is returned.
*
* @return the receiver's deferred layout state
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @see #setLayoutDeferred(boolean)
* @see #getLayoutDeferred()
*/
public boolean isLayoutDeferred() {
checkWidget();
return findDeferredControl() != null;
}
/**
* If the receiver has a layout, asks the layout to <em>lay out</em>
* (that is, set the size and location of) the receiver's children.
* If the receiver does not have a layout, do nothing.
* <p>
* Use of this method is discouraged since it is the least-efficient
* way to trigger a layout. The use of <code>layout(true)</code>
* discards all cached layout information, even from controls which
* have not changed. It is much more efficient to invoke
* {@link Control#requestLayout()} on every control which has changed
* in the layout than it is to invoke this method on the layout itself.
* </p>
* <p>
* This is equivalent to calling <code>layout(true)</code>.
* </p>
* <p>
* Note: Layout is different from painting. If a child is
* moved or resized such that an area in the parent is
* exposed, then the parent will paint. If no child is
* affected, the parent will not paint.
* </p>
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public void layout() {
checkWidget();
layout( true );
}
/**
* If the receiver has a layout, asks the layout to <em>lay out</em>
* (that is, set the size and location of) the receiver's children.
* If the argument is <code>true</code> the layout must not rely
* on any information it has cached about the immediate children. If it
* is <code>false</code> the layout may (potentially) optimize the
* work it is doing by assuming that none of the receiver's
* children has changed state since the last layout.
* If the receiver does not have a layout, do nothing.
* <p>
* It is normally more efficient to invoke {@link Control#requestLayout()}
* on every control which has changed in the layout than it is to invoke
* this method on the layout itself. Clients are encouraged to use
* {@link Control#requestLayout()} where possible instead of calling
* this method.
* </p>
* <p>
* If a child is resized as a result of a call to layout, the
* resize event will invoke the layout of the child. The layout
* will cascade down through all child widgets in the receiver's widget
* tree until a child is encountered that does not resize. Note that
* a layout due to a resize will not flush any cached information
* (same as <code>layout(false)</code>).
* </p>
* <p>
* Note: Layout is different from painting. If a child is
* moved or resized such that an area in the parent is
* exposed, then the parent will paint. If no child is
* affected, the parent will not paint.
* </p>
*
* @param changed <code>true</code> if the layout must flush its caches, and <code>false</code> otherwise
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public void layout( boolean changed ) {
checkWidget();
if( layout != null ) {
layout( changed, false );
}
}
/**
* If the receiver has a layout, asks the layout to <em>lay out</em>
* (that is, set the size and location of) the receiver's children.
* If the changed argument is <code>true</code> the layout must not rely
* on any information it has cached about its children. If it
* is <code>false</code> the layout may (potentially) optimize the
* work it is doing by assuming that none of the receiver's
* children has changed state since the last layout.
* If the all argument is <code>true</code> the layout will cascade down
* through all child widgets in the receiver's widget tree, regardless of
* whether the child has changed size. The changed argument is applied to
* all layouts. If the all argument is <code>false</code>, the layout will
* <em>not</em> cascade down through all child widgets in the receiver's widget
* tree. However, if a child is resized as a result of a call to layout, the
* resize event will invoke the layout of the child. Note that
* a layout due to a resize will not flush any cached information
* (same as <code>layout(false)</code>).
* </p>
* <p>
* It is normally more efficient to invoke {@link Control#requestLayout()}
* on every control which has changed in the layout than it is to invoke
* this method on the layout itself. Clients are encouraged to use
* {@link Control#requestLayout()} where possible instead of calling
* this method.
* </p>
* <p>
* Note: Layout is different from painting. If a child is
* moved or resized such that an area in the parent is
* exposed, then the parent will paint. If no child is
* affected, the parent will not paint.
* </p>
*
* @param changed <code>true</code> if the layout must flush its caches, and <code>false</code> otherwise
* @param all <code>true</code> if all children in the receiver's widget tree should be laid out, and <code>false</code> otherwise
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public void layout( boolean changed, boolean all ) {
checkWidget();
if( layout != null || all ) {
markLayout( changed, all );
updateLayout( true, all );
}
}
/**
* Forces a lay out (that is, sets the size and location) of all widgets that
* are in the parent hierarchy of the changed control up to and including the
* receiver. The layouts in the hierarchy must not rely on any information
* cached about the changed control or any of its ancestors. The layout may
* (potentially) optimize the work it is doing by assuming that none of the
* peers of the changed control have changed state since the last layout.
* If an ancestor does not have a layout, skip it.
* <p>
* It is normally more efficient to invoke {@link Control#requestLayout()}
* on every control which has changed in the layout than it is to invoke
* this method on the layout itself. Clients are encouraged to use
* {@link Control#requestLayout()} where possible instead of calling
* this method.
* </p>
* <p>
* Note: Layout is different from painting. If a child is
* moved or resized such that an area in the parent is
* exposed, then the parent will paint. If no child is
* affected, the parent will not paint.
* </p>
*
* @param changed a control that has had a state change which requires a recalculation of its size
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_ARGUMENT - if the changed array is null any of its controls are null or have been disposed</li>
* <li>ERROR_INVALID_PARENT - if any control in changed is not in the widget tree of the receiver</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public void layout( Control[] changed ) {
checkWidget();
if( changed == null ) {
error( SWT.ERROR_INVALID_ARGUMENT );
}
layout( changed, SWT.NONE );
}
/**
* Forces a lay out (that is, sets the size and location) of all widgets that
* are in the parent hierarchy of the changed control up to and including the
* receiver.
* <p>
* The parameter <code>flags</code> may be a combination of:
* <dl>
* <dt><b>SWT.ALL</b></dt>
* <dd>all children in the receiver's widget tree should be laid out</dd>
* <dt><b>SWT.CHANGED</b></dt>
* <dd>the layout must flush its caches</dd>
* <dt><b>SWT.DEFER</b></dt>
* <dd>layout will be deferred</dd>
* </dl>
* </p>
* <p>
* When the <code>changed</code> array is specified, the flags <code>SWT.ALL</code>
* and <code>SWT.CHANGED</code> have no effect. In this case, the layouts in the
* hierarchy must not rely on any information cached about the changed control or
* any of its ancestors. The layout may (potentially) optimize the
* work it is doing by assuming that none of the peers of the changed
* control have changed state since the last layout.
* If an ancestor does not have a layout, skip it.
* </p>
* <p>
* When the <code>changed</code> array is not specified, the flag <code>SWT.ALL</code>
* indicates that the whole widget tree should be laid out. And the flag
* <code>SWT.CHANGED</code> indicates that the layouts should flush any cached
* information for all controls that are laid out.
* </p>
* <p>
* The <code>SWT.DEFER</code> flag always causes the layout to be deferred by
* calling <code>Composite.setLayoutDeferred(true)</code> and scheduling a call
* to <code>Composite.setLayoutDeferred(false)</code>, which will happen when
* appropriate (usually before the next event is handled). When this flag is set,
* the application should not call <code>Composite.setLayoutDeferred()</code>.
* </p>
* <p>
* Note: Layout is different from painting. If a child is
* moved or resized such that an area in the parent is
* exposed, then the parent will paint. If no child is
* affected, the parent will not paint.
* </p>
*
* @param changed a control that has had a state change which requires a recalculation of its size
* @param flags the flags specifying how the layout should happen
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_ARGUMENT - if any of the controls in changed is null or has been disposed</li>
* <li>ERROR_INVALID_PARENT - if any control in changed is not in the widget tree of the receiver</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 1.3
*/
// [if]: This is a verbatim copy of SWT, thus no reformatting was done.
public void layout (Control [] changed, int flags) {
checkWidget ();
if (changed != null) {
for (int i=0; i<changed.length; i++) {
Control control = changed [i];
if (control == null) {
error (SWT.ERROR_INVALID_ARGUMENT);
}
if (control.isDisposed ()) {
error (SWT.ERROR_INVALID_ARGUMENT);
}
boolean ancestor = false;
Composite composite = control._getParent();
while (composite != null) {
ancestor = composite == this;
if (ancestor) {
break;
}
composite = composite._getParent();
}
if (!ancestor) {
error (SWT.ERROR_INVALID_PARENT);
}
}
int updateCount = 0;
Composite [] update = new Composite [16];
for (int i=0; i<changed.length; i++) {
Control child = changed [i];
Composite composite = child._getParent();
while (child != this) {
if (composite.layout != null) {
composite.addState( LAYOUT_NEEDED );
if (!composite.layout.flushCache (child)) {
composite.addState( LAYOUT_CHANGED );
}
}
if (updateCount == update.length) {
Composite [] newUpdate = new Composite [update.length + 16];
System.arraycopy (update, 0, newUpdate, 0, update.length);
update = newUpdate;
}
child = update [updateCount++] = composite;
composite = child._getParent();
}
}
if ((flags & SWT.DEFER) != 0) {
setLayoutDeferred (true);
display.addLayoutDeferred (this);
}
for (int i=updateCount-1; i>=0; i--) {
update [i].updateLayout (false);
}
} else {
if (layout == null && (flags & SWT.ALL) == 0) {
return;
}
markLayout ((flags & SWT.CHANGED) != 0, (flags & SWT.ALL) != 0);
if ((flags & SWT.DEFER) != 0) {
setLayoutDeferred (true);
display.addLayoutDeferred (this);
}
updateLayout ((flags & SWT.ALL) != 0);
}
}
@Override
void markLayout( boolean changed, boolean all ) {
if( layout != null ) {
addState( LAYOUT_NEEDED );
if( changed ) {
addState( LAYOUT_CHANGED );
}
}
if( all ) {
for( Control child : children ) {
child.markLayout( changed, all );
}
}
}
void updateLayout( boolean all ) {
updateLayout( true, all );
}
@Override
void updateLayout( boolean resize, boolean all ) {
Composite parent = findDeferredControl();
if( parent != null ) {
parent.addState( LAYOUT_CHILD );
return;
}
if( hasState( LAYOUT_NEEDED ) ) {
boolean changed = hasState( LAYOUT_CHANGED );
removeState( LAYOUT_NEEDED | LAYOUT_CHANGED );
// if (resize) setResizeChildren (false);
layout.layout( this, changed );
// if (resize) setResizeChildren (true);
}
if( all ) {
removeState( LAYOUT_CHILD );
for( Control child : children ) {
child.updateLayout( resize, all );
}
}
}
Composite findDeferredControl() {
return layoutCount > 0 ? this : _getParent().findDeferredControl();
}
@Override
public Point computeSize( int wHint, int hHint, boolean changed ) {
checkWidget();
Point size;
boolean hasChanged = changed;
if( layout != null ) {
if( wHint == SWT.DEFAULT || hHint == SWT.DEFAULT ) {
hasChanged |= hasState( LAYOUT_CHANGED );
removeState( LAYOUT_CHANGED );
size = layout.computeSize( this, wHint, hHint, hasChanged );
} else {
size = new Point( wHint, hHint );
}
} else {
size = minimumSize();
if( size.x == 0 ) {
size.x = DEFAULT_WIDTH;
}
if( size.y == 0 ) {
size.y = DEFAULT_HEIGHT;
}
}
if( wHint != SWT.DEFAULT ) {
size.x = wHint;
}
if( hHint != SWT.DEFAULT ) {
size.y = hHint;
}
Rectangle trim = computeTrim( 0, 0, size.x, size.y );
return new Point( trim.width, trim.height );
}
/**
* Clears any data that has been cached by a Layout for all widgets that
* are in the parent hierarchy of the changed control up to and including the
* receiver. If an ancestor does not have a layout, it is skipped.
*
* @param changed an array of controls that changed state and require a recalculation of size
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_ARGUMENT - if the changed array is null any of its controls are null or have been disposed</li>
* <li>ERROR_INVALID_PARENT - if any control in changed is not in the widget tree of the receiver</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @since 1.0
*/
public void changed( Control[] changed ) {
checkWidget();
if( changed == null ) {
error( SWT.ERROR_INVALID_ARGUMENT );
}
for( int i = 0; i < changed.length; i++ ) {
Control control = changed[ i ];
if( control == null ) {
error( SWT.ERROR_INVALID_ARGUMENT );
}
if( control.isDisposed() ) {
error( SWT.ERROR_INVALID_ARGUMENT );
}
boolean ancestor = false;
Composite composite = control._getParent();
while( composite != null ) {
ancestor = composite == this;
if( ancestor ) {
break;
}
composite = composite._getParent();
}
if( !ancestor ) {
error( SWT.ERROR_INVALID_PARENT );
}
}
for( int i = 0; i < changed.length; i++ ) {
Control child = changed[ i ];
Composite composite = child._getParent();
while( child != this ) {
if( composite.layout == null || !composite.layout.flushCache( child ) ) {
composite.addState( LAYOUT_CHANGED );
}
child = composite;
composite = child._getParent();
}
}
}
/**
* Returns the receiver's background drawing mode. This
* will be one of the following constants defined in class
* <code>SWT</code>:
* <code>INHERIT_NONE</code>, <code>INHERIT_DEFAULT</code>,
* <code>INHERTIT_FORCE</code>.
*
* @return the background mode
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @see SWT
*
* @since 1.1
*/
public int getBackgroundMode() {
checkWidget();
return backgroundMode;
}
/**
* Sets the background drawing mode to the argument which should be one of the
* following constants defined in class <code>SWT</code>:
* <code>INHERIT_NONE</code>, <code>INHERIT_DEFAULT</code>,
* <code>INHERIT_FORCE</code>.
*
* @param mode the new background mode
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
* @see SWT
* @since 1.1
*/
public void setBackgroundMode( int mode ) {
checkWidget();
backgroundMode = mode;
for( Control child : children ) {
child.updateBackgroundMode();
}
}
@Override
void updateBackgroundMode() {
super.updateBackgroundMode();
for( Control child : children ) {
child.updateBackgroundMode();
}
}
@Override
void updateOrientation () {
int orientation = style & ( SWT.LEFT_TO_RIGHT | SWT.RIGHT_TO_LEFT );
super.updateOrientation();
for( Control child : children ) {
child.setOrientation( orientation );
}
}
@Override
public boolean setFocus() {
checkWidget();
for( Control child : children ) {
if( child.setFocus() ) {
return true;
}
}
return super.setFocus ();
}
////////////
// Tab Order
/**
* Sets the tabbing order for the specified controls to
* match the order that they occur in the argument list.
*
* @param tabList the ordered list of controls representing the tab order or null
*
* @exception IllegalArgumentException <ul>
* <li>ERROR_INVALID_ARGUMENT - if a widget in the tabList is null or has been disposed</li>
* <li>ERROR_INVALID_PARENT - if widget in the tabList is not in the same widget tree</li>
* </ul>
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*/
public void setTabList( Control[] tabList ) {
checkWidget();
Control[] newList = tabList;
if( tabList != null ) {
for( int i = 0; i < tabList.length; i++ ) {
Control control = tabList[ i ];
if( control == null ) {
error( SWT.ERROR_INVALID_ARGUMENT );
}
if( control.isDisposed() ) {
error( SWT.ERROR_INVALID_ARGUMENT );
}
if( control._getParent() != this ) {
error( SWT.ERROR_INVALID_PARENT );
}
}
newList = new Control[ tabList.length ];
System.arraycopy( tabList, 0, newList, 0, tabList.length );
}
this.tabList = newList;
}
/**
* Gets the (possibly empty) tabbing order for the control.
*
* @return tabList the ordered list of controls representing the tab order
*
* @exception SWTException <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
* </ul>
*
* @see #setTabList
*/
// returns only tabGroups
public Control[] getTabList() {
checkWidget();
Control[] result = _getTabList();
if( result == null ) {
int count = 0;
for( Control child : children ) {
if( child.isTabGroup() ) {
count++;
}
}
result = new Control[ count ];
int index = 0;
for( Control child : children ) {
if( child.isTabGroup() ) {
result[ index++ ] = child;
}
}
}
return result;
}
// filters disposed controls out
Control[] _getTabList() {
if( tabList != null ) {
int count = 0;
for( int i = 0; i < tabList.length; i++ ) {
if( !tabList[ i ].isDisposed() ) {
count++;
}
}
if( count != tabList.length ) {
Control[] newList = new Control[ count ];
int index = 0;
for( int i = 0; i < tabList.length; i++ ) {
if( !tabList[ i ].isDisposed() ) {
newList[ index++ ] = tabList[ i ];
}
}
tabList = newList;
}
}
return tabList;
}
@Override
boolean isTabGroup() {
return true;
}
/////////////////////////////////////
// Helping method used by computeSize
Point minimumSize() {
Rectangle clientArea = getClientArea();
int width = 0, height = 0;
for( Control child : children ) {
Rectangle rect = child.getBounds();
width = Math.max( width, rect.x - clientArea.x + rect.width );
height = Math.max( height, rect.y - clientArea.y + rect.height );
}
return new Point( width, height );
}
/////////////////////////////////////////////////
// Internal methods to maintain the child controls
@Override
void releaseChildren() {
super.releaseChildren();
List<Control> copy = new ArrayList<>( children );
for( Control child : copy ) {
child.dispose();
}
}
void addChild( Control control ) {
getRemoteAdapter().preserveChildren( children.toArray( new Control[ 0 ] ) );
children.add( control );
}
void removeChild( Control control ) {
getRemoteAdapter().preserveChildren( children.toArray( new Control[ 0 ] ) );
children.remove( control );
}
void moveAbove( Control control1, Control control2 ) {
getRemoteAdapter().preserveChildren( children.toArray( new Control[ 0 ] ) );
children.remove( control1 );
int index = control2 != null ? children.indexOf( control2 ) : 0;
children.add( index, control1 );
}
void moveBelow( Control control1, Control control2 ) {
getRemoteAdapter().preserveChildren( children.toArray( new Control[ 0 ] ) );
children.remove( control1 );
int index = control2 != null ? children.indexOf( control2 ) + 1 : children.size();
children.add( index, control1 );
}
@Override
void notifyResize( Point oldSize ) {
// TODO [rh] revise this: the SWT code (method sendResize) first calls
// 'super' (fires resize events) and *then* does the layouting
if( !oldSize.equals( getSize() ) || isLayoutNeeded() ) {
ProcessActionRunner.add( new Runnable() {
@Override
public void run() {
if( !isDisposed() && layout != null ) {
markLayout( false, false );
updateLayout( false, false );
}
}
} );
}
super.notifyResize( oldSize );
}
private boolean isLayoutNeeded() {
return hasState( LAYOUT_NEEDED );
}
@Override
void reskinChildren( int flags ) {
super.reskinChildren( flags );
for( Control child : children ) {
if( child != null ) {
child.reskin( flags );
}
}
}
private ControlRemoteAdapter getRemoteAdapter() {
return ( ControlRemoteAdapter )getAdapter( RemoteAdapter.class );
}
private final class CompositeAdapter implements ICompositeAdapter, SerializableCompatibility {
@Override
public void markLayoutNeeded() {
markLayout( false, false );
}
@Override
public Iterable<Control> getChildren() {
return children;
}
}
}