Content of file GridTableViewerComposite.java

/**
 * Copyright (c) 2011-2019 EclipseSource Muenchen GmbH and others.
 *
 * All rights reserved. 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:
 * Alexandra Buzila - initial API and implementation
 * Johannes Faltermeier - initial API and implementation
 * Lucas Koehler - adaptions to RAP limitations
 ******************************************************************************/
package org.eclipse.emf.ecp.view.spi.table.nebula.grid.rap;

import java.util.List;

import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.emf.databinding.EMFDataBindingContext;
import org.eclipse.emf.ecp.view.spi.table.nebula.grid.rap.menu.GridColumnAction;
import org.eclipse.emf.ecp.view.spi.table.nebula.grid.rap.messages.Messages;
import org.eclipse.emfforms.spi.swt.table.AbstractTableViewerComposite;
import org.eclipse.emfforms.spi.swt.table.ColumnConfiguration;
import org.eclipse.emfforms.spi.swt.table.TableConfiguration;
import org.eclipse.emfforms.spi.swt.table.TableControl;
import org.eclipse.emfforms.spi.swt.table.TableViewerComparator;
import org.eclipse.emfforms.spi.swt.table.TableViewerSWTCustomization;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.layout.AbstractColumnLayout;
import org.eclipse.jface.viewers.ViewerColumn;
import org.eclipse.nebula.jface.gridviewer.GridColumnLayout;
import org.eclipse.nebula.jface.gridviewer.GridTableViewer;
import org.eclipse.nebula.jface.gridviewer.GridViewerColumn;
import org.eclipse.nebula.widgets.grid.Grid;
import org.eclipse.nebula.widgets.grid.GridColumn;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Widget;

/**
 * A {@link Composite} containing a {@link GridTableViewer}.
 *
 * @author Jonas Helming
 *
 */
public class GridTableViewerComposite extends AbstractTableViewerComposite<GridTableViewer> {

	private static final long serialVersionUID = 2569328255801045004L;
	private GridTableViewer gridTableViewer;
	private TableViewerComparator comparator;
	private List<Integer> sortableColumns;

	/**
	 * Default constructor.
	 *
	 * @param parent the parent {@link Composite}
	 * @param style the style bits
	 * @param inputObject the input object
	 * @param customization the {@link TableViewerSWTCustomization}
	 * @param title the title
	 * @param tooltip the tooltip
	 */
	@SuppressWarnings("unchecked")
	public GridTableViewerComposite(Composite parent, int style, Object inputObject,
		TableViewerSWTCustomization customization,
		IObservableValue title, IObservableValue tooltip) {
		super(parent, style, inputObject, customization, title, tooltip);
	}

	@Override
	public GridTableViewer getTableViewer() {
		return gridTableViewer;
	}

	@Override
	protected GridTableViewer createTableViewer(TableViewerSWTCustomization<GridTableViewer> customization,
		Composite viewerComposite) {
		gridTableViewer = customization.createTableViewer(viewerComposite);
		gridTableViewer.getGrid().setAutoHeight(true);
		return gridTableViewer;
	}

	@Override
	protected void configureContextMenu(GridTableViewer tableViewer) {
		final MenuManager menuMgr = new MenuManager();
		menuMgr.setRemoveAllWhenShown(true);

		if (getEnabledFeatures().contains(TableConfiguration.FEATURE_COLUMN_HIDE_SHOW)) {
			menuMgr.addMenuListener(new ColumnHideShowMenuListener());
		}

		// TODO usable when the nebula grid RAP implementation supports header controls
		// if (getEnabledFeatures().contains(TableConfiguration.FEATURE_COLUMN_FILTER)) {
		// menuMgr.addMenuListener(new ColumnFilterMenuListener());
		// }

		final Menu menu = menuMgr.createContextMenu(tableViewer.getControl());
		tableViewer.getControl().setMenu(menu);
	}

	@Override
	protected void configureViewerFilters(GridTableViewer tableViewer) {
		// TODO usable when the nebula grid RAP implementation supports header controls
		// if (getEnabledFeatures().contains(TableConfiguration.FEATURE_COLUMN_FILTER)) {
		// tableViewer.addFilter(new GridColumnFilterViewerFilter(this, tableViewer));
		// }
	}

	@Override
	protected AbstractColumnLayout createLayout(Composite viewerComposite) {
		final GridColumnLayout layout = new GridColumnLayout();
		viewerComposite.setLayout(layout);
		return layout;
	}

	@Override
	public Widget[] getColumns() {
		return gridTableViewer.getGrid().getColumns();
	}

	@Override
	public void addColumnListener(ControlListener columnlistener) {
		for (int i = 0; i < gridTableViewer.getGrid().getColumns().length; i++) {
			final GridColumn gridColumn = gridTableViewer.getGrid().getColumns()[i];
			gridColumn.addControlListener(columnlistener);
		}
	}

	@Override
	public TableControl getTableControl() {
		return new TableControl() {

			@Override
			public boolean isDisposed() {
				return getTableViewer().getGrid().isDisposed();
			}

			@Override
			public int getItemHeight() {
				return getTableViewer().getGrid().getItemHeight();
			}

			@Override
			public boolean getHeaderVisible() {
				return getTableViewer().getGrid().getHeaderVisible();
			}

			@Override
			public int getHeaderHeight() {
				return getTableViewer().getGrid().getHeaderHeight();
			}

			@Override
			public int getItemCount() {
				return getTableViewer().getGrid().getItemCount();
			}
		};
	}

	@Override
	protected ViewerColumn createColumn(final ColumnConfiguration config,
		EMFDataBindingContext emfDataBindingContext, final GridTableViewer tableViewer) {

		final GridViewerColumn column = new GridViewerColumnBuilder(config)
			.withDatabinding(emfDataBindingContext)
			.build(tableViewer);

		column.getColumn().setWordWrap(true);

		return column;
	}

	@Override
	public void setComparator(final TableViewerComparator comparator, List<Integer> sortableColumns) {
		this.comparator = comparator;
		this.sortableColumns = sortableColumns;
		for (int i = 0; i < getTableViewer().getGrid().getColumns().length; i++) {
			if (!sortableColumns.contains(i)) {
				continue;
			}
			final int j = i;
			final GridColumn tableColumn = getTableViewer().getGrid().getColumns()[i];
			final SelectionAdapter selectionAdapter = new SelectionAdapter() {
				@Override
				public void widgetSelected(SelectionEvent e) {
					setCompareColumn(j);
				}
			};
			tableColumn.addSelectionListener(selectionAdapter);
		}

	}

	private ColumnConfiguration getCurrentColumnConfig() {

		final Grid grid = getTableViewer().getGrid();
		final Point cursorLocation = grid.getDisplay().getCursorLocation();
		final GridColumn column = grid.getColumn(grid.toControl(cursorLocation));

		if (column == null) {
			return null;
		}
		return getColumnConfiguration(column);
	}

	/**
	 * Column hide/show menu listener.
	 *
	 * @author Mat Hansen
	 *
	 */
	private class ColumnHideShowMenuListener implements IMenuListener {

		@Override
		public void menuAboutToShow(IMenuManager manager) {
			final ColumnConfiguration columnConfiguration = getCurrentColumnConfig();
			if (columnConfiguration == null) {
				return;
			}
			manager.add(new GridColumnAction(GridTableViewerComposite.this,
				Messages.GridTableViewerComposite_hideColumnAction) {
				@Override
				public void run() {
					columnConfiguration.visible().setValue(Boolean.FALSE);
				}

				@Override
				public boolean isEnabled() {
					if (!super.isEnabled()) {
						return false;
					}
					return columnConfiguration.getEnabledFeatures()
						.contains(ColumnConfiguration.FEATURE_COLUMN_HIDE_SHOW);
				}
			});
			manager.add(new GridColumnAction(GridTableViewerComposite.this,
				Messages.GridTableViewerComposite_showAllColumnsAction) {
				@Override
				public void run() {
					for (final Widget widget : getColumns()) {
						getGridTableViewer().getColumnConfiguration(widget).visible().setValue(Boolean.TRUE);
					}
				}

				@Override
				public boolean isEnabled() {
					return getEnabledFeatures().contains(TableConfiguration.FEATURE_COLUMN_HIDE_SHOW)
						&& hasHiddenColumns();
				}

				boolean hasHiddenColumns() {
					for (final Widget widget : getColumns()) {
						if (!getGridTableViewer().getColumnConfiguration(widget).visible().getValue()) {
							return true;
						}
					}
					return false;
				}
			});
		}

	}

	@Override
	public void setCompareColumn(int columnIndex) {
		// Reset other columns to avoid left over sort indicators
		for (final int index : sortableColumns) {
			final GridColumn column = getTableViewer().getGrid().getColumns()[index];
			if (index != columnIndex && column.getSort() != SWT.NONE) {
				column.setSort(SWT.NONE);
			}
		}
		comparator.setColumn(columnIndex);
		final GridColumn tableColumn = getTableViewer().getGrid().getColumns()[columnIndex];
		tableColumn.setSort(comparator.getDirection());
		gridTableViewer.refresh();
	}

	// TODO usable when the nebula grid RAP implementation supports header controls
	// /**
	// * Column hide/show menu listener.
	// *
	// * @author Mat Hansen
	// *
	// */
	// private class ColumnFilterMenuListener implements IMenuListener {
	//
	// @Override
	// public void menuAboutToShow(IMenuManager manager) {
	// final ColumnConfiguration columnConfiguration = getCurrentColumnConfig();
	// if (columnConfiguration == null) {
	// return;
	// }
	// manager.add(new GridColumnAction(GridTableViewerComposite.this,
	// Messages.GridTableViewerComposite_toggleFilterControlsAction) {
	// @Override
	// public void run() {
	// for (final Widget widget : getColumns()) {
	// PropertyHelper.toggle(
	// getGridTableViewer().getColumnConfiguration(widget).showFilterControl());
	// }
	//
	// // getGrid().recalculateHeader();
	// }
	//
	// @Override
	// public boolean isEnabled() {
	// if (!super.isEnabled()) {
	// return false;
	// }
	// return columnConfiguration.getEnabledFeatures()
	// .contains(ColumnConfiguration.FEATURE_COLUMN_FILTER);
	// }
	// });
	// }
	//
	// }

	// TODO usable when the nebula grid RAP implementation supports header controls
	// /**
	// * Viewer filter for column filter support.
	// *
	// * @author Mat Hansen
	// *
	// */
	// private class GridColumnFilterViewerFilter extends ViewerFilter {
	//
	// private final GridTableViewerComposite tableViewerComposite;
	// private final GridTableViewer tableViewer;
	// private final Grid grid;
	//
	// /**
	// * The Constructor.
	// *
	// * @param tableViewerComposite the Grid table viewer composite.
	// * @param tableViewer the Grid table viewer.
	// */
	// GridColumnFilterViewerFilter(
	// GridTableViewerComposite tableViewerComposite,
	// GridTableViewer tableViewer) {
	// super();
	// this.tableViewerComposite = tableViewerComposite;
	// this.tableViewer = tableViewer;
	// grid = tableViewer.getGrid();
	// }
	//
	// @Override
	// public boolean select(Viewer viewer, Object parentElement, Object element) {
	//
	// if (grid.getItemCount() == 0) {
	// return true;
	// }
	//
	// grid.setRedraw(false);
	// final GridItem dummyItem = new GridItem(grid, SWT.NONE);
	//
	// try {
	//
	// dummyItem.setData(element);
	// final GridViewerRow viewerRow = (GridViewerRow) ((CustomGridTableViewer) tableViewer)
	// .getViewerRowFromItem(dummyItem);
	//
	// for (final Widget widget : getColumns()) {
	//
	// final ColumnConfiguration config = tableViewerComposite.getColumnConfiguration(widget);
	//
	// final Object filter = config.matchFilter().getValue();
	// if (filter == null || String.valueOf(filter).isEmpty()) {
	// continue;
	// }
	//
	// final GridColumn column = (GridColumn) widget;
	// final int columnIndex = tableViewer.getGrid().indexOf(column);
	//
	// final ViewerCell cell = viewerRow.getCell(columnIndex);
	// final CellLabelProvider labelProvider = tableViewer.getLabelProvider(columnIndex);
	// labelProvider.update(cell);
	//
	// if (!matchesColumnFilter(cell.getText(), filter)) {
	// return false;
	// }
	//
	// }
	//
	// } finally {
	// dummyItem.dispose();
	// grid.setRedraw(true);
	// }
	//
	// return true;
	// }
	//
	// /**
	// * Test whether the given value/filter combination matches.
	// *
	// * @param value the value to test
	// * @param filterValue the filter value
	// * @return true if the value matches the filter value
	// */
	// protected boolean matchesColumnFilter(Object value, Object filterValue) {
	//
	// if (filterValue == null) {
	// return false;
	// }
	//
	// return String.valueOf(value).toLowerCase()
	// .contains(String.valueOf(filterValue).toLowerCase());
	// }
	//
	// }

}