/*******************************************************************************
* Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
*
* 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:
* Michael Jastram - initial API and implementation
******************************************************************************/
package org.eclipse.rmf.reqif10.pror.editor.agilegrid;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.agilemore.agilegrid.AgileGrid;
import org.agilemore.agilegrid.Cell;
import org.agilemore.agilegrid.CellDoubleClickEvent;
import org.agilemore.agilegrid.CellResizeAdapter;
import org.agilemore.agilegrid.EditorActivationStrategy;
import org.agilemore.agilegrid.ICellDoubleClickListener;
import org.agilemore.agilegrid.ICellResizeListener;
import org.agilemore.agilegrid.ISelectionChangedListener;
import org.agilemore.agilegrid.SWTX;
import org.agilemore.agilegrid.SelectionChangedEvent;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.util.EContentAdapter;
import org.eclipse.emf.edit.command.AddCommand;
import org.eclipse.emf.edit.command.SetCommand;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter;
import org.eclipse.emf.edit.ui.dnd.LocalTransfer;
import org.eclipse.emf.edit.ui.dnd.ViewerDragAdapter;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.util.LocalSelectionTransfer;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.rmf.reqif10.ReqIF10Factory;
import org.eclipse.rmf.reqif10.ReqIF10Package;
import org.eclipse.rmf.reqif10.SpecHierarchy;
import org.eclipse.rmf.reqif10.SpecObject;
import org.eclipse.rmf.reqif10.SpecRelation;
import org.eclipse.rmf.reqif10.Specification;
import org.eclipse.rmf.reqif10.common.util.ReqIF10Util;
import org.eclipse.rmf.reqif10.pror.configuration.Column;
import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
import org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration;
import org.eclipse.rmf.reqif10.pror.editor.agilegrid.ProrRow.ProrRowSpecHierarchy;
import org.eclipse.rmf.reqif10.pror.editor.agilegrid.ProrRow.ProrRowSpecRelation;
import org.eclipse.rmf.reqif10.pror.filter.ReqifFilter;
import org.eclipse.rmf.reqif10.pror.util.ConfigurationUtil;
import org.eclipse.rmf.reqif10.pror.util.ProrUtil;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DragSource;
import org.eclipse.swt.dnd.DragSourceEvent;
import org.eclipse.swt.dnd.DragSourceListener;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.dnd.DropTargetListener;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.ui.part.PluginTransfer;
/**
* A Viewer that manages an {@link AgileGrid} rendering a
* {@link SpecHierarchyRoot}.
*
* @author jastram
*/
public class ProrAgileGridViewer extends Viewer {
private final ProrAgileGrid agileGrid;
private Specification specification;
private ProrSpecViewConfiguration specViewConfig;
private ProrAgileGridContentProvider contentProvider;
private final EditingDomain editingDomain;
private IStructuredSelection selection;
private ISelectionChangedListener selectionChangedistener;
private EContentAdapter specHierarchyRootContentAdapter;
private Adapter emfColumnListener;
private ICellResizeListener agColumnListener;
private ICellDoubleClickListener doubleClickListener;
/**
* We need to ignore selection requests when a selection is in progress -
* see {@link #setSelection(ISelection, boolean)}
*/
private boolean settingSelection = false;
/**
* We need to temporarily store the dragTarget in order to use the EMF
* DragNDrop Stuff.
*/
protected SpecHierarchy dragTarget;
private EContentAdapter specRelationContentAdapter;
private AdapterFactory adapterFactory;
private AgileCellEditorActionHandler agileCellEditorActionHandler;
/**
* Constructs the Viewer.
*
* @param adapterFactory
*/
public ProrAgileGridViewer(Composite composite,
AdapterFactory adapterFactory, EditingDomain editingDomain,
AgileCellEditorActionHandler agileCellEditorActionHandler) {
agileGrid = new ProrAgileGrid(composite, SWT.V_SCROLL | SWT.H_SCROLL
| SWTX.FILL_WITH_LASTCOL | SWT.MULTI | SWT.DOUBLE_BUFFERED);
agileGrid.setLayoutAdvisor(new ProrLayoutAdvisor(agileGrid));
// agileGrid.setAgileGridEditor(new ProrAgileGridEditor(agileGrid));
agileGrid.setEditorActivationStrategy(new EditorActivationStrategy(
agileGrid, true));
this.editingDomain = editingDomain;
this.adapterFactory = adapterFactory;
this.agileCellEditorActionHandler = agileCellEditorActionHandler;
enableDragNDrop();
enableKeyHandling();
}
private void enableKeyHandling() {
agileGrid.addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
if (e.stateMask == SWT.CTRL
&& (e.keyCode == SWT.CR || e.keyCode == SWT.KEYPAD_CR)) {
e.doit = false;
if (selection.isEmpty()) {
return;
}
Object obj = selection.getFirstElement();
if (!(obj instanceof SpecHierarchy)) {
return;
}
SpecHierarchy specHierarchy = (SpecHierarchy) obj;
if (specHierarchy.getObject() == null) {
return;
}
insertNewRowAndEdit(specHierarchy);
}
}
});
}
/**
* Inserts a new SpecHierarchy as the sibling of this one and starts editing
* it.
*/
private void insertNewRowAndEdit(SpecHierarchy specHierarchy) {
// Won't do anything if there is no object
if (specHierarchy.getObject() == null
|| specHierarchy.getObject().getType() == null) {
return;
}
// Create the new elements
SpecHierarchy newSpecHierarchy = ReqIF10Factory.eINSTANCE
.createSpecHierarchy();
SpecObject newSpecObject = ReqIF10Factory.eINSTANCE.createSpecObject();
newSpecHierarchy.setObject(newSpecObject);
EReference childFeature;
int pos;
EObject parent = specHierarchy.eContainer();
if (parent instanceof SpecHierarchy) {
childFeature = ReqIF10Package.Literals.SPEC_HIERARCHY__CHILDREN;
pos = ((SpecHierarchy) specHierarchy.eContainer()).getChildren()
.indexOf(specHierarchy) + 1;
} else if (parent instanceof Specification) {
childFeature = ReqIF10Package.Literals.SPECIFICATION__CHILDREN;
pos = ((Specification) specHierarchy.eContainer()).getChildren()
.indexOf(specHierarchy) + 1;
} else {
throw new IllegalStateException("Wrong parent: " + parent);
}
CompoundCommand cmd = ProrUtil.createAddTypedElementCommand(ReqIF10Util
.getReqIF(specHierarchy).getCoreContent(),
ReqIF10Package.Literals.REQ_IF_CONTENT__SPEC_OBJECTS,
newSpecObject, ReqIF10Package.Literals.SPEC_OBJECT__TYPE,
specHierarchy.getObject().getType(), -1, 0, editingDomain,
adapterFactory);
cmd.append(AddCommand.create(editingDomain, specHierarchy.eContainer(),
childFeature, newSpecHierarchy, pos));
editingDomain.getCommandStack().execute(cmd);
// The row to be edited may be further down due to indenting.
Cell activeCell = agileGrid.getCellSelection()[0];
int row = activeCell.row + 1;
ProrRow.ProrRowSpecHierarchy prorRowSpecHierarchy = (ProrRow.ProrRowSpecHierarchy) contentProvider
.getProrRow(row);
while (prorRowSpecHierarchy.getSpecHierarchy() != newSpecHierarchy
&& row <= contentProvider.getRowCount()) {
row++;
}
agileGrid.editCell(row, activeCell.column);
}
@Override
public Control getControl() {
return agileGrid;
}
@Override
public Object getInput() {
return specification;
}
@Override
public ISelection getSelection() {
return selection != null ? selection : StructuredSelection.EMPTY;
}
@Override
public void refresh() {
agileGrid.redraw();
}
/**
* This method sets a {@link Specification} as input and registers some
* listeners.
*/
@Override
public void setInput(Object input) {
unregisterColumnListener();
unregisterSelectionChangedListener();
unregisterSpecHierarchyListener();
unregisterSpecRelationListener();
unregisterDoubleClickListener();
this.specification = (Specification) input;
this.specViewConfig = ConfigurationUtil.createSpecViewConfiguration(
specification, editingDomain);
this.contentProvider = new ProrAgileGridContentProvider(specification,
specViewConfig);
agileGrid.setContentProvider(contentProvider);
agileGrid.setCellRendererProvider(new ProrCellRendererProvider(
agileGrid, adapterFactory, editingDomain));
agileGrid.setCellEditorProvider(new ProrCellEditorProvider(agileGrid,
adapterFactory, agileCellEditorActionHandler));
agileGrid.setRowResizeCursor(new Cursor(agileGrid.getDisplay(),
SWT.CURSOR_ARROW));
updateRowCount();
updateColumnInformation();
registerColumnListener();
registerSelectionChangedListener();
registerSpecHierarchyListener();
registerSpecRelationListener();
registerDoubleClickListener();
resolveSpecObjectReferences();
}
/**
* Turns out that it takes a lot of time to resolve the references from
* SpecHierarchy to Specification. This is usually done on demand. This is
* fine, but prevents fast scrolling the first time. Therefore, we do this
* as a background job.
*/
private void resolveSpecObjectReferences() {
Job job = new Job("Resolving SpecObject References") {
@Override
protected IStatus run(IProgressMonitor monitor) {
HashSet<SpecHierarchy> specHierarchies = new HashSet<SpecHierarchy>();
specHierarchies.addAll(specification.getChildren());
monitor.beginTask("Resolving SpecObject References",
contentProvider.getRowCount());
while (!specHierarchies.isEmpty()) {
SpecHierarchy specHierarchy = specHierarchies.iterator()
.next();
specHierarchies.remove(specHierarchy);
specHierarchies.addAll(specHierarchy.getChildren());
// This actually resolves the reference
specHierarchy.getObject();
monitor.worked(1);
}
monitor.done();
return Status.OK_STATUS;
}
};
job.schedule();
}
/**
* Explicit cleanup to prevent strange errors.
*/
public void dispose() {
unregisterColumnListener();
unregisterSelectionChangedListener();
unregisterSpecHierarchyListener();
unregisterSpecRelationListener();
unregisterDoubleClickListener();
if (!agileGrid.isDisposed()) {
agileGrid.dispose();
}
}
private void unregisterColumnListener() {
if (emfColumnListener != null)
specViewConfig.eAdapters().remove(emfColumnListener);
}
/**
* Registers two listeners: (1) Listen to the EMF Model to propagate Column
* changes to the agileGrid; (2) Listen to the agileGrid and propagate
* changes to the EMF Model.
* <p>
*
* (1) Includes column count and labels.<br>
* (2) Includes column width.
*/
private void registerColumnListener() {
emfColumnListener = new AdapterImpl() {
@Override
public void notifyChanged(Notification msg) {
if (!agileGrid.isDisposed()) {
updateColumnInformation();
refresh();
}
}
};
specViewConfig.eAdapters().add(emfColumnListener);
agColumnListener = new CellResizeAdapter() {
@Override
public void columnResized(int col, int newWidth) {
// If the column index is -1 we resized the very first column,
// otherwise we resized a normal column
Column column = (col == -1) ? ConfigurationUtil
.getLeftHeaderColumn(specification, editingDomain)
: specViewConfig.getColumns().get(col);
if (column != null) {
Command cmd = SetCommand.create(editingDomain, column,
ConfigurationPackage.Literals.COLUMN__WIDTH,
newWidth);
editingDomain.getCommandStack().execute(cmd);
}
}
};
agileGrid.addCellResizeListener(agColumnListener);
}
private void unregisterSpecHierarchyListener() {
if (specHierarchyRootContentAdapter != null) {
specification.eAdapters().remove(specHierarchyRootContentAdapter);
}
}
private void unregisterSpecRelationListener() {
if (specRelationContentAdapter != null) {
ReqIF10Util.getReqIF(specification).getCoreContent().eAdapters()
.remove(specRelationContentAdapter);
}
}
/**
* Attaches a Listener to notify the agileGrid when a
* {@link SpecHierarchyRoot} (or any of its children) changes.
*/
private void registerSpecHierarchyListener() {
specHierarchyRootContentAdapter = new EContentAdapter() {
@Override
public void notifyChanged(Notification notification) {
super.notifyChanged(notification);
if (notification.getNewValue() instanceof SpecObject
&& notification.getEventType() == Notification.SET) {
SpecObject specObject = (SpecObject) notification
.getNewValue();
contentProvider.updateElement(specObject);
} else if (notification.getFeature() == ReqIF10Package.Literals.SPECIFICATION__CHILDREN
|| notification.getFeature() == ReqIF10Package.Literals.SPEC_HIERARCHY__CHILDREN) {
updateRowCount();
refresh();
}
}
};
specification.eAdapters().add(specHierarchyRootContentAdapter);
}
private void registerSpecRelationListener() {
specRelationContentAdapter = new EContentAdapter() {
@Override
public void notifyChanged(Notification notification) {
super.notifyChanged(notification);
SpecRelation specRelation = null;
if (notification.getNotifier() instanceof SpecRelation) {
specRelation = (SpecRelation) notification.getNotifier();
}
if (notification.getNewValue() instanceof SpecRelation) {
specRelation = (SpecRelation) notification.getNewValue();
}
if (specRelation != null) {
if (specRelation.getSource() != null) {
contentProvider.updateElement(specRelation.getSource());
}
if (specRelation.getTarget() != null) {
contentProvider.updateElement(specRelation.getTarget());
}
updateRowCount();
// if (contentProvider.getShowSpecRelations()) {
// // By setting the flag again, the cash is cleared,
// // triggering a redraw.
// contentProvider.setShowSpecRelations(true);
// updateRowCount();
// }
refresh();
}
}
};
ReqIF10Util.getReqIF(specification).getCoreContent().eAdapters()
.add(specRelationContentAdapter);
}
private void registerDoubleClickListener() {
doubleClickListener = new ICellDoubleClickListener() {
public void cellDoubleClicked(CellDoubleClickEvent event) {
Object source = event.getSource();
if (source instanceof Cell) {
Cell cell = (Cell) source;
ProrRow prorRow = contentProvider.getProrRow(cell.row);
if (prorRow instanceof ProrRowSpecHierarchy
&& cell.column == specViewConfig.getColumns()
.size()) {
ProrRowSpecHierarchy prorRowSH = (ProrRowSpecHierarchy) prorRow;
prorRowSH.setShowSpecRelation(!prorRowSH
.isShowSpecRelation());
contentProvider.flushCache();
updateRowCount();
refresh();
}
}
}
};
agileGrid.addCellDoubleClickListener(doubleClickListener);
}
private void unregisterDoubleClickListener() {
if (doubleClickListener != null && !agileGrid.isDisposed())
agileGrid.removeDoubleClickListener(doubleClickListener);
}
private void unregisterSelectionChangedListener() {
if (selectionChangedistener != null && !agileGrid.isDisposed())
agileGrid.removeSelectionChangedListener(selectionChangedistener);
}
/**
* Creates an {@link ISelectionChangedListener} for registration with the
* {@link AgileGrid} that relays Selections to the Eclipse environment.
* <p>
*
* What's confusing is that some of the AgileGrid stuff and Eclipse stuff
* has the same name (e.g. SelectionChangedEvent), so be aware of what's
* going on.
*
*/
private void registerSelectionChangedListener() {
// Remove the old listener, if present
if (selectionChangedistener != null) {
agileGrid.removeSelectionChangedListener(selectionChangedistener);
}
// Create a Listener that translates the new selection from Cells to
// SpecHierarchies
selectionChangedistener = new ISelectionChangedListener() {
public void selectionChanged(SelectionChangedEvent event) {
if (settingSelection) {
return;
}
Set<Cell> cells = event.getNewSelections();
List<Object> items = new ArrayList<Object>();
for (Cell cell : cells) {
if (cell.row > -1) {
ProrRow row = contentProvider.getProrRow(cell.row);
// If the item is a SpecRelation and the last column is
// selected, show the target instead.
if (row instanceof ProrRowSpecRelation
&& cell.column == specViewConfig.getColumns()
.size()) {
SpecRelation relation = (SpecRelation) row
.getSpecElement();
if (relation.getTarget() != null) {
items.add(relation.getTarget());
}
} else if (row instanceof ProrRowSpecRelation
&& cell.column < specViewConfig.getColumns()
.size()) {
items.add(row.getSpecElement());
} else if (row instanceof ProrRowSpecHierarchy) {
items.add(((ProrRowSpecHierarchy) row)
.getSpecHierarchy());
} else {
throw new IllegalArgumentException();
}
}
}
// If there are no items, it either means that (1) The user
// explicitly unselected everything, or (2) The user clicked in
// the empty space below the rows. In case of (2), we would like
// the Specification to be the current selection.
if (items.size() == 0) {
items.add(getInput());
}
selection = new StructuredSelection(items);
ProrAgileGridViewer.this
.fireSelectionChanged(new org.eclipse.jface.viewers.SelectionChangedEvent(
ProrAgileGridViewer.this, selection));
}
};
agileGrid.addSelectionChangedListener(selectionChangedistener);
}
/**
* Updates the number so rows. This is an expensive operation, as we have to
* count the elements one by one.
*/
private void updateRowCount() {
agileGrid.getLayoutAdvisor().setRowCount(contentProvider.getRowCount());
}
/**
* Update Column Count, Column Label and Column Width. This should be called
* whenever a Column changes.
* <p>
*
*/
private void updateColumnInformation() {
EList<Column> cols = specViewConfig.getColumns();
Column leftHeaderColumn = ConfigurationUtil.getLeftHeaderColumn(
specification, editingDomain);
// Handle first column
if (leftHeaderColumn != null)
agileGrid.getLayoutAdvisor().setLeftHeaderWidth(
leftHeaderColumn.getWidth());
// One more column for the links
if (!agileGrid.isDisposed()) {
agileGrid.getLayoutAdvisor().setColumnCount(cols.size() + 1);
for (int i = 0; i < cols.size(); i++) {
agileGrid.getLayoutAdvisor().setTopHeaderLabel(i,
cols.get(i).getLabel());
agileGrid.getLayoutAdvisor().setColumnWidth(i,
cols.get(i).getWidth());
}
}
}
/**
* Changes the selection. Note that we are only interested in the selected
* row, not column. Thus, if something is already selected in a certain row
* and the row is supposed to stay selected, then we'll leave the selection
* as is.
* <p>
*
* Further, we are only interested in SpecHierarchies and
* {@link SpecRelation}s. We tried to be smart by accepting SpecObjects as
* well (thereby selecting those SpecHierarchies linked to the SpecObject,
* but this is too expensive on large Specifications.
* <p>
*/
@Override
public void setSelection(ISelection selection, boolean reveal) {
if (!(selection instanceof IStructuredSelection))
return;
// Necessary due to a bug in CellSelectionManager (AgileGrid).
if (settingSelection)
return;
settingSelection = true;
this.selection = (IStructuredSelection) selection;
Set<Cell> cells = new HashSet<Cell>();
for (int row = 0; row < contentProvider.getRowCount(); row++) {
ProrRow prorRow = contentProvider.getProrRow(row);
Object current;
if (prorRow instanceof ProrRow.ProrRowSpecHierarchy)
current = ((ProrRow.ProrRowSpecHierarchy) prorRow)
.getSpecHierarchy();
else
current = prorRow.getSpecElement();
for (Object item : ((IStructuredSelection) selection).toList()) {
if (item.equals(current)) {
boolean added = false;
for (int col = 0; col < agileGrid.getLayoutAdvisor()
.getColumnCount(); col++) {
if (agileGrid.isCellSelected(row, col)) {
cells.add(new Cell(agileGrid, row, col));
added = true;
}
}
if (!added) {
cells.add(new Cell(agileGrid, row, 0));
}
break;
}
}
}
Cell[] cellArray = new Cell[cells.size()];
cells.toArray(cellArray);
// Without clearing the selection, selections would accumulate.
agileGrid.clearSelection();
// Without focusing a cell, we'd get an overflow in CellSelectionManager
// due to a bug there. However, calling focusCell will trigger another
// selection event. This is a reason why we introduced #settingSelection
// to ignore further selection events when we are updating.
if (cellArray.length > 0) {
// We do not want to interrupt editing
if (!agileGrid.isCellEditorActive()) {
agileGrid.focusCell(cellArray[0]);
}
agileGrid.selectCells(cellArray);
org.eclipse.jface.viewers.SelectionChangedEvent event = new org.eclipse.jface.viewers.SelectionChangedEvent(
this, selection);
fireSelectionChanged(event);
}
// Notify all Listeners
settingSelection = false;
}
/**
* Can be called to provide a context menu
*/
public void setContextMenu(MenuManager contextMenu) {
Menu menu = contextMenu.createContextMenu(agileGrid);
agileGrid.setMenu(menu);
}
private void enableDragNDrop() {
int dndOperations = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance(),
LocalSelectionTransfer.getTransfer(),
PluginTransfer.getInstance() };
addDragSupport(dndOperations, transfers, new ViewerDragAdapter(this) {
// Modified to allow resizing of columns
@Override
public void dragStart(DragSourceEvent event) {
Cell cell = agileGrid.getCell(event.x, event.y);
if (cell.row == -1 || cell.column == -1) {
event.doit = false;
}
super.dragStart(event);
}
@Override
public void dragFinished(DragSourceEvent event) {
super.dragFinished(event);
}
});
// Modified to make the EMF-Based Drag and Drop work.
addDropSupport(dndOperations, transfers,
new EditingDomainViewerDropAdapter(editingDomain, this) {
// store if previously hovered over a SpecHirarchy
protected boolean prevTargetIsSpecHierarchy;
protected SpecHierarchy prevTarget;
protected float prevLocation;
/**
* By using an AgileGrid instead of a StructuredViewer, item
* will always be null. Thus, we store the dragTarget when
* dragOver is called.
*/
@Override
public void dragEnter(DropTargetEvent event) {
prevTargetIsSpecHierarchy = false;
prevTarget = null;
prevLocation = -1.0F;
super.dragEnter(event);
}
@Override
public void dragLeave(DropTargetEvent event) {
// clean up highlighting on leave and don't set
// dragTarget to null (still needed)
if (prevTargetIsSpecHierarchy) {
agileGrid.dndHoverCell = null;
// dragTarget = null;
agileGrid.redraw();
prevTargetIsSpecHierarchy = false;
}
super.dragLeave(event);
}
@Override
protected Object extractDropTarget(Widget item) {
return dragTarget;
}
@Override
public void dragOver(DropTargetEvent e) {
Point pos = agileGrid.toControl(e.x, e.y);
Cell cell = agileGrid.getCell(pos.x, pos.y);
// No target if dragged over empty space.
if (cell.equals(Cell.NULLCELL)) {
dragTarget = null;
super.dragOver(e);
return;
}
ProrRow row = cell.row >= 0 ? contentProvider
.getProrRow(cell.row) : null;
Object target = null;
if (row instanceof ProrRowSpecHierarchy) {
target = ((ProrRowSpecHierarchy) row)
.getSpecHierarchy();
} else if (row instanceof ProrRowSpecRelation) {
target = row.getSpecElement();
}
if (target instanceof SpecHierarchy) {
dragTarget = (SpecHierarchy) target;
float location = getLocation(e);
// prevent flickering: redraw only if something
// changed
if ((location != prevLocation)
|| (dragTarget != prevTarget)) {
if (location == 0.5) {
agileGrid.dndHoverCell = cell;
agileGrid.dndHoverDropMode = ProrAgileGrid.DND_DROP_AS_CHILD;
}
if (location == 0.0) {
Cell prevCell = agileGrid.getNeighbor(cell,
AgileGrid.ABOVE, true);
agileGrid.dndHoverCell = prevCell;
agileGrid.dndHoverDropMode = ProrAgileGrid.DND_DROP_AS_SIBLING;
}
if (location == 1.0) {
agileGrid.dndHoverCell = cell;
agileGrid.dndHoverDropMode = ProrAgileGrid.DND_DROP_AS_SIBLING;
}
agileGrid.redraw();
}
prevTargetIsSpecHierarchy = true;
prevTarget = dragTarget;
prevLocation = location;
} else {
// if previously hovered over a SpecHirarchy: redraw
// agileGrid
// once more to Reset highlighting and set
// dragTarget to null
if (prevTargetIsSpecHierarchy) {
agileGrid.dndHoverCell = null;
dragTarget = null;
agileGrid.redraw();
prevTargetIsSpecHierarchy = false;
}
}
super.dragOver(e);
}
@Override
public void drop(DropTargetEvent event) {
super.drop(event);
agileGrid.dndHoverCell = null;
agileGrid.redraw();
}
@Override
protected float getLocation(DropTargetEvent event) {
Point pos = agileGrid.toControl(event.x, event.y);
Cell cell = agileGrid.getCell(pos.x, pos.y);
if (agileGrid.getLayoutAdvisor() instanceof ProrLayoutAdvisor) {
ProrLayoutAdvisor layoutAdvisor = (ProrLayoutAdvisor) agileGrid
.getLayoutAdvisor();
int rowHeight = layoutAdvisor
.getRowHeight(cell.row);
int y = agileGrid.getYForRow(cell.row);
int mouseY = pos.y - y;
float location = (float) mouseY / (float) rowHeight;
if (location < 0.3) {
return 0.0F;
} else if (location <= 0.7) {
return 0.5F;
} else {
return 1.0F;
}
}
return 1.0F;
}
});
}
/**
* Copied from {@link StructuredViewer}
*/
private void addDragSupport(int operations, Transfer[] transferTypes,
DragSourceListener listener) {
Control myControl = getControl();
final DragSource dragSource = new DragSource(myControl, operations);
dragSource.setTransfer(transferTypes);
dragSource.addDragListener(listener);
}
/**
* Copied from {@link StructuredViewer}
*/
private void addDropSupport(int operations, Transfer[] transferTypes,
final DropTargetListener listener) {
DropTarget dropTarget = new DropTarget(agileGrid, operations);
dropTarget.setTransfer(transferTypes);
dropTarget.addDropListener(listener);
}
public void setShowSpecRelations(boolean status) {
contentProvider.setShowSpecRelations(status);
updateRowCount();
agileGrid.redraw();
}
public void setFilter(ReqifFilter filter) {
if (agileGrid.getContentProvider() instanceof ProrAgileGridContentProvider) {
((ProrAgileGridContentProvider) agileGrid.getContentProvider())
.setFilter(filter);
this.refresh();
}
}
}