use of org.talend.designer.dbmap.ui.visualmap.zone.Zone in project tdi-studio-se by Talend.
the class CompleteDropTargetListener method drop.
// private void showInfos(DropTargetEvent event) {
// System.out.println(event);
// System.out.println("event.feedback=" + event.feedback);
// System.out.println("event.detail=" + event.detail);
// System.out.println("event.operations=" + event.operations);
//
// System.out.println("DND.DROP_DEFAULT=" + DND.DROP_DEFAULT);
// System.out.println("DND.DROP_COPY=" + DND.DROP_COPY);
// System.out.println("DND.DROP_MOVE=" + DND.DROP_MOVE);
// System.out.println("DND.DROP_LINK=" + DND.DROP_LINK);
// System.out.println("DND.DROP_TARGET_MOVE=" + DND.DROP_TARGET_MOVE);
// }
//
@Override
public void drop(DropTargetEvent event) {
super.drop(event);
retrieveInsertionIndicator().setVisible(false);
UIManager uiManager = getUiManager();
DraggedData draggedData = TableEntriesTransfer.getInstance().getDraggedData();
DropContextAnalyzer analyzer = analyzeDropTarget(event, draggedData);
// System.out.println("\n>>drop");
// System.out.println(event);
Point cursorPosition = new Point(event.x, event.y);
// int startInsertAtThisIndex = getItemIndexWhereInsertFromPosition(cursorPosition);
int startInsertAtThisIndex = TableUtils.getItemIndexWhereInsertFromPosition(draggableTable, cursorPosition);
IDbLanguage currentLanguage = getMapperManager().getCurrentLanguage();
DataMapTableView dataMapTableViewTarget = getMapperManager().retrieveDataMapTableView(draggableTable);
Zone zoneTarget = dataMapTableViewTarget.getZone();
uiManager.selectDataMapTableView(dataMapTableViewTarget, true, false);
MetadataTableEditorView metadataEditorView = getUiManager().getMetadataEditorView(dataMapTableViewTarget.getZone());
List<TransferableEntry> transferableEntryList = draggedData.getTransferableEntryList();
int currentIndex = startInsertAtThisIndex;
uiManager.clearLastCreatedInOutColumnEntries();
draggableTable.deselectAll();
ITableEntry currentEntryTarget = getEntryFromPosition(cursorPosition);
ArrayList<String> columnsBeingAdded = new ArrayList<String>();
ArrayList<Integer> columnIndicesToSelect = new ArrayList<Integer>();
ArrayList<ITableEntry> sourceEntriesOfEntriesBeingAdded = new ArrayList<ITableEntry>();
ArrayList<IMetadataColumn> metadataColumnsBeingAdded = new ArrayList<IMetadataColumn>();
boolean targetTableIsFiltersTable = analyzer.targetTableIsFiltersTable();
boolean atLeastOneEntryInserted = false;
boolean insertionEntryMode = analyzer.isInsertionEntryMode();
boolean mapEachSourceToNextTargets = analyzer.isMapOneToOneMode();
TableViewerCreator tableViewerCreatorTarget = null;
if (targetTableIsFiltersTable) {
if (analyzer.targetTableIsWhereFiltersTable()) {
tableViewerCreatorTarget = dataMapTableViewTarget.getTableViewerCreatorForWhereFilters();
} else {
tableViewerCreatorTarget = dataMapTableViewTarget.getTableViewerCreatorForOtherFilters();
}
} else {
tableViewerCreatorTarget = dataMapTableViewTarget.getTableViewerCreatorForColumns();
}
// MapperDropCommand dropCommand = new MapperDropCommand();
// MetadataEditorEvent metadataEditorEvent = new MetadataEditorEvent(MetadataEditorEvent.TYPE.ADD);
ITableEntry lastEntryTarget = null;
for (TransferableEntry transferableEntry : transferableEntryList) {
ITableEntry tableEntrySource = transferableEntry.getTableEntrySource();
IMetadataColumn metadataColumnDragged = transferableEntry.getMetadataColumn();
Zone zoneSourceEntry = (Zone) transferableEntry.getZoneSourceEntry();
TableEntryLocation tableEntryLocationTarget = new TableEntryLocation(dataMapTableViewTarget.getDataMapTable().getName(), tableEntrySource.getName());
if (zoneSourceEntry == Zone.INPUTS && zoneTarget == Zone.INPUTS && tableEntrySource.getParentName().equals(tableEntryLocationTarget.tableName)) {
continue;
} else if (currentEntryTarget != null && !insertionEntryMode) {
modifyExistingEntry(uiManager, analyzer, currentLanguage, currentEntryTarget, columnIndicesToSelect, tableViewerCreatorTarget, lastEntryTarget, tableEntrySource, zoneSourceEntry);
} else {
String columnName = transferableEntry.getTableEntrySource().getName();
tableEntryLocationTarget = getMapperManager().findUniqueLocation(tableEntryLocationTarget, dataMapTableViewTarget.getDataMapTable());
columnName = tableEntryLocationTarget.columnName;
if (currentEntryTarget == null && analyzer.isMapOneToOneMode()) {
currentIndex = tableViewerCreatorTarget.getInputList().size();
columnIndicesToSelect.add(currentIndex);
}
if (zoneSourceEntry == Zone.INPUTS && zoneTarget == Zone.OUTPUTS) {
insertNewInOutEntryFromInputEntry(sourceEntriesOfEntriesBeingAdded, metadataColumnsBeingAdded, // metadataEditorEvent,
tableEntrySource, metadataColumnDragged, columnName);
atLeastOneEntryInserted = true;
} else if (zoneSourceEntry == Zone.OUTPUTS && zoneTarget == Zone.OUTPUTS) {
insertOutpuEntryCopyToOtherOutput(sourceEntriesOfEntriesBeingAdded, metadataColumnsBeingAdded, // metadataEditorEvent,
tableEntrySource, metadataColumnDragged, columnName);
atLeastOneEntryInserted = true;
} else {
// throw new IllegalStateException("Drop case not found !");
}
columnsBeingAdded.add(columnName);
}
lastEntryTarget = currentEntryTarget;
if (mapEachSourceToNextTargets && currentEntryTarget != null) {
currentEntryTarget = getNextEntryTarget(currentEntryTarget, tableViewerCreatorTarget);
}
}
if (!atLeastOneEntryInserted) {
tableViewerCreatorTarget.getTableViewer().refresh();
} else {
updateExpressionsOfInsertedEntries(currentLanguage, metadataEditorView, currentIndex, sourceEntriesOfEntriesBeingAdded, targetTableIsFiltersTable, tableViewerCreatorTarget, // , metadataEditorEvent
metadataColumnsBeingAdded);
for (int i = currentIndex; i < currentIndex + sourceEntriesOfEntriesBeingAdded.size(); i++) {
columnIndicesToSelect.add(i);
}
}
dataMapTableViewTarget.resizeAtExpandedSize();
uiManager.unselectAllEntriesOfAllTables();
uiManager.refreshBackground(true, false);
if (metadataEditorView != null && !targetTableIsFiltersTable) {
metadataEditorView.getTableViewerCreator().getTableViewer().refresh();
}
int[] selection = ArrayUtils.toPrimitive(columnIndicesToSelect.toArray(new Integer[0]));
tableViewerCreatorTarget.getSelectionHelper().setSelection(selection);
ISelection iselection = tableViewerCreatorTarget.getTableViewer().getSelection();
List<ITableEntry> selectedEntries = uiManager.extractSelectedTableEntries(iselection);
uiManager.unselectAllOutputMetaDataEntries();
uiManager.unselectAllInputMetaDataEntries();
uiManager.parseAllExpressionsForAllTables();
getMapperManager().getProblemsManager().checkProblemsForAllEntriesOfAllTables(true);
getUiManager().refreshSqlExpression();
uiManager.selectLinks(dataMapTableViewTarget, selectedEntries, targetTableIsFiltersTable, true);
tableViewerCreatorTarget.getTable().setFocus();
uiManager.setDragging(false);
}
use of org.talend.designer.dbmap.ui.visualmap.zone.Zone in project tdi-studio-se by Talend.
the class CompleteDropTargetListener method updateExpressionsOfInsertedEntries.
/**
* DOC amaumont Comment method "updateExpressionsOfInsertedEntries".
*
* @param uiManager
* @param currentLanguage
* @param metadataEditorView
* @param currentIndex
* @param sourceEntriesOfEntriesBeingAdded
* @param targetTableIsConstraintsTable
* @param tableViewerCreatorTarget
* @param metadataColumnsBeingAdded
* @param metadataEditorEvent
*/
@SuppressWarnings("unchecked")
private void updateExpressionsOfInsertedEntries(IDbLanguage currentLanguage, MetadataTableEditorView metadataEditorView, int currentIndex, ArrayList<ITableEntry> sourceEntriesOfEntriesBeingAdded, boolean targetTableIsConstraintsTable, TableViewerCreator tableViewerCreatorTarget, ArrayList<IMetadataColumn> metadataColumnsBeingAdded) // , MetadataEditorEvent metadataEditorEvent
{
UIManager uiManager = getUiManager();
if (metadataEditorView != null && !targetTableIsConstraintsTable) {
metadataEditorView.getMetadataTableEditor().addAll(currentIndex, metadataColumnsBeingAdded);
// metadataEditorEvent.indexStartInsert = currentIndex;
// IAction action = MetadataEditorActionFactory.getInstance().getAction(metadataEditorView,
// metadataEditorEvent);
// action.run(metadataEditorEvent);
Zone zoneTarget = getMapperManager().retrieveDataMapTableView(tableViewerCreatorTarget.getTable()).getZone();
List<IColumnEntry> lastCreatedTableEntries = uiManager.getLastCreatedInOutColumnEntries();
for (int i = 0; i < lastCreatedTableEntries.size(); i++) {
ITableEntry tableEntrySource = sourceEntriesOfEntriesBeingAdded.get(i);
ITableEntry dataMapTableEntry = lastCreatedTableEntries.get(i);
if (zoneTarget == Zone.INPUTS) {
setDefaultOperator((InputColumnTableEntry) dataMapTableEntry);
}
DataMapTableView dataMapTableView = getMapperManager().retrieveIDataMapTableView(tableEntrySource.getParent());
Zone zoneSource = dataMapTableView.getZone();
String location = null;
if (zoneSource == Zone.OUTPUTS) {
location = tableEntrySource.getExpression();
} else {
location = currentLanguage.getLocation(tableEntrySource.getParentName(), tableEntrySource.getName());
}
if (location != null) {
//$NON-NLS-1$
dataMapTableEntry.setExpression(location + " ");
}
}
}
tableViewerCreatorTarget.getTableViewer().refresh();
List<ITableEntry> refreshedTableEntriesList = tableViewerCreatorTarget.getInputList();
for (ITableEntry tableEntry : refreshedTableEntriesList) {
uiManager.parseExpression(tableEntry.getExpression(), tableEntry, false, true, false);
}
}
use of org.talend.designer.dbmap.ui.visualmap.zone.Zone in project tdi-studio-se by Talend.
the class UIManager method selectDataMapTableView.
/**
* Select a table view.
*
* @param dataMapTableView
* @param useNewCommand
* @param selectAllEntries TODO
*/
public void selectDataMapTableView(final DataMapTableView dataMapTableView, boolean useNewCommand, boolean selectAllEntries) {
TabFolderEditors tabFolderEditors = mapperUI.getTabFolderEditors();
// tabFolderEditors.setSelection(TabFolderEditors.INDEX_TAB_METADATA_EDITOR);
MetadataTableEditorView metadataTableEditorView = null;
MetadataTableEditorView otherMetadataTableEditorView = null;
final Zone currentZone = dataMapTableView.getZone();
List<? extends IDataMapTable> tables = null;
DataMapTableView previousSelectedTableView = null;
DataMapTableView newSelectedTableView = null;
if (currentZone == Zone.INPUTS) {
metadataTableEditorView = tabFolderEditors.getInputMetaEditor();
otherMetadataTableEditorView = tabFolderEditors.getOutputMetaEditor();
tables = mapperManager.getInputTables();
previousSelectedTableView = this.currentSelectedInputTableView;
setCurrentSelectedInputTableView((InputDataMapTableView) dataMapTableView);
newSelectedTableView = dataMapTableView;
} else if (currentZone == Zone.OUTPUTS) {
metadataTableEditorView = tabFolderEditors.getOutputMetaEditor();
otherMetadataTableEditorView = tabFolderEditors.getInputMetaEditor();
tables = mapperManager.getOutputTables();
previousSelectedTableView = this.currentSelectedOutputTableView;
newSelectedTableView = dataMapTableView;
setCurrentSelectedOutputTableView((OutputDataMapTableView) dataMapTableView);
}
updateToolbarButtonsStates(currentZone);
final AbstractInOutTable abstractDataMapTable = (AbstractInOutTable) mapperManager.retrieveIDataMapTable(dataMapTableView);
MetadataTableEditor currentMetadataTableEditor = metadataTableEditorView.getMetadataTableEditor();
final TableViewerCreator dataMapTVCreator = dataMapTableView.getTableViewerCreatorForColumns();
final TableViewer dataMapTableViewer = dataMapTableView.getTableViewerCreatorForColumns().getTableViewer();
if (currentMetadataTableEditor == null || currentMetadataTableEditor != null && newSelectedTableView != previousSelectedTableView) {
if (useNewCommand) {
DataMapTableViewSelectedCommand command = new DataMapTableViewSelectedCommand(this, previousSelectedTableView, dataMapTableView);
mapperManager.executeCommand(command);
}
currentMetadataTableEditor = new MetadataTableEditor(abstractDataMapTable.getMetadataTable(), abstractDataMapTable.getTitle());
currentMetadataTableEditor.setModifiedBeanListenable(metadataTableEditorView.getTableViewerCreator());
final MetadataTableEditorView metadataTableEditorViewFinal = metadataTableEditorView;
final TableViewerCreator metadataTVCreator = metadataTableEditorViewFinal.getTableViewerCreator();
final MetadataTableEditor metadataTableEditor = currentMetadataTableEditor;
modifySelectionChangedListener(currentZone, metadataTableEditorViewFinal, metadataTVCreator, metadataTableEditor, dataMapTableView, previousSelectedTableView);
// init actions listeners for list which contains metadata
metadataTableEditor.addAfterOperationListListener(new IListenableListListener() {
/**
* DOC acer Comment method "handleEvent".
*
* @param event
*/
@Override
public void handleEvent(ListenableListEvent event) {
DataMapTableView view = mapperManager.retrieveIDataMapTableView(abstractDataMapTable);
if (event.type == TYPE.ADDED) {
// metadataEditorTableViewer.refresh();
List<IMetadataColumn> metadataColumns = (List<IMetadataColumn>) event.addedObjects;
lastCreatedInOutColumnEntries.clear();
if (event.index != null) {
int index = event.index;
for (IMetadataColumn metadataColumn : metadataColumns) {
lastCreatedInOutColumnEntries.add(mapperManager.addNewColumnEntry(dataMapTableView, metadataColumn, index++));
}
} else if (event.indicesTarget != null) {
List<Integer> indicesTarget = event.indicesTarget;
int lstSize = indicesTarget.size();
for (int i = 0; i < lstSize; i++) {
Integer indice = indicesTarget.get(i);
IMetadataColumn metadataColumn = metadataColumns.get(i);
lastCreatedInOutColumnEntries.add(mapperManager.addNewColumnEntry(dataMapTableView, metadataColumn, indice));
}
} else {
//$NON-NLS-1$
throw new IllegalStateException(Messages.getString("UIManager.1"));
}
refreshBackground(false, false);
if (event.index != null) {
dataMapTableView.changeSize(view.getPreferredSize(true, false, false), true, true);
dataMapTableViewer.refresh();
dataMapTVCreator.getSelectionHelper().setSelection(event.index);
} else if (event.indicesTarget != null) {
dataMapTableViewer.refresh();
dataMapTableView.changeSize(view.getPreferredSize(false, true, false), true, true);
int[] selection = ArrayUtils.toPrimitive((Integer[]) event.indicesTarget.toArray(new Integer[0]));
dataMapTVCreator.getSelectionHelper().setSelection(selection);
}
mapperManager.getProblemsManager().checkProblemsForAllEntriesOfAllTables(true);
}
if (event.type == TYPE.REMOVED) {
// metadataEditorTableViewer.refresh();
List<IMetadataColumn> metadataColumns = (List<IMetadataColumn>) event.removedObjects;
for (IMetadataColumn metadataColumn : metadataColumns) {
ITableEntry metadataTableEntry = mapperManager.retrieveTableEntry(new TableEntryLocation(abstractDataMapTable.getName(), metadataColumn.getLabel()));
mapperManager.removeTableEntry(metadataTableEntry);
}
dataMapTableViewer.refresh();
dataMapTableView.resizeAtExpandedSize();
resizeTablesZoneViewAtComputedSize(dataMapTableView.getZone());
moveScrollBarZoneAtSelectedTable(dataMapTableView.getZone());
refreshBackground(true, false);
mapperManager.getProblemsManager().checkProblemsForAllEntriesOfAllTables(true);
}
if (event.type == TYPE.SWAPED) {
List<Integer> listIndexTarget = event.indicesTarget;
abstractDataMapTable.swapColumnElements(event.indicesOrigin, listIndexTarget);
// dataMapTableViewer.refresh();
refreshBackground(true, false);
}
}
});
metadataTableEditorView.getTableViewerCreator().getSelectionHelper().setActiveFireSelectionChanged(false);
metadataTableEditorView.setMetadataTableEditor(metadataTableEditor);
metadataTableEditorView.getTableViewerCreator().getSelectionHelper().setActiveFireSelectionChanged(true);
metadataTableEditorView.getExtendedToolbar().updateEnabledStateOfButtons();
dataMapTVCreator.getSelectionHelper().setActiveFireSelectionChanged(false);
metadataTableEditorView.getTableViewerCreator().getSelectionHelper().setSelection(dataMapTableViewer.getTable().getSelectionIndices());
dataMapTVCreator.getSelectionHelper().setActiveFireSelectionChanged(true);
// disable highlight for other DataMapTableView and highlight selected DataMapTableView
for (IDataMapTable table : tables) {
DataMapTableView otherDataMapTableView = mapperManager.retrieveIDataMapTableView(table);
otherDataMapTableView.setBackground(dataMapTableView.getDisplay().getSystemColor(SWT.COLOR_WIDGET_LIGHT_SHADOW));
}
dataMapTableView.setBackground(dataMapTableView.getDisplay().getSystemColor(SWT.COLOR_YELLOW));
}
if (selectAllEntries) {
dataMapTVCreator.getTable().selectAll();
selectAllLinks(dataMapTableView);
metadataTableEditorView.getTableViewerCreator().getTable().selectAll();
metadataTableEditorView.getToolBar().updateEnabledStateOfButtons();
if (currentZone == Zone.OUTPUTS) {
dataMapTableView.getTableViewerCreatorForWhereFilters().getTable().selectAll();
dataMapTableView.getTableViewerCreatorForOtherFilters().getTable().selectAll();
}
}
if (otherMetadataTableEditorView != null) {
otherMetadataTableEditorView.getExtendedToolbar().updateEnabledStateOfButtons();
}
}
use of org.talend.designer.dbmap.ui.visualmap.zone.Zone in project tdi-studio-se by Talend.
the class UIManager method selectLinks.
/**
* Highlight links and linked cells which have are referenced by the selected items.
*
* @param dataMapTableView
* @param selectedMetadataTableEntries, source or targets entries which must be highlighted, can be null to select
* all links of a same DataMapTableView
* @param isFilterTableSelected TODO
* @param forceResetHighlightLinksForOtherTables TODO
*/
@SuppressWarnings("unchecked")
public void selectLinks(DataMapTableView dataMapTableView, List<ITableEntry> selectedMetadataTableEntries, boolean isFilterTableSelected, boolean forceResetHighlightLinksForOtherTables) {
boolean selectColumnAndFiltersLinks = (selectedMetadataTableEntries == null);
UIManager uiManager = mapperManager.getUiManager();
TableViewerCreator<ITableEntry> currentTableViewer = null;
TableViewerCreator<ITableEntry> whereFilterCreator = null;
TableViewerCreator<ITableEntry> otherFilterCreator = null;
if (isFilterTableSelected) {
currentTableViewer = dataMapTableView.getTableViewerCreatorForWhereFilters();
} else {
currentTableViewer = dataMapTableView.getTableViewerCreatorForColumns();
}
// Color selectedColor = dataMapTableView.getDisplay().getSystemColor(SWT.COLOR_YELLOW);
Color unselectedColor = dataMapTableView.getDisplay().getSystemColor(SWT.COLOR_WHITE);
Zone currentZone = dataMapTableView.getZone();
Set<ITableEntry> hashSelectedMetadataTableEntries = new HashSet<ITableEntry>();
if (selectColumnAndFiltersLinks) {
hashSelectedMetadataTableEntries.addAll(dataMapTableView.getTableViewerCreatorForColumns().getInputList());
if (currentZone == Zone.OUTPUTS) {
hashSelectedMetadataTableEntries.addAll(dataMapTableView.getTableViewerCreatorForWhereFilters().getInputList());
hashSelectedMetadataTableEntries.addAll(dataMapTableView.getTableViewerCreatorForOtherFilters().getInputList());
}
} else {
hashSelectedMetadataTableEntries.addAll(selectedMetadataTableEntries);
}
// ////////////////////////////////////////////////////////////////////////
// Unselect all links and tableEntries if Ctrl or Shift keys are not pressed or if zone different of last
// selection
boolean zoneHasChanged = previousSelectedZone == Zone.INPUTS && currentZone == Zone.OUTPUTS || currentZone == Zone.INPUTS && previousSelectedZone == Zone.OUTPUTS;
boolean tableTypeHasChanged = previousSelectedTableIsConstraint != isFilterTableSelected && currentZone == Zone.OUTPUTS;
boolean resetHighlightObjectsForOtherTables = !uiManager.isDragging() && (!uiManager.isCtrlPressed() && !uiManager.isShiftPressed() || zoneHasChanged);
if (resetHighlightObjectsForOtherTables || forceResetHighlightLinksForOtherTables) {
for (IMapperLink link : mapperManager.getLinks()) {
if (!hashSelectedMetadataTableEntries.contains(link.getPointLinkDescriptor1().getTableEntry()) && !hashSelectedMetadataTableEntries.contains(link.getPointLinkDescriptor2().getTableEntry())) {
link.setState(LinkState.UNSELECTED);
ITableEntry sourceITableEntry = link.getPointLinkDescriptor1().getTableEntry();
TableItem tableItem = mapperManager.retrieveTableItem(sourceITableEntry);
tableItem.setBackground(unselectedColor);
ITableEntry targetITableEntry = link.getPointLinkDescriptor2().getTableEntry();
tableItem = mapperManager.retrieveTableItem(targetITableEntry);
tableItem.setBackground(unselectedColor);
}
}
if (currentZone == Zone.INPUTS) {
unselectAllOutputMetaDataEntries();
} else if (currentZone == Zone.OUTPUTS) {
unselectAllInputMetaDataEntries();
}
Collection<DataMapTableView> tablesToDeselectEntries = mapperManager.getTablesView();
for (DataMapTableView viewToDeselectEntries : tablesToDeselectEntries) {
if (viewToDeselectEntries != dataMapTableView) {
viewToDeselectEntries.unselectAllEntries();
} else if (viewToDeselectEntries == dataMapTableView && tableTypeHasChanged) {
if (isFilterTableSelected) {
viewToDeselectEntries.unselectAllColumnEntries();
} else {
viewToDeselectEntries.unselectAllConstraintEntries();
}
}
}
}
// ////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////
// Select or unselect links and tableEntries
List<ITableEntry> allEntriesOfCurrentTableView = new ArrayList<ITableEntry>();
if (currentTableViewer != null) {
allEntriesOfCurrentTableView.addAll(currentTableViewer.getInputList());
if (selectColumnAndFiltersLinks && currentZone == Zone.OUTPUTS) {
allEntriesOfCurrentTableView.addAll(dataMapTableView.getTableViewerCreatorForWhereFilters().getInputList());
allEntriesOfCurrentTableView.addAll(dataMapTableView.getTableViewerCreatorForOtherFilters().getInputList());
}
}
int lstSize = allEntriesOfCurrentTableView.size();
Set<IMapperLink> linksAlreadySelected = new HashSet<IMapperLink>();
for (int i = 0; i < lstSize; i++) {
ITableEntry entry = allEntriesOfCurrentTableView.get(i);
Set<IMapperLink> linksFromSource = mapperManager.getGraphicalLinksFromSource(entry);
Set<IMapperLink> linksFromTarget = mapperManager.getGraphicalLinksFromTarget(entry);
LinkState linkState = null;
if (hashSelectedMetadataTableEntries.contains(entry)) {
linkState = LinkState.SELECTED;
} else {
linkState = LinkState.UNSELECTED;
}
for (IMapperLink link : linksFromSource) {
ITableEntry targetITableEntry = link.getPointLinkDescriptor2().getTableEntry();
if (linkState == LinkState.SELECTED || !linksAlreadySelected.contains(link) && linkState == LinkState.UNSELECTED) {
link.setState(linkState);
if (linkState == LinkState.SELECTED) {
linksAlreadySelected.add(link);
}
}
EntryState entryState = (link.getState() == LinkState.SELECTED ? EntryState.HIGHLIGHT : EntryState.NONE);
setEntryState(mapperManager, entryState, targetITableEntry);
}
for (IMapperLink link : linksFromTarget) {
ITableEntry sourceITableEntry = link.getPointLinkDescriptor1().getTableEntry();
if (linkState == LinkState.SELECTED || !linksAlreadySelected.contains(link) && linkState == LinkState.UNSELECTED) {
link.setState(linkState);
if (linkState == LinkState.SELECTED) {
linksAlreadySelected.add(link);
}
}
EntryState entryState = (link.getState() == LinkState.SELECTED ? EntryState.HIGHLIGHT : EntryState.NONE);
setEntryState(mapperManager, entryState, sourceITableEntry);
}
}
// ////////////////////////////////////////////////////////////////////////
// order links to place selected links at last position (last drawn)
mapperManager.orderLinks();
uiManager.refreshBackground(false, false);
previousSelectedZone = dataMapTableView.getZone();
previousSelectedTableIsConstraint = isFilterTableSelected;
}
Aggregations