| /** |
| * |
| * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) |
| * |
| * 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: |
| * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation |
| * |
| * |
| * This copyright notice shows up in the generated Java code |
| * |
| */ |
| |
| package org.eclipse.osbp.xtext.perspective.scoping |
| |
| import org.eclipse.emf.ecore.EObject |
| import org.eclipse.emf.ecore.EReference |
| import org.eclipse.osbp.dsl.xtext.lazyresolver.api.EcoreUtil3 |
| import org.eclipse.osbp.ecview.semantic.uimodel.UiIDEView |
| import org.eclipse.osbp.xtext.blip.Blip |
| import org.eclipse.osbp.xtext.blip.BlipUserTask |
| import org.eclipse.osbp.xtext.dialogdsl.Dialog |
| import org.eclipse.osbp.xtext.perspective.Perspective |
| import org.eclipse.osbp.xtext.perspective.PerspectiveDialog |
| import org.eclipse.osbp.xtext.perspective.PerspectiveDslPackage |
| import org.eclipse.osbp.xtext.perspective.PerspectiveGrid |
| import org.eclipse.osbp.xtext.perspective.PerspectivePartStack |
| import org.eclipse.osbp.xtext.perspective.PerspectiveSashContainer |
| import org.eclipse.osbp.xtext.perspective.PerspectiveSelection |
| import org.eclipse.osbp.xtext.perspective.PerspectiveTable |
| import org.eclipse.osbp.xtext.table.Table |
| import org.eclipse.osbp.xtext.table.TableGrid |
| import org.eclipse.osbp.xtext.table.TableSelection |
| import org.eclipse.osbp.xtext.table.TableTable |
| import org.eclipse.xtext.resource.EObjectDescription |
| import org.eclipse.xtext.resource.IEObjectDescription |
| import org.eclipse.xtext.scoping.IScope |
| import org.eclipse.xtext.scoping.impl.MapBasedScope |
| import org.eclipse.xtext.xbase.annotations.typesystem.XbaseWithAnnotationsBatchScopeProvider |
| |
| class PerspectiveScopeProvider extends XbaseWithAnnotationsBatchScopeProvider { |
| |
| @Override |
| override IScope getScope(EObject context, EReference reference) { |
| if (reference == PerspectiveDslPackage.Literals.PERSPECTIVE_SASH_CONTAINER__SELECTED_ELEMENT) { |
| return getScope_CCPerspectiveSashContainer_selected_element(context) |
| } else if (reference == PerspectiveDslPackage.Literals.PERSPECTIVE_PART_STACK__SELECTED_ELEMENT) { |
| return getScope_CCPerspectivePartStack_selected_element(context) |
| } else if (reference == PerspectiveDslPackage.Literals.PERSPECTIVE__USER_TASK) { |
| return getScope_CCPerspectivePartStack_USER_TASK(context as Perspective) |
| } else if (reference == PerspectiveDslPackage.Literals.PERSPECTIVE_DIALOG__REF) { |
| return getScope_CCPerspectivePartStack_PERSPECTIVE_DIALOG__REF(context as PerspectiveDialog, reference) |
| } else if (reference == PerspectiveDslPackage.Literals.PERSPECTIVE_SELECTION__REF) { |
| return getScope_CCPerspectivePartStack_PERSPECTIVE_SELECTION__REF(context as PerspectiveSelection, reference) |
| } else if (reference == PerspectiveDslPackage.Literals.PERSPECTIVE_TABLE__REF) { |
| return getScope_CCPerspectivePartStack_PERSPECTIVE_TABLE__REF(context as PerspectiveTable, reference) |
| } else if (reference == PerspectiveDslPackage.Literals.PERSPECTIVE_GRID__REF) { |
| return getScope_CCPerspectivePartStack_PERSPECTIVE_GRID__REF(context as PerspectiveGrid, reference) |
| } |
| return super.getScope(context, reference) |
| } |
| |
| def getScope_CCPerspectivePartStack_PERSPECTIVE_DIALOG__REF(PerspectiveDialog dialogView, EReference reference) { |
| val superScope = super.getScope(dialogView, reference) |
| var result = <IEObjectDescription>newArrayList |
| var perspective = dialogView.eContainer |
| while ((perspective != null) && !(perspective instanceof Perspective)) { |
| perspective = perspective.eContainer |
| } |
| if ((perspective as Perspective)?.userTask == null) { |
| return superScope |
| } else { |
| val humanTask = EcoreUtil3.resolve((perspective as Perspective)?.userTask, dialogView.eResource.resourceSet) as BlipUserTask |
| val operativeDto = humanTask.operativeLDto |
| if (operativeDto?.name == null) { |
| return superScope |
| } else { |
| for (element : superScope.allElements) { |
| if (element.EObjectOrProxy instanceof Dialog) { |
| var dialog = element.EObjectOrProxy as Dialog |
| dialog = EcoreUtil3.resolve(dialog, dialogView.eResource.resourceSet) as Dialog |
| if(dialog.uiView != null) { |
| val uiViewObj = EcoreUtil3.resolve(dialog.uiView as EObject, dialogView.eResource.resourceSet) |
| if (uiViewObj instanceof UiIDEView) { |
| val uiView = uiViewObj as UiIDEView |
| for (beanSlot : uiView.beanSlots) { |
| if (operativeDto.name.equals(beanSlot?.jvmType?.type?.simpleName)) { |
| result.add(element) |
| } |
| } |
| } |
| } else if(dialog.dto != null) { |
| if (operativeDto.name.equals(dialog.dto.name)) { |
| result.add(element) |
| } |
| } |
| } |
| } |
| } |
| return MapBasedScope.createScope(IScope.NULLSCOPE, result) |
| } |
| } |
| |
| def getScope_CCPerspectivePartStack_PERSPECTIVE_TABLE__REF(PerspectiveTable tableView, EReference reference) { |
| var superScope = super.getScope(tableView, reference) |
| var result = <IEObjectDescription>newArrayList |
| // extract pure table tables |
| for (element : superScope.allElements) { |
| if (element.EObjectOrProxy instanceof Table) { |
| var table = element.EObjectOrProxy as Table |
| table = EcoreUtil3.resolve(table, tableView.eResource.resourceSet) as Table |
| if (table.tabletype instanceof TableTable) { |
| result.add(element) |
| } |
| else if (table.tabletype instanceof TableGrid) { |
| result.add(element) |
| } |
| } |
| } |
| superScope = MapBasedScope.createScope(IScope.NULLSCOPE, result) |
| result = <IEObjectDescription>newArrayList |
| // check for blip requirements |
| var perspective = tableView.eContainer |
| while ((perspective != null) && !(perspective instanceof Perspective)) { |
| perspective = perspective.eContainer |
| } |
| if ((perspective as Perspective)?.userTask == null) { |
| return superScope |
| } else { |
| // Even not using the return value of this line it is mandatory to initialize lazy loading for bpmn |
| EcoreUtil3.resolve((perspective as Perspective)?.process, tableView.eResource.resourceSet) as Blip |
| val humanTask = EcoreUtil3.resolve((perspective as Perspective)?.userTask, tableView.eResource.resourceSet) as BlipUserTask |
| val operativeDto = humanTask.operativeLDto |
| if (operativeDto?.name == null) { |
| return superScope |
| } else { |
| for (element : superScope.allElements) { |
| if (element.EObjectOrProxy instanceof Table) { |
| var table = element.EObjectOrProxy as Table |
| table = EcoreUtil3.resolve(table, tableView.eResource.resourceSet) as Table |
| if (table.tabletype instanceof TableGrid) { |
| val tableGrid = table.tabletype as TableGrid |
| val tableDtoDatasource = tableGrid?.source |
| val rootTypeDto = tableDtoDatasource?.dtoSource |
| if (operativeDto.name.equals(rootTypeDto.name)) { |
| result.add(element) |
| } |
| } else if (table.tabletype instanceof TableTable) { |
| result.add(element) |
| } |
| } |
| } |
| } |
| return MapBasedScope.createScope(IScope.NULLSCOPE, result) |
| } |
| } |
| |
| def getScope_CCPerspectivePartStack_PERSPECTIVE_SELECTION__REF(PerspectiveSelection selectionView, EReference reference) { |
| var superScope = super.getScope(selectionView, reference) |
| var result = <IEObjectDescription>newArrayList |
| // extract pure select tables |
| for (element : superScope.allElements) { |
| if (element.EObjectOrProxy instanceof Table) { |
| var table = element.EObjectOrProxy as Table |
| table = EcoreUtil3.resolve(table, selectionView.eResource.resourceSet) as Table |
| if (table.tabletype instanceof TableSelection) { |
| result.add(element) |
| } |
| } |
| } |
| superScope = MapBasedScope.createScope(IScope.NULLSCOPE, result) |
| result = <IEObjectDescription>newArrayList |
| // check for blip requirements |
| var perspective = selectionView.eContainer |
| while ((perspective != null) && !(perspective instanceof Perspective)) { |
| perspective = perspective.eContainer |
| } |
| if ((perspective as Perspective)?.userTask == null) { |
| return superScope |
| } else { |
| // Even not using the return value of this line it is mandatory to initialize lazy loading for bpmn |
| EcoreUtil3.resolve((perspective as Perspective)?.process, selectionView.eResource.resourceSet) as Blip |
| val humanTask = EcoreUtil3.resolve((perspective as Perspective)?.userTask, selectionView.eResource.resourceSet) as BlipUserTask |
| val operativeDto = humanTask.operativeLDto |
| if (operativeDto?.name == null) { |
| return superScope |
| } else { |
| for (element : superScope.allElements) { |
| if (element.EObjectOrProxy instanceof Table) { |
| var table = element.EObjectOrProxy as Table |
| table = EcoreUtil3.resolve(table, selectionView.eResource.resourceSet) as Table |
| if (table.tabletype instanceof TableSelection) { |
| result.add(element) |
| } |
| } |
| } |
| } |
| return MapBasedScope.createScope(IScope.NULLSCOPE, result) |
| } |
| } |
| |
| def getScope_CCPerspectivePartStack_PERSPECTIVE_GRID__REF(PerspectiveGrid gridView, EReference reference) { |
| val superScope = super.getScope(gridView, reference) |
| var result = <IEObjectDescription>newArrayList |
| for (element : superScope.allElements) { |
| if (element.EObjectOrProxy instanceof Table) { |
| var table = element.EObjectOrProxy as Table |
| table = EcoreUtil3.resolve(table, gridView.eResource.resourceSet) as Table |
| if (table.tabletype instanceof TableGrid) { |
| result.add(element) |
| } |
| } |
| } |
| return MapBasedScope.createScope(IScope.NULLSCOPE, result) |
| } |
| |
| def getScope_CCPerspectivePartStack_USER_TASK(Perspective perspective) { |
| var result = <IEObjectDescription>newArrayList |
| var blipProcess = perspective.process |
| if (blipProcess != null) { |
| for (item : blipProcess.items) { |
| if (item instanceof BlipUserTask) { |
| result.add(EObjectDescription.create(item.name, item)) |
| } |
| } |
| } |
| return MapBasedScope.createScope(IScope.NULLSCOPE, result) |
| } |
| |
| def getScope_CCPerspectivePartStack_selected_element(EObject object) { |
| var result = <IEObjectDescription>newArrayList |
| if (object instanceof PerspectivePartStack) { |
| var stack = object as PerspectivePartStack |
| for (part : stack.elements) { |
| result.add(EObjectDescription.create(part.elementId, part)) |
| } |
| } |
| return MapBasedScope.createScope(IScope.NULLSCOPE, result) |
| } |
| |
| def getScope_CCPerspectiveSashContainer_selected_element(EObject object) { |
| var result = <IEObjectDescription>newArrayList |
| if (object instanceof PerspectiveSashContainer) { |
| var sash = object as PerspectiveSashContainer |
| for (part : sash.elements) { |
| result.add(EObjectDescription.create(part.elementId, part)) |
| } |
| } |
| return MapBasedScope.createScope(IScope.NULLSCOPE, result) |
| } |
| } |
