def IScope scope_Origin_atr(Origin or, EReference ref) {
		Scopes::scopeFor(or.navigateEMF.allReferencesINeed)
	}

	def IScope scope_OtherOrigin_atr(OtherOrigin or, EReference ref) {
		val baseScope = super.delegateGetScope(or, ref)
		//Remove some of the elements in baseScope
		val filteredScope = baseScope
		
		filteredScope
	}	

Transition: event=[Event] '=>' state=[State]

def IScope scope_Transition_state(Transition t, EReference ref) {
		Scopes::scopeFor(t.stateMachine.states.filter[s | s.actions.size == 0])
	}

	def Statemachine stateMachine(Transition t) {
		// navigate from transition to it's parent Statemachine
	}

Statemachine :
  'events'
  (events+=Event)+
  'end'
  ('resetEvents'
  (resetEvents+=[Event])+
  'end')?
  'commands'
  (commands+=Command)+
  'end'
  (states+=State)+;

Statemachine: Event | Command | State

def IScope scope_Transition_state(Transition t, EReference ref) {
		val baseScope = super.delegateGetScope(t, ref)

		// I don't know how to filter here the object IScope
		
		baseScope
	}

val filtscope = new FilteringScope(baseScope, [iod| EObjectOrProxy instanceof State])

public class StatenachineResourceDescriptionStrategy extends
		DefaultResourceDescriptionStrategy {
	
	public static final String HAS_ACTIONS = "HAS_ACTIONS";
	
	@Override
	public boolean createEObjectDescriptions(EObject eObject,
			IAcceptor<IEObjectDescription> acceptor) {
		if (eObject instanceof State) {
			return createStateDescriptions((State) eObject, acceptor);
		}
		return super.createEObjectDescriptions(eObject, acceptor);
	}
	
	public boolean createStateDescriptions(State state, IAcceptor<IEObjectDescription> acceptor) {
		if (getQualifiedNameProvider() == null)
			return false;
		try {
			QualifiedName qualifiedName = getQualifiedNameProvider().getFullyQualifiedName(state);
			if (qualifiedName != null) {
				Map<String, String> data = new HashMap<String, String>();
				data.put(HAS_ACTIONS, Boolean.toString(NodeModelUtils.findNodesForFeature(state, StatemachinePackage.Literals.STATE__ACTIONS).size() > 0));
				acceptor.accept(EObjectDescription.create(qualifiedName, state, data ));
			}
		} catch (Exception exc) {
			exc.printStackTrace();
		}
		return true;
	}

}

public Class<? extends IDefaultResourceDescriptionStrategy> bindIDefaultResourceDescriptionStrategy() {
		return StatenachineResourceDescriptionStrategy.class;
	}

public class StatemachineScopeProvider extends AbstractDeclarativeScopeProvider {
	
	public IScope scope_Transition_state(Transition t, EReference ref) {
		return new FilteringScope(delegateGetScope(t, ref), new Predicate<IEObjectDescription>() {
			
			@Override
			public boolean apply(IEObjectDescription input) {
				String hasActions = input.getUserData(StatenachineResourceDescriptionStrategy.HAS_ACTIONS);
				return hasActions != null && !Boolean.valueOf(hasActions);
			}
		});
	}

}

public class StatemchineImportedNamespaceAwareLocalScopeProvider extends
		ImportedNamespaceAwareLocalScopeProvider {
	
	@Inject
	private IQualifiedNameProvider qualifiedNameProvider;

	@Override
	protected ISelectable internalGetAllDescriptions(final Resource resource) {
		Iterable<EObject> allContents = new Iterable<EObject>(){
			public Iterator<EObject> iterator() {
				return EcoreUtil.getAllContents(resource, false);
			}
		}; 
		Iterable<IEObjectDescription> allDescriptions = scopedElementsFor2(allContents, qualifiedNameProvider);
		return new MultimapBasedSelectable(allDescriptions);
	}
	

	public  <T extends EObject> Iterable<IEObjectDescription> scopedElementsFor2(Iterable<? extends T> elements,
			final Function<T, QualifiedName> nameComputation) {
		Iterable<IEObjectDescription> transformed = Iterables.transform(elements,
				new Function<T, IEObjectDescription>() {
					public IEObjectDescription apply(T from) {
						final QualifiedName qualifiedName = nameComputation.apply(from);
						Map<String, String> data = new HashMap<String, String>();
						if (from instanceof State) {
							data.put(StatenachineResourceDescriptionStrategy.HAS_ACTIONS,Boolean.toString(((State)from).getActions().size() > 0));
							if (qualifiedName != null) 
								return new EObjectDescription(qualifiedName, from, data );
						} else {
							if (qualifiedName != null) 
								return new EObjectDescription(qualifiedName, from, null );
						}
						
						return null;
					}
				});
		return Iterables.filter(transformed, Predicates.notNull());
	}
}

public void configureIScopeProviderDelegate(com.google.inject.Binder binder) {
		binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(StatemchineImportedNamespaceAwareLocalScopeProvider.class);
	}