Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2006 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation /
  
  package org.eclipse.xtext.ui.editor.tasks.dialogfields;
  
  import java.util.List;
  
  import  org.eclipse.core.runtime.Assert;
  import  org.eclipse.jface.viewers.ColumnLayoutData;
  import  org.eclipse.jface.viewers.ColumnPixelData;
  import  org.eclipse.jface.viewers.ColumnWeightData;
  import  org.eclipse.jface.viewers.DoubleClickEvent;
  import  org.eclipse.jface.viewers.IDoubleClickListener;
  import  org.eclipse.jface.viewers.ILabelProvider;
  import  org.eclipse.jface.viewers.ISelection;
  import  org.eclipse.jface.viewers.ISelectionChangedListener;
  import  org.eclipse.jface.viewers.IStructuredContentProvider;
  import  org.eclipse.jface.viewers.IStructuredSelection;
  import  org.eclipse.jface.viewers.SelectionChangedEvent;
  import  org.eclipse.jface.viewers.StructuredSelection;
  import  org.eclipse.jface.viewers.TableLayout;
  import  org.eclipse.jface.viewers.TableViewer;
  import  org.eclipse.jface.viewers.Viewer;
  import  org.eclipse.jface.viewers.ViewerComparator;
  import  org.eclipse.jface.viewers.ViewerSorter;
  import  org.eclipse.swt.SWT;
  import  org.eclipse.swt.events.ControlAdapter;
  import  org.eclipse.swt.events.ControlEvent;
  import  org.eclipse.swt.events.KeyAdapter;
  import  org.eclipse.swt.events.KeyEvent;
  import  org.eclipse.swt.events.SelectionEvent;
  import  org.eclipse.swt.events.SelectionListener;
  import  org.eclipse.swt.graphics.Point;
  import  org.eclipse.swt.graphics.Rectangle;
  import  org.eclipse.swt.layout.GridData;
  import  org.eclipse.swt.layout.GridLayout;
  import  org.eclipse.swt.widgets.Button;
  import  org.eclipse.swt.widgets.Composite;
  import  org.eclipse.swt.widgets.Control;
  import  org.eclipse.swt.widgets.Display;
  import  org.eclipse.swt.widgets.Label;
  import  org.eclipse.swt.widgets.Table;
  import  org.eclipse.swt.widgets.TableColumn;
A list with a button bar. Typical buttons are 'Add', 'Remove', 'Up' and 'Down'. List model is independent of widget creation. DialogFields controls are: Label, List and Composite containing buttons.
  
  @SuppressWarnings({"rawtypes""unchecked"})
  public class ListDialogField extends DialogField {
  
  	public static class ColumnsDescription {
  		private ColumnLayoutData[] columns;
  		private String[] headers;
  		private boolean drawLines;
  
  		public ColumnsDescription(ColumnLayoutData[] columnsString[] headers,
  				boolean drawLines) {
  			this. = columns;
  			this. = headers;
  			this. = drawLines;
  		}
  
  		public ColumnsDescription(String[] headersboolean drawLines) {
  			this(createColumnWeightData(headers.length), headersdrawLines);
  		}
  
  		public ColumnsDescription(int nColumnsboolean drawLines) {
  			this(createColumnWeightData(nColumns), nulldrawLines);
  		}
  
  		private static ColumnLayoutData[] createColumnWeightData(int nColumns) {
  			ColumnLayoutData[] data = new ColumnLayoutData[nColumns];
  			for (int i = 0; i < nColumnsi++) {
  				data[i] = new ColumnWeightData(1);
  			}
  			return data;
  		}
  	}
  
  	protected TableViewer fTable;
  	protected Control fTableControl;
  	protected ILabelProvider fLabelProvider;
  	protected List fElements;
  	protected ViewerComparator fViewerComparator;
 
 	protected String[] fButtonLabels;
 	private Button[] fButtonControls;
 
 	private boolean[] fButtonsEnabled;
 
 	private int fRemoveButtonIndex;
 	private int fUpButtonIndex;
 	private int fDownButtonIndex;
 
 	private Label fLastSeparator;
 
 	private Composite fButtonsControl;
 	private ISelection fSelectionWhenEnabled;
 
 
 
Creates the ListDialogField.

Parameters:
adapter A listener for button invocation, selection changes. Can be null.
buttonLabels The labels of all buttons: null is a valid array entry and marks a separator.
lprovider The label provider to render the table entries
 
 	public ListDialogField(IListAdapter adapterString[] buttonLabels,
 			ILabelProvider lprovider) {
 		super();
 		 = adapter;
 
 		 = lprovider;
 		 = this;
 
 		 = new ArrayList(10);
 
 		 = buttonLabels;
 		if ( != null) {
 			int nButtons = .;
 			 = new boolean[nButtons];
 			for (int i = 0; i < nButtonsi++) {
 				[i] = true;
 			}
 		}
 
 		 = null;
 		 = null;
 		 = null;
 		 = null;
 
 	}

Sets the index of the 'remove' button in the button label array passed in the constructor. The behavior of the button marked as the 'remove' button will then be handled internally. (enable state, button invocation behavior)
 
 	public void setRemoveButtonIndex(int removeButtonIndex) {
 		Assert.isTrue(removeButtonIndex < .);
 		 = removeButtonIndex;
 	}

Sets the index of the 'up' button in the button label array passed in the constructor. The behavior of the button marked as the 'up' button will then be handled internally. (enable state, button invocation behavior)
 
 	public void setUpButtonIndex(int upButtonIndex) {
 		Assert.isTrue(upButtonIndex < .);
 		 = upButtonIndex;
 	}

Sets the index of the 'down' button in the button label array passed in the constructor. The behavior of the button marked as the 'down' button will then be handled internally. (enable state, button invocation behavior)
 
 	public void setDownButtonIndex(int downButtonIndex) {
 		Assert.isTrue(downButtonIndex < .);
 		 = downButtonIndex;
 	}

Sets the viewer comparator.

Parameters:
viewerComparator The viewer comparator to set
 
 	public void setViewerComparator(ViewerComparator viewerComparator) {
 		 = viewerComparator;
 	}
 
 	public void setTableColumns(ColumnsDescription column) {
 		 = column;
 	}
 
 	// ------ adapter communication
 
 	private void buttonPressed(int index) {
 		if (!managedButtonPressed(index) &&  != null) {
 		}
 	}

Checks if the button pressed is handled internally

Returns:
Returns true if button has been handled.
 
 	protected boolean managedButtonPressed(int index) {
 		if (index == ) {
 			remove();
 		} else if (index == ) {
 			up();
 			if (![index].isEnabled() &&  != -1) {
 			}
 		} else if (index == ) {
 			down();
 			if (![index].isEnabled() &&  != -1) {
 			}
 		} else {
 			return false;
 		}
 		return true;
 	}
 
 	// ------ layout helpers
 
 	/*
 	 * @see DialogField#doFillIntoGrid
 	 */
 	public Control[] doFillIntoGrid(Composite parentint nColumns) {
 		PixelConverter converter = new PixelConverter(parent);
 
 
 		Label label = getLabelControl(parent);
 		GridData gd = gridDataForLabel(1);
 		gd.verticalAlignment = GridData.BEGINNING;
 		label.setLayoutData(gd);
 
 		Control list = getListControl(parent);
 		gd = new GridData();
 		gd.horizontalAlignment = GridData.FILL;
 		gd.grabExcessHorizontalSpace = false;
 		gd.verticalAlignment = GridData.FILL;
 		gd.grabExcessVerticalSpace = true;
 		gd.horizontalSpan = nColumns - 2;
 		gd.widthHint = converter.convertWidthInCharsToPixels(50);
 		gd.heightHint = converter.convertHeightInCharsToPixels(6);
 
 		list.setLayoutData(gd);
 
 		Composite buttons = getButtonBox(parent);
 		gd = new GridData();
 		gd.horizontalAlignment = GridData.FILL;
 		gd.grabExcessHorizontalSpace = false;
 		gd.verticalAlignment = GridData.FILL;
 		gd.grabExcessVerticalSpace = true;
 		gd.horizontalSpan = 1;
 		buttons.setLayoutData(gd);
 
 		return new Control[] { labellistbuttons };
 	}
 
 	/*
 	 * @see DialogField#getNumberOfControls
 	 */
 	public int getNumberOfControls() {
 		return 3;
 	}

Sets the minimal width of the buttons. Must be called after widget creation.
 
 	public void setButtonsMinWidth(int minWidth) {
 		if ( != null) {
 			((GridData) .getLayoutData()).widthHint = minWidth;
 		}
 	}
 
 	// ------ UI creation
 
Returns the list control. When called the first time, the control will be created.

Parameters:
parent The parent composite when called the first time, or null after.
 
 	public Control getListControl(Composite parent) {
 		if ( == null) {
 
 			if ( == null) {
 				Table tableControl = .getTable();
 
 				 = tableControl;
 				tableControl.setLayout(new TableLayout());
 			} else {
 						parent, SWT.NONE);
 				composite.setFont(parent.getFont());
 				 = composite;
 
 				 = createTableViewer(composite);
 				Table tableControl = .getTable();
 
 				tableControl.setHeaderVisible(. != null);
 				tableControl.setLinesVisible(.);
 				ColumnLayoutData[] columns = .;
 				for (int i = 0; i < columns.length; i++) {
 					composite.addColumnData(columns[i]);
 					TableColumn column = new TableColumn(tableControl, SWT.NONE);
 					// tableLayout.addColumnData(columns[i]);
 					if (. != null) {
 						column.setText(.[i]);
 					}
 				}
 			}
 
 			.getTable().addKeyListener(new KeyAdapter() {
 				public void keyPressed(KeyEvent e) {
 				}
 			});
 
 			// fTableControl.setLayout(tableLayout);
 
 			.setContentProvider();
 			.setLabelProvider();
 			.addSelectionChangedListener();
 			.addDoubleClickListener();
 
 
 			if ( != null) {
 				.setComparator();
 			}
 
 			.setEnabled(isEnabled());
 			if ( != null) {
 			}
 		}
 		return ;
 	}

Returns the internally used table viewer.
 
 	public TableViewer getTableViewer() {
 		return ;
 	}
 
 	/*
 	 * Subclasses may override to specify a different style.
 	 */
 	protected int getListStyle() {
 		int style = SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL;
 		if ( != null) {
 			style |= SWT.FULL_SELECTION;
 		}
 		return style;
 	}
 
 	protected TableViewer createTableViewer(Composite parent) {
 		Table table = new Table(parentgetListStyle());
 		table.setFont(parent.getFont());
 		return new TableViewer(table);
 	}
 
 	protected Button createButton(Composite parentString label,
 			SelectionListener listener) {
 		Button button = new Button(parent, SWT.PUSH);
 		button.setFont(parent.getFont());
 		button.setText(label);
 		button.addSelectionListener(listener);
 		GridData gd = new GridData();
 		gd.horizontalAlignment = GridData.FILL;
 		gd.grabExcessHorizontalSpace = true;
 		gd.verticalAlignment = GridData.BEGINNING;
 		gd.widthHint = SWTUtil.getButtonWidthHint(button);
 
 		button.setLayoutData(gd);
 
 		return button;
 	}
 
 	private Label createSeparator(Composite parent) {
 		Label separator = new Label(parent, SWT.SEPARATOR | SWT.HORIZONTAL);
 		separator.setFont(parent.getFont());
 		separator.setVisible(false);
 		GridData gd = new GridData();
 		gd.horizontalAlignment = GridData.FILL;
 		gd.verticalAlignment = GridData.BEGINNING;
 		gd.verticalIndent = 4;
 		separator.setLayoutData(gd);
 		return separator;
 	}

Returns the composite containing the buttons. When called the first time, the control will be created.

Parameters:
parent The parent composite when called the first time, or null after.
 
 	public Composite getButtonBox(Composite parent) {
 		if ( == null) {
 
 			SelectionListener listener = new SelectionListener() {
 				public void widgetDefaultSelected(SelectionEvent e) {
 				}
 
 				public void widgetSelected(SelectionEvent e) {
 				}
 			};
 
 			Composite contents = new Composite(parent, SWT.NONE);
 			contents.setFont(parent.getFont());
 			GridLayout layout = new GridLayout();
 			layout.marginWidth = 0;
 			layout.marginHeight = 0;
 			contents.setLayout(layout);
 
 			if ( != null) {
 				for (int i = 0; i < .i++) {
 					String currLabel = [i];
 					if (currLabel != null) {
 						[i] = createButton(contentscurrLabel,
 								listener);
 						[i].setEnabled(isEnabled()
 								&& [i]);
 					} else {
 						[i] = null;
 						createSeparator(contents);
 					}
 				}
 			}
 
 
 			 = contents;
 		}
 
 		return ;
 	}
 
 	private void doButtonSelected(SelectionEvent e) {
 		if ( != null) {
 			for (int i = 0; i < .i++) {
 				if (e.widget == [i]) {
 					return;
 				}
 			}
 		}
 	}

Handles key events in the table viewer. Specifically when the delete key is pressed.
 
 	protected void handleKeyPressed(KeyEvent event) {
 		if (event.character == SWT.DEL && event.stateMask == 0) {
 			if ( != -1
 					&& isButtonEnabled(.getSelection(),
 			}
 		}
 	}
 
 	// ------ enable / disable management
 
 	/*
 	 * @see DialogField#dialogFieldChanged
 	 */
 	public void dialogFieldChanged() {
 	}
 
 	/*
 	 * Updates the enable state of the all buttons
 	 */
 	protected void updateButtonState() {
 				&& .isEnabled()) {
 			ISelection sel = .getSelection();
 			for (int i = 0; i < .i++) {
 				Button button = [i];
 				if (isOkToUse(button)) {
 					button.setEnabled(isButtonEnabled(seli));
 				}
 			}
 		}
 	}
 
 	protected boolean getManagedButtonState(ISelection selint index) {
 		if (index == ) {
 			return !sel.isEmpty();
 		} else if (index == ) {
 			return !sel.isEmpty() && canMoveUp();
 		} else if (index == ) {
 			return !sel.isEmpty() && canMoveDown();
 		}
 		return true;
 	}
 
 	/*
 	 * @see DialogField#updateEnableState
 	 */
 	protected void updateEnableState() {
 
 		boolean enabled = isEnabled();
 			if (!enabled) {
 				if ( == null) {
 					 = .getSelection();
 				}
 			} else if ( != null) {
 			}
 			.setEnabled(enabled);
 		}
 	}

Sets a button enabled or disabled.
 
 	public void enableButton(int indexboolean enable) {
 		if ( != null && index < .) {
 			[index] = enable;
 		}
 	}
 
 	private boolean isButtonEnabled(ISelection selint index) {
 		boolean extraState = getManagedButtonState(selindex);
 		return isEnabled() && extraState && [index];
 	}
 
 	// ------ model access
 
Sets the elements shown in the list.
 
 	public void setElements(Collection elements) {
 		 = new ArrayList(elements);
 			.refresh();
 		}
 	}

Gets the elements shown in the list. The list returned is a copy, so it can be modified by the user.
 
 	public List getElements() {
 		return new ArrayList();
 	}

Gets the elements shown at the given index.
 
 	public Object getElement(int index) {
 		return .get(index);
 	}

Gets the index of an element in the list or -1 if element is not in list.
 
 	public int getIndexOfElement(Object elem) {
 		return .indexOf(elem);
 	}

Replaces an element.
 
 	public void replaceElement(Object oldElementObject newElement)
 		int idx = .indexOf(oldElement);
 		if (idx != -1) {
 			.set(idxnewElement);
 				List selected = getSelectedElements();
 				if (selected.remove(oldElement)) {
 					selected.add(newElement);
 				}
 				.refresh();
 				selectElements(new StructuredSelection(selected));
 			}
 		} else {
 			throw new IllegalArgumentException();
 		}
 	}

Notifies clients that the element has changed.
 
 	public void elementChanged(Object elementthrows IllegalArgumentException {
 		if (.contains(element)) {
 				.update(elementnull);
 			}
 		} else {
 			throw new IllegalArgumentException();
 		}
 	}

Adds an element at the end of the list.
 
 	public boolean addElement(Object element) {
 		return addElement(element.size());
 	}

Adds an element at a position.
 
 	public boolean addElement(Object elementint index) {
 		if (.contains(element)) {
 			return false;
 		}
 		.add(indexelement);
 			.refresh();
 			.setSelection(new StructuredSelection(element));
 		}
 
 		return true;
 	}

Adds elements at the given index
 
 	public boolean addElements(List elementsint index) {
 
 		int nElements = elements.size();
 
 		if (nElements > 0 && index >= 0 && index <= .size()) {
 			// filter duplicated
 			ArrayList elementsToAdd = new ArrayList(nElements);
 
 			for (int i = 0; i < nElementsi++) {
 				Object elem = elements.get(i);
 				if (!.contains(elem)) {
 					elementsToAdd.add(elem);
 				}
 			}
 			if (!elementsToAdd.isEmpty()) {
 				.addAll(indexelementsToAdd);
 					if (index == .size()) {
 						.add(elementsToAdd.toArray());
 					} else {
 						for (int i = elementsToAdd.size() - 1; i >= 0; i--) {
 							.insert(elementsToAdd.get(i), index);
 						}
 					}
 					.setSelection(new StructuredSelection(elementsToAdd));
 				}
 				return true;
 			}
 		}
 		return false;
 	}

Adds elements at the end of the list.
 
 	public boolean addElements(List elements) {
 		return addElements(elements.size());
 	}

Adds an element at a position.
 
 	public void removeAllElements() {
 		if (.size() > 0) {
 				.refresh();
 			}
 		}
 	}

Removes an element from the list.
 
 	public void removeElement(Object elementthrows IllegalArgumentException {
 		if (.remove(element)) {
 				.remove(element);
 			}
 		} else {
 			throw new IllegalArgumentException();
 		}
 	}

Removes elements from the list.
 
 	public void removeElements(List elements) {
 		if (elements.size() > 0) {
 			.removeAll(elements);
 				.remove(elements.toArray());
 			}
 		}
 	}

Gets the number of elements
 
 	public int getSize() {
 		return .size();
 	}
 
 	public void selectElements(ISelection selection) {
 		 = selection;
 			.setSelection(selectiontrue);
 		}
 	}
 
 	public void selectFirstElement() {
 		Object element = null;
 		if ( != null) {
 			Object[] arr = .toArray();
 			if (arr.length > 0) {
 				element = arr[0];
 			}
 		} else {
 			if (.size() > 0) {
 				element = .get(0);
 			}
 		}
 		if (element != null) {
 			selectElements(new StructuredSelection(element));
 		}
 	}
 
 	public void editElement(Object element) {
 			.refresh(element);
 			.editElement(element, 0);
 		}
 	}
 
 	public void postSetSelection(final ISelection selection) {
 			Display d = .getDisplay();
 			d.asyncExec(new Runnable() {
 				public void run() {
 						selectElements(selection);
 					}
 				}
 			});
 		}
 	}

Refreshes the table.
 
 	public void refresh() {
 		super.refresh();
 			.refresh();
 		}
 	}
 
 	// ------- list maintenance
 
 	private List moveUp(List elementsList move) {
 		int nElements = elements.size();
 		List res = new ArrayList(nElements);
 		Object floating = null;
 		for (int i = 0; i < nElementsi++) {
 			Object curr = elements.get(i);
 			if (move.contains(curr)) {
 				res.add(curr);
 			} else {
 				if (floating != null) {
 					res.add(floating);
 				}
 				floating = curr;
 			}
 		}
 		if (floating != null) {
 			res.add(floating);
 		}
 		return res;
 	}
 
 	private void moveUp(List toMoveUp) {
 		if (toMoveUp.size() > 0) {
 			.reveal(toMoveUp.get(0));
 		}
 	}
 
 	private void moveDown(List toMoveDown) {
 		if (toMoveDown.size() > 0) {
 			.reveal(toMoveDown.get(toMoveDown.size() - 1));
 		}
 	}
 
 	private List reverse(List p) {
 		List reverse = new ArrayList(p.size());
 		for (int i = p.size() - 1; i >= 0; i--) {
 			reverse.add(p.get(i));
 		}
 		return reverse;
 	}
 
 	private void remove() {
 	}
 
 	private void up() {
 	}
 
 	private void down() {
 	}
 
 	public boolean canMoveUp() {
 			int[] indc = .getTable().getSelectionIndices();
 			for (int i = 0; i < indc.lengthi++) {
 				if (indc[i] != i) {
 					return true;
 				}
 			}
 		}
 		return false;
 	}
 
 	public boolean canMoveDown() {
 			int[] indc = .getTable().getSelectionIndices();
 			int k = .size() - 1;
 			for (int i = indc.length - 1; i >= 0; i--, k--) {
 				if (indc[i] != k) {
 					return true;
 				}
 			}
 		}
 		return false;
 	}

Returns the selected elements.
 
 	public List getSelectedElements() {
 		List result = new ArrayList();
 			ISelection selection = .getSelection();
 			if (selection instanceof IStructuredSelection) {
 				Iterator iter = ((IStructuredSelection) selection).iterator();
 				while (iter.hasNext()) {
 					result.add(iter.next());
 				}
 			}
 		}
 		return result;
 	}
 
 	// ------- ListViewerAdapter
 
 	private class ListViewerAdapter implements IStructuredContentProvider,
 			ISelectionChangedListener, IDoubleClickListener {
 
 		// ------- ITableContentProvider Interface ------------
 
 		public void inputChanged(Viewer viewerObject oldInputObject newInput) {
 			// will never happen
 		}
 
 		public void dispose() {
 		}
 
 		public Object[] getElements(Object obj) {
 			return .toArray();
 		}
 
 		// ------- ISelectionChangedListener Interface ------------
 
 		public void selectionChanged(SelectionChangedEvent event) {
 		}
 
 		/*
 		 * (non-Javadoc)
 		 * 
 		 * @see
 		 * org.eclipse.jface.viewers.IDoubleClickListener#doubleClick(org.eclipse
 		 * .jface.viewers.DoubleClickEvent)
 		 */
 		public void doubleClick(DoubleClickEvent event) {
 			doDoubleClick(event);
 		}
 
 	}
 
 	protected void doListSelected(SelectionChangedEvent event) {
 		if ( != null) {
 		}
 	}
 
 	protected void doDoubleClick(DoubleClickEvent event) {
 		if ( != null) {
 		}
 	}

Deprecated:
Use setViewerComparator(ViewerComparator) instead}
 
 	public void setViewerSorter(ViewerSorter sorter) {
 	}

A special composite to layout columns inside a table. The composite is needed since we have to layout the columns "before" the actual table gets layouted. Hence we can't use a normal layout manager.

Should switch to use org.eclipse.jface.layout.TableColumnLayout.

 
 	static class TableLayoutComposite extends Composite {

The number of extra pixels taken as horizontal trim by the table column. To ensure there are N pixels available for the content of the column, assign N+COLUMN_TRIM for the column width.

Should either switch to use org.eclipse.jface.layout.TableColumnLayout or get API from JFace or SWT, see: https://bugs.eclipse.org/bugs/show_bug.cgi?id=218483

Since:
3.1
		private static int COLUMN_TRIM;
		static {
			String platform = SWT.getPlatform();
			if ("win32".equals(platform)) //$NON-NLS-1$
			else if ("carbon".equals(platform)) //$NON-NLS-1$
			else
		private List columns = new ArrayList();

Creates a new TableLayoutComposite.

Parameters:
parent the parent composite
style the SWT style
		public TableLayoutComposite(Composite parentint style) {
			super(parentstyle);
			addControlListener(new ControlAdapter() {
				public void controlResized(ControlEvent e) {
					Rectangle area = getClientArea();
					Table table = (Table) getChildren()[0];
					Point preferredSize = computeTableSize(table);
					int width = area.width - 2 * table.getBorderWidth();
					if (preferredSize.y > area.height) {
						// Subtract the scrollbar width from the total column
						// width
						// if a vertical scrollbar will be required
						Point vBarSize = table.getVerticalBar().getSize();
						width -= vBarSize.x;
					layoutTable(tablewidtharea,
							table.getSize().x < area.width);
			});
		}

Adds a new column of data to this table layout.

Parameters:
data the column layout data
		public void addColumnData(ColumnLayoutData data) {
		// ---- Helpers
		// ----------------------------------------------------------
		// ---------------------------
		private Point computeTableSize(Table table) {
			Point result = table.computeSize(SWT.DEFAULT, SWT.DEFAULT);
			int width = 0;
			int size = .size();
			for (int i = 0; i < size; ++i) {
				ColumnLayoutData layoutData = (ColumnLayoutData) .get(i);
				if (layoutData instanceof ColumnPixelData) {
					ColumnPixelData col = (ColumnPixelData) layoutData;
					width += col.width;
					if (col.addTrim) {
						width += ;
else if (layoutData instanceof ColumnWeightData) {
					ColumnWeightData col = (ColumnWeightData) layoutData;
					width += col.minimumWidth;
else {
					Assert.isTrue(false"Unknown column layout data"); //$NON-NLS-1$
			if (width > result.x)
				result.x = width;
			return result;
		private void layoutTable(Table tableint width, Rectangle area,
				boolean increase) {
			// Layout is being called with an invalid value the first time
			// it is being called on Linux. This method resets the
			// Layout to null so we make sure we run it only when
			// the value is OK.
			if (width <= 1)
				return;
			TableColumn[] tableColumns = table.getColumns();
			int size = Math.min(.size(), tableColumns.length);
			int[] widths = new int[size];
			int fixedWidth = 0;
			int numberOfWeightColumns = 0;
			int totalWeight = 0;
			// First calc space occupied by fixed columns
			for (int i = 0; i < sizei++) {
				ColumnLayoutData col = (ColumnLayoutData) .get(i);
				if (col instanceof ColumnPixelData) {
					ColumnPixelData cpd = (ColumnPixelData) col;
					int pixels = cpd.width;
					if (cpd.addTrim) {
						pixels += ;
					widths[i] = pixels;
					fixedWidth += pixels;
else if (col instanceof ColumnWeightData) {
					ColumnWeightData cw = (ColumnWeightData) col;
					numberOfWeightColumns++;
					// first time, use the weight specified by the column data,
					// otherwise use the actual width as the weight
					// int weight = firstTime ? cw.weight :
					// tableColumns[i].getWidth();
					int weight = cw.weight;
					totalWeight += weight;
else {
					Assert.isTrue(false"Unknown column layout data"); //$NON-NLS-1$
			// Do we have columns that have a weight
			if (numberOfWeightColumns > 0) {
				// Now distribute the rest to the columns with weight.
				int rest = width - fixedWidth;
				int totalDistributed = 0;
				for (int i = 0; i < size; ++i) {
					ColumnLayoutData col = (ColumnLayoutData) .get(i);
					if (col instanceof ColumnWeightData) {
						ColumnWeightData cw = (ColumnWeightData) col;
						// calculate weight as above
						// int weight = firstTime ? cw.weight :
						// tableColumns[i].getWidth();
						int weight = cw.weight;
						int pixels = totalWeight == 0 ? 0 : weight * rest
totalWeight;
						if (pixels < cw.minimumWidth)
							pixels = cw.minimumWidth;
						totalDistributed += pixels;
						widths[i] = pixels;
				// Distribute any remaining pixels to columns with weight.
				int diff = rest - totalDistributed;
				for (int i = 0; diff > 0; ++i) {
					if (i == size)
						i = 0;
					ColumnLayoutData col = (ColumnLayoutData) .get(i);
					if (col instanceof ColumnWeightData) {
						++widths[i];
						--diff;
			if (increase) {
				table.setSize(area.width, area.height);
			for (int i = 0; i < sizei++) {
				tableColumns[i].setWidth(widths[i]);
			if (!increase) {
				table.setSize(area.width, area.height);