--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2016 IBM Corporation and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.custom;
+
+
+import org.eclipse.swt.*;
+import org.eclipse.swt.graphics.*;
+import org.eclipse.swt.widgets.*;
+
+/**
+ * The SashForm is a composite control that lays out its children in a
+ * row or column arrangement (as specified by the orientation) and places
+ * a Sash between each child. One child may be maximized to occupy the
+ * entire size of the SashForm. The relative sizes of the children may
+ * be specified using weights.
+ * <dl>
+ * <dt><b>Styles:</b></dt>
+ * <dd>HORIZONTAL, VERTICAL, SMOOTH</dd>
+ * </dl>
+ *
+ * @see <a href="http://www.eclipse.org/swt/snippets/#sashform">SashForm snippets</a>
+ * @see <a href="http://www.eclipse.org/swt/examples.php">SWT Example: CustomControlExample</a>
+ * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
+ */
+public class SashForm extends Composite {
+
+ /**
+ * The width of all sashes in the form.
+ */
+ public int SASH_WIDTH = 3;
+
+ int sashStyle;
+ Sash[] sashes = new Sash[0];
+ // Remember background and foreground
+ // colors to determine whether to set
+ // sashes to the default color (null) or
+ // a specific color
+ Color background = null;
+ Color foreground = null;
+ Control[] controls = new Control[0];
+ Control maxControl = null;
+ Listener sashListener;
+ static final int DRAG_MINIMUM = 20;
+
+/**
+ * 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#HORIZONTAL
+ * @see SWT#VERTICAL
+ * @see #getStyle()
+ */
+public SashForm(Composite parent, int style) {
+ super(parent, checkStyle(style));
+ super.setLayout(new SashFormLayout());
+ sashStyle = ((style & SWT.VERTICAL) != 0) ? SWT.HORIZONTAL : SWT.VERTICAL;
+ if ((style & SWT.BORDER) != 0) sashStyle |= SWT.BORDER;
+ if ((style & SWT.SMOOTH) != 0) sashStyle |= SWT.SMOOTH;
+ sashListener = e -> onDragSash(e);
+}
+static int checkStyle (int style) {
+ int mask = SWT.BORDER | SWT.LEFT_TO_RIGHT | SWT.RIGHT_TO_LEFT;
+ return style & mask;
+}
+Sash createSash() {
+ Sash sash = new Sash(this, sashStyle);
+ sash.setBackground(background);
+ sash.setForeground(foreground);
+ sash.setToolTipText(getToolTipText());
+ sash.addListener(SWT.Selection, sashListener);
+ return sash;
+}
+/**
+ * Returns SWT.HORIZONTAL if the controls in the SashForm are laid out side by side
+ * or SWT.VERTICAL if the controls in the SashForm are laid out top to bottom.
+ *
+ * <p>
+ * To retrieve the bidi orientation of the SashForm use <code>{@link #getStyle()}</code>
+ * and test if the SWT.RIGHT_TO_LEFT or SWT.LEFT_TO_RIGHT bits are set.
+ * </p>
+ *
+ * @return SWT.HORIZONTAL or SWT.VERTICAL
+ */
+@Override
+public int getOrientation() {
+ /*
+ * This call is intentionally commented out, to allow this getter method to be
+ * called from a thread which is different from one that created the widget.
+ */
+ //checkWidget();
+ return (sashStyle & SWT.VERTICAL) != 0 ? SWT.HORIZONTAL : SWT.VERTICAL;
+}
+/**
+ * Returns the width of the sashes when the controls in the SashForm are
+ * laid out.
+ *
+ * @return the width of the sashes
+ *
+ * @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 3.4
+ */
+public int getSashWidth() {
+ checkWidget();
+ return SASH_WIDTH;
+}
+@Override
+public int getStyle() {
+ int style = super.getStyle();
+ style |= getOrientation() == SWT.VERTICAL ? SWT.VERTICAL : SWT.HORIZONTAL;
+ if ((sashStyle & SWT.SMOOTH) != 0) style |= SWT.SMOOTH;
+ return style;
+}
+/**
+ * Answer the control that currently is maximized in the SashForm.
+ * This value may be null.
+ *
+ * @return the control that currently is maximized or null
+ */
+public Control getMaximizedControl(){
+ /*
+ * This call is intentionally commented out, to allow this getter method to be
+ * called from a thread which is different from one that created the widget.
+ */
+ //checkWidget();
+ return this.maxControl;
+}
+/**
+ * Answer the relative weight of each child in the SashForm. The weight represents the
+ * percent of the total width (if SashForm has Horizontal orientation) or
+ * total height (if SashForm has Vertical orientation) each control occupies.
+ * The weights are returned in order of the creation of the widgets (weight[0]
+ * corresponds to the weight of the first child created).
+ *
+ * @return the relative weight of each child
+ *
+ * @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 int[] getWeights() {
+ checkWidget();
+ Control[] cArray = getControls(false);
+ int[] ratios = new int[cArray.length];
+ for (int i = 0; i < cArray.length; i++) {
+ Object data = cArray[i].getLayoutData();
+ if (data != null && data instanceof SashFormData) {
+ ratios[i] = (int)(((SashFormData)data).weight * 1000 >> 16);
+ } else {
+ ratios[i] = 200;
+ }
+ }
+ return ratios;
+}
+Control[] getControls(boolean onlyVisible) {
+ Control[] children = getChildren();
+ Control[] result = new Control[0];
+ for (int i = 0; i < children.length; i++) {
+ if (children[i] instanceof Sash) continue;
+ if (onlyVisible && !children[i].getVisible()) continue;
+
+ Control[] newResult = new Control[result.length + 1];
+ System.arraycopy(result, 0, newResult, 0, result.length);
+ newResult[result.length] = children[i];
+ result = newResult;
+ }
+ return result;
+}
+void onDragSash(Event event) {
+ Sash sash = (Sash)event.widget;
+ int sashIndex = -1;
+ for (int i= 0; i < sashes.length; i++) {
+ if (sashes[i] == sash) {
+ sashIndex = i;
+ break;
+ }
+ }
+ if (sashIndex == -1) return;
+
+ Control c1 = controls[sashIndex];
+ Control c2 = controls[sashIndex + 1];
+ Rectangle b1 = c1.getBounds();
+ Rectangle b2 = c2.getBounds();
+
+ Rectangle sashBounds = sash.getBounds();
+ Rectangle area = getClientArea();
+ boolean correction = false;
+ if (getOrientation() == SWT.HORIZONTAL) {
+ correction = b1.width < DRAG_MINIMUM || b2.width < DRAG_MINIMUM;
+ int totalWidth = b2.x + b2.width - b1.x;
+ int shift = event.x - sashBounds.x;
+ b1.width += shift;
+ b2.x += shift;
+ b2.width -= shift;
+ if (b1.width < DRAG_MINIMUM) {
+ b1.width = DRAG_MINIMUM;
+ b2.x = b1.x + b1.width + sashBounds.width;
+ b2.width = totalWidth - b2.x;
+ event.x = b1.x + b1.width;
+ event.doit = false;
+ }
+ if (b2.width < DRAG_MINIMUM) {
+ b1.width = totalWidth - DRAG_MINIMUM - sashBounds.width;
+ b2.x = b1.x + b1.width + sashBounds.width;
+ b2.width = DRAG_MINIMUM;
+ event.x = b1.x + b1.width;
+ event.doit = false;
+ }
+ Object data1 = c1.getLayoutData();
+ if (data1 == null || !(data1 instanceof SashFormData)) {
+ data1 = new SashFormData();
+ c1.setLayoutData(data1);
+ }
+ Object data2 = c2.getLayoutData();
+ if (data2 == null || !(data2 instanceof SashFormData)) {
+ data2 = new SashFormData();
+ c2.setLayoutData(data2);
+ }
+ ((SashFormData)data1).weight = (((long)b1.width << 16) + area.width - 1) / area.width;
+ ((SashFormData)data2).weight = (((long)b2.width << 16) + area.width - 1) / area.width;
+ } else {
+ correction = b1.height < DRAG_MINIMUM || b2.height < DRAG_MINIMUM;
+ int totalHeight = b2.y + b2.height - b1.y;
+ int shift = event.y - sashBounds.y;
+ b1.height += shift;
+ b2.y += shift;
+ b2.height -= shift;
+ if (b1.height < DRAG_MINIMUM) {
+ b1.height = DRAG_MINIMUM;
+ b2.y = b1.y + b1.height + sashBounds.height;
+ b2.height = totalHeight - b2.y;
+ event.y = b1.y + b1.height;
+ event.doit = false;
+ }
+ if (b2.height < DRAG_MINIMUM) {
+ b1.height = totalHeight - DRAG_MINIMUM - sashBounds.height;
+ b2.y = b1.y + b1.height + sashBounds.height;
+ b2.height = DRAG_MINIMUM;
+ event.y = b1.y + b1.height;
+ event.doit = false;
+ }
+ Object data1 = c1.getLayoutData();
+ if (data1 == null || !(data1 instanceof SashFormData)) {
+ data1 = new SashFormData();
+ c1.setLayoutData(data1);
+ }
+ Object data2 = c2.getLayoutData();
+ if (data2 == null || !(data2 instanceof SashFormData)) {
+ data2 = new SashFormData();
+ c2.setLayoutData(data2);
+ }
+ ((SashFormData)data1).weight = (((long)b1.height << 16) + area.height - 1) / area.height;
+ ((SashFormData)data2).weight = (((long)b2.height << 16) + area.height - 1) / area.height;
+ }
+ if (correction || (event.doit && event.detail != SWT.DRAG)) {
+ c1.setBounds(b1);
+ sash.setBounds(event.x, event.y, event.width, event.height);
+ c2.setBounds(b2);
+ }
+}
+/**
+ * If orientation is SWT.HORIZONTAL, lay the controls in the SashForm
+ * out side by side. If orientation is SWT.VERTICAL, lay the
+ * controls in the SashForm out top to bottom.
+ *
+ * <p>
+ * Since 3.7, this method can also be called with SWT.RIGHT_TO_LEFT or SWT.LEFT_TO_RIGHT
+ * to change the bidi orientation of the SashForm.
+ * </p>
+ *
+ * @param orientation SWT.HORIZONTAL or SWT.VERTICAL, SWT.RIGHT_TO_LEFT or SWT.LEFT_TO_RIGHT
+ *
+ * @see Control#setOrientation(int)
+ *
+ * @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>
+ * <li>ERROR_INVALID_ARGUMENT - if the value of orientation is not SWT.HORIZONTAL or SWT.VERTICAL, SWT.RIGHT_TO_LEFT or SWT.LEFT_TO_RIGHT
+ * </ul>
+ */
+@Override
+public void setOrientation(int orientation) {
+ checkWidget();
+ if (orientation == SWT.RIGHT_TO_LEFT || orientation == SWT.LEFT_TO_RIGHT) {
+ super.setOrientation(orientation);
+ return;
+ }
+ if (getOrientation() == orientation) return;
+ if (orientation != SWT.HORIZONTAL && orientation != SWT.VERTICAL) {
+ SWT.error(SWT.ERROR_INVALID_ARGUMENT);
+ }
+ sashStyle &= ~(SWT.HORIZONTAL | SWT.VERTICAL);
+ sashStyle |= orientation == SWT.VERTICAL ? SWT.HORIZONTAL : SWT.VERTICAL;
+ for (int i = 0; i < sashes.length; i++) {
+ sashes[i].dispose();
+ sashes[i] = createSash();
+ }
+ layout(false);
+}
+@Override
+public void setBackground (Color color) {
+ super.setBackground(color);
+ background = color;
+ for (int i = 0; i < sashes.length; i++) {
+ sashes[i].setBackground(background);
+ }
+}
+@Override
+public void setForeground (Color color) {
+ super.setForeground(color);
+ foreground = color;
+ for (int i = 0; i < sashes.length; i++) {
+ sashes[i].setForeground(foreground);
+ }
+}
+/**
+ * Sets the layout which is associated with the receiver to be
+ * the argument which may be null.
+ * <p>
+ * Note: No Layout can be set on this Control because it already
+ * manages the size and position of its children.
+ * </p>
+ *
+ * @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>
+ */
+@Override
+public void setLayout (Layout layout) {
+ checkWidget();
+ return;
+}
+/**
+ * Specify the control that should take up the entire client area of the SashForm.
+ * If one control has been maximized, and this method is called with a different control,
+ * the previous control will be minimized and the new control will be maximized.
+ * If the value of control is null, the SashForm will minimize all controls and return to
+ * the default layout where all controls are laid out separated by sashes.
+ *
+ * @param control the control to be maximized 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 setMaximizedControl(Control control){
+ checkWidget();
+ if (control == null) {
+ if (maxControl != null) {
+ this.maxControl = null;
+ layout(false);
+ for (int i= 0; i < sashes.length; i++){
+ sashes[i].setVisible(true);
+ }
+ }
+ return;
+ }
+
+ for (int i= 0; i < sashes.length; i++){
+ sashes[i].setVisible(false);
+ }
+ maxControl = control;
+ layout(false);
+}
+
+/**
+ * Specify the width of the sashes when the controls in the SashForm are
+ * laid out.
+ *
+ * @param width the width of the sashes
+ *
+ * @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 3.4
+ */
+public void setSashWidth(int width) {
+ checkWidget();
+ if (SASH_WIDTH == width) return;
+ SASH_WIDTH = width;
+ layout(false);
+}
+@Override
+public void setToolTipText(String string) {
+ super.setToolTipText(string);
+ for (int i = 0; i < sashes.length; i++) {
+ sashes[i].setToolTipText(string);
+ }
+}
+/**
+ * Specify the relative weight of each child in the SashForm. This will determine
+ * what percent of the total width (if SashForm has Horizontal orientation) or
+ * total height (if SashForm has Vertical orientation) each control will occupy.
+ * The weights must be positive values and there must be an entry for each
+ * non-sash child of the SashForm.
+ *
+ * @param weights the relative weight of each child
+ *
+ * @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>
+ * <li>ERROR_INVALID_ARGUMENT - if the weights value is null or of incorrect length (must match the number of children)</li>
+ * </ul>
+ */
+public void setWeights(int[] weights) {
+ checkWidget();
+ Control[] cArray = getControls(false);
+ if (weights == null || weights.length != cArray.length) {
+ SWT.error(SWT.ERROR_INVALID_ARGUMENT);
+ }
+
+ int total = 0;
+ for (int i = 0; i < weights.length; i++) {
+ if (weights[i] < 0) {
+ SWT.error(SWT.ERROR_INVALID_ARGUMENT);
+ }
+ total += weights[i];
+ }
+ if (total == 0) {
+ SWT.error(SWT.ERROR_INVALID_ARGUMENT);
+ }
+ for (int i = 0; i < cArray.length; i++) {
+ Object data = cArray[i].getLayoutData();
+ if (data == null || !(data instanceof SashFormData)) {
+ data = new SashFormData();
+ cArray[i].setLayoutData(data);
+ }
+ ((SashFormData)data).weight = (((long)weights[i] << 16) + total - 1) / total;
+ }
+
+ layout(false);
+}
+}