+ * 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.
+ *
+ *
+ * @return an array of children
+ *
+ * @see Control#moveAbove
+ * @see Control#moveBelow
+ *
+ * @exception SWTException true if the receiver has deferred
+ * the performing of layout, and false otherwise.
+ *
+ * @return the receiver's deferred layout 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 #setLayoutDeferred(boolean)
+ * @see #isLayoutDeferred()
+ *
+ * @since 3.1
+ */
+public boolean getLayoutDeferred () {
+ checkWidget ();
+ return layoutCount > 0 ;
+}
+
+/**
+ * Returns true if the receiver or any ancestor
+ * up to and including the receiver's nearest ancestor shell
+ * has deferred the performing of layouts. Otherwise, false
+ * is returned.
+ *
+ * @return the receiver's deferred layout 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 #setLayoutDeferred(boolean)
+ * @see #getLayoutDeferred()
+ *
+ * @since 3.1
+ */
+public boolean isLayoutDeferred () {
+ checkWidget ();
+ return findDeferredControl () != null;
+}
+
+/**
+ * If the receiver has a layout, asks the layout to lay out
+ * (that is, set the size and location of) the receiver's children.
+ * If the receiver does not have a layout, do nothing.
+ *
+ * Use of this method is discouraged since it is the least-efficient
+ * way to trigger a layout. The use of layout(true)
+ * 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.
+ *
+ *
+ * This is equivalent to calling layout(true).
+ *
+ *
+ * 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.
+ *
+ *
+ * @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 void layout () {
+ checkWidget ();
+ layout (true);
+}
+
+/**
+ * If the receiver has a layout, asks the layout to lay out
+ * (that is, set the size and location of) the receiver's children.
+ * If the argument is true the layout must not rely
+ * on any information it has cached about the immediate children. If it
+ * is false 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.
+ *
+ * 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.
+ *
+ *
+ * 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 layout(false)).
+ *
+ *
+ * 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.
+ *
+ *
+ * @param changed true if the layout must flush its caches, and false otherwise
+ *
+ * @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 void layout (boolean changed) {
+ checkWidget ();
+ if (layout == null) return;
+ layout (changed, false);
+}
+
+/**
+ * If the receiver has a layout, asks the layout to lay out
+ * (that is, set the size and location of) the receiver's children.
+ * If the changed argument is true the layout must not rely
+ * on any information it has cached about its children. If it
+ * is false 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 true 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 false, the layout will
+ * not 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 layout(false)).
+ *
+ * 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.
+ *
+ *
+ * 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.
+ *
+ *
+ * @param changed true if the layout must flush its caches, and false otherwise
+ * @param all true if all children in the receiver's widget tree should be laid out, and false otherwise
+ *
+ * @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 3.1
+ */
+public void layout (boolean changed, boolean all) {
+ checkWidget ();
+ if (layout == null && !all) return;
+ markLayout (changed, all);
+ updateLayout (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.
+ *
+ * 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.
+ *
+ *
+ * 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.
+ *
+ *
+ * @param changed a control that has had a state change which requires a recalculation of its size
+ *
+ * @exception IllegalArgumentException
+ * - ERROR_INVALID_ARGUMENT - if the changed array is null any of its controls are null or have been disposed
+ * - ERROR_INVALID_PARENT - if any control in changed is not in the widget tree of 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 3.1
+ */
+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.
+ *
+ * The parameter flags may be a combination of:
+ *
+ *
+ * - SWT.ALL
+ * - all children in the receiver's widget tree should be laid out
+ * - SWT.CHANGED
+ * - the layout must flush its caches
+ * - SWT.DEFER
+ * - layout will be deferred
+ *
+ *
+ * When the changed array is specified, the flags SWT.ALL
+ * and SWT.CHANGED 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.
+ *
+ *
+ * When the changed array is not specified, the flag SWT.ALL
+ * indicates that the whole widget tree should be laid out. And the flag
+ * SWT.CHANGED indicates that the layouts should flush any cached
+ * information for all controls that are laid out.
+ *
+ *
+ * The SWT.DEFER flag always causes the layout to be deferred by
+ * calling Composite.setLayoutDeferred(true) and scheduling a call
+ * to Composite.setLayoutDeferred(false), which will happen when
+ * appropriate (usually before the next event is handled). When this flag is set,
+ * the application should not call Composite.setLayoutDeferred(boolean).
+ *
+ *
+ * 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.
+ *
+ *
+ * @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
+ * - ERROR_INVALID_ARGUMENT - if any of the controls in changed is null or has been disposed
+ * - ERROR_INVALID_PARENT - if any control in changed is not in the widget tree of 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 3.6
+ */
+public void layout (Control [] changed, int flags) {
+ checkWidget ();
+ if (changed != null) {
+ for (int i=0; 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 (!display.externalEventLoop && (flags & SWT.DEFER) != 0) {
+ setLayoutDeferred (true);
+ display.addLayoutDeferred (this);
+ }
+ updateLayout ((flags & SWT.ALL) != 0);
+ }
+}
+
+@Override
+void markLayout (boolean changed, boolean all) {
+ if (layout != null) {
+ state |= LAYOUT_NEEDED;
+ if (changed) state |= LAYOUT_CHANGED;
+ }
+ if (all) {
+ Control [] children = _getChildren ();
+ for (int i=0; i 1) {
+// int bits = OS.GetWindowLong (handle, OS.GWL_STYLE);
+// if ((bits & OS.WS_CLIPSIBLINGS) == 0) wp.flags |= OS.SWP_NOCOPYBITS;
+// }
+ if (defer) {
+ hdwp = OS.DeferWindowPos (hdwp, wp.hwnd, 0, wp.x, wp.y, wp.cx, wp.cy, wp.flags);
+ if (hdwp == 0) return false;
+ } else {
+ OS.SetWindowPos (wp.hwnd, 0, wp.x, wp.y, wp.cx, wp.cy, wp.flags);
+ }
+ }
+ }
+ if (defer) return OS.EndDeferWindowPos (hdwp);
+ return true;
+}
+
+void resizeEmbeddedHandle(long embeddedHandle, int width, int height) {
+ if (embeddedHandle == 0) return;
+ int [] processID = new int [1];
+ int threadId = OS.GetWindowThreadProcessId (embeddedHandle, processID);
+ if (threadId != OS.GetCurrentThreadId ()) {
+ if (processID [0] == OS.GetCurrentProcessId ()) {
+ if (display.msgHook == 0) {
+ display.getMsgCallback = new Callback (display, "getMsgProc", 3);
+ display.getMsgProc = display.getMsgCallback.getAddress ();
+ if (display.getMsgProc == 0) error (SWT.ERROR_NO_MORE_CALLBACKS);
+ display.msgHook = OS.SetWindowsHookEx (OS.WH_GETMESSAGE, display.getMsgProc, OS.GetLibraryHandle(), threadId);
+ OS.PostThreadMessage (threadId, OS.WM_NULL, 0, 0);
+ }
+ }
+ int flags = OS.SWP_NOZORDER | OS.SWP_DRAWFRAME | OS.SWP_NOACTIVATE | OS.SWP_ASYNCWINDOWPOS;
+ OS.SetWindowPos (embeddedHandle, 0, 0, 0, width, height, flags);
+ }
+}
+
+@Override
+void sendResize () {
+ setResizeChildren (false);
+ super.sendResize ();
+ if (isDisposed ()) return;
+ if (layout != null) {
+ markLayout (false, false);
+ updateLayout (false, false);
+ }
+ setResizeChildren (true);
+}
+
+/**
+ * Sets the background drawing mode to the argument which should
+ * be one of the following constants defined in class SWT:
+ * INHERIT_NONE, INHERIT_DEFAULT,
+ * INHERIT_FORCE.
+ *
+ * @param mode the new background mode
+ *
+ * @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
+ *
+ * @since 3.2
+ */
+public void setBackgroundMode (int mode) {
+ checkWidget ();
+ backgroundMode = mode;
+ Control [] children = _getChildren ();
+ for (int i = 0; i < children.length; i++) {
+ children [i].updateBackgroundMode ();
+ }
+}
+
+@Override
+void setBoundsInPixels (int x, int y, int width, int height, int flags, boolean defer) {
+ if (display.resizeCount > Display.RESIZE_LIMIT) {
+ defer = false;
+ }
+ if (!defer && (state & CANVAS) != 0) {
+ state &= ~(RESIZE_OCCURRED | MOVE_OCCURRED);
+ state |= RESIZE_DEFERRED | MOVE_DEFERRED;
+ }
+ super.setBoundsInPixels (x, y, width, height, flags, defer);
+ if (!defer && (state & CANVAS) != 0) {
+ boolean wasMoved = (state & MOVE_OCCURRED) != 0;
+ boolean wasResized = (state & RESIZE_OCCURRED) != 0;
+ state &= ~(RESIZE_DEFERRED | MOVE_DEFERRED);
+ if (wasMoved && !isDisposed ()) sendMove ();
+ if (wasResized && !isDisposed ()) sendResize ();
+ }
+}
+
+@Override
+public boolean setFocus () {
+ checkWidget ();
+ Control [] children = _getChildren ();
+ for (int i=0; i
+ * ERROR_WIDGET_DISPOSED - if the receiver has been disposed
+ * ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
+ *
+ */
+public void setLayout (Layout layout) {
+ checkWidget ();
+ this.layout = layout;
+}
+
+/**
+ * If the argument is true, 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
+ * true are remembered and when the flag is set to
+ * false, the layout operations are performed in an
+ * optimized manner. Nested calls to this method are stacked.
+ *
+ * @param defer the new defer 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 #layout(boolean)
+ * @see #layout(Control[])
+ *
+ * @since 3.1
+ */
+public void setLayoutDeferred (boolean defer) {
+ checkWidget();
+ if (!defer) {
+ if (--layoutCount == 0) {
+ if ((state & LAYOUT_CHILD) != 0 || (state & LAYOUT_NEEDED) != 0) {
+ updateLayout (true);
+ }
+ }
+ } else {
+ layoutCount++;
+ }
+}
+/**
+ * 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
+ * - ERROR_INVALID_ARGUMENT - if a widget in the tabList is null or has been disposed
+ * - ERROR_INVALID_PARENT - if widget in the tabList 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
+ *
+ */
+public void setTabList (Control [] tabList) {
+ checkWidget ();
+ if (tabList != null) {
+ for (int i=0; i Display.RESIZE_LIMIT) {
+ return;
+ }
+ int count = getChildrenCount ();
+ if (count > 1 && lpwp == null) {
+ lpwp = new WINDOWPOS [count];
+ }
+ }
+}
+
+@Override
+boolean setTabGroupFocus () {
+ if (isTabItem ()) return setTabItemFocus ();
+ boolean takeFocus = (style & SWT.NO_FOCUS) == 0;
+ if ((state & CANVAS) != 0) {
+ takeFocus = hooksKeys ();
+ if ((style & SWT.EMBEDDED) != 0) takeFocus = true;
+ }
+ if (takeFocus && setTabItemFocus ()) return true;
+ Control [] children = _getChildren ();
+ for (int i=0; i 0) {
+ if (children[i] != null && !children[i].isDisposed ()) {
+ children[i].updateTextDirection(textDirection);
+ }
+ }
+ /*
+ * Return value indicates whether or not to update derivatives, so in case
+ * of AUTO always return true regardless of the actual update.
+ */
+ return true;
+}
+
+String toolTipText (NMTTDISPINFO hdr) {
+ Shell shell = getShell ();
+ if ((hdr.uFlags & OS.TTF_IDISHWND) == 0) {
+ String string = null;
+ ToolTip toolTip = shell.findToolTip ((int)hdr.idFrom);
+ if (toolTip != null) {
+ string = toolTip.message;
+ if (string == null || string.length () == 0) string = " ";
+ /*
+ * Bug in Windows. On Windows 7, tool tips hang when displaying large
+ * unwrapped strings. The fix is to wrap the string ourselves.
+ */
+ if (string.length () > TOOLTIP_LIMIT / 4) {
+ string = display.wrapText (string, handle, toolTip.getWidth ());
+ }
+ }
+ return string;
+ }
+ shell.setToolTipTitle (hdr.hwndFrom, null, 0);
+ OS.SendMessage (hdr.hwndFrom, OS.TTM_SETMAXTIPWIDTH, 0, 0x7FFF);
+ Control control = display.getControl (hdr.idFrom);
+ return control != null ? control.toolTipText : null;
+}
+
+@Override
+boolean translateMnemonic (Event event, Control control) {
+ if (super.translateMnemonic (event, control)) return true;
+ if (control != null) {
+ Control [] children = _getChildren ();
+ for (int i=0; i TOOLTIP_LIMIT) {
+ string = string.substring(0, TOOLTIP_LIMIT);
+ }
+ /*
+ * Bug 475858: In Japanese like languages where mnemonics are not taken from the
+ * source label text but appended in parentheses like "(&M)" at end. In order to
+ * allow the reuse of such label text as a tool-tip text as well, "(&M)" like
+ * character sequence has to be removed from the end of CJK-style mnemonics.
+ */
+ char [] chars = fixMnemonic (string, false, true);
+
+ /*
+ * Ensure that the orientation of the tool tip matches
+ * the orientation of the control.
+ */
+ Widget widget = null;
+ long hwnd = hdr.idFrom;
+ if ((lpnmtdi.uFlags & OS.TTF_IDISHWND) != 0) {
+ widget = display.getControl (hwnd);
+ } else {
+ if (hdr.hwndFrom == shell.toolTipHandle || hdr.hwndFrom == shell.balloonTipHandle) {
+ widget = shell.findToolTip ((int)hdr.idFrom);
+ }
+ }
+ if (widget != null) {
+ int style = widget.getStyle();
+ int flags = SWT.RIGHT_TO_LEFT | SWT.FLIP_TEXT_DIRECTION;
+ if ((style & flags) != 0 && (style & flags) != flags) {
+ lpnmtdi.uFlags |= OS.TTF_RTLREADING;
+ } else {
+ lpnmtdi.uFlags &= ~OS.TTF_RTLREADING;
+ }
+ }
+ shell.setToolTipText (lpnmtdi, chars);
+ OS.MoveMemory (lParam, lpnmtdi, NMTTDISPINFO.sizeof);
+ return LRESULT.ZERO;
+ }
+ break;
+ }
+ }
+ return super.wmNotify (hdr, wParam, lParam);
+}
+
+}