package org.eclipse.stem.ui.views.explorer;

/*******************************************************************************
 * Copyright (c) 2008 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.edit.provider.DelegatingWrapperItemProvider;
import org.eclipse.jface.viewers.IElementComparer;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.stem.core.CorePlugin;
import org.eclipse.stem.core.common.Identifiable;
import org.eclipse.stem.core.experiment.Experiment;
import org.eclipse.stem.core.graph.Graph;
import org.eclipse.stem.core.model.Decorator;
import org.eclipse.stem.core.model.Model;
import org.eclipse.stem.core.predicate.IdentifiablePredicateExpression;
import org.eclipse.stem.core.scenario.Scenario;
import org.eclipse.stem.core.trigger.Trigger;
import org.eclipse.stem.ui.Activator;
import org.eclipse.stem.ui.Utility;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.navigator.CommonViewer;
import org.eclipse.ui.progress.UIJob;

/**
 * This class is a {@link ITreeContentProvider} for
 * {@link IdentifiableInstanceTreeNode}s which appear in the
 * {@link CommonNavigator} framework that is used to explore STEM Projects.
 */
@SuppressWarnings("unused")
public class IdentifiableContentProvider implements ITreeContentProvider,
		IResourceChangeListener, IResourceDeltaVisitor {

	Viewer viewer;

	/**
	 * Default Constructor
	 */
	public IdentifiableContentProvider() {
		ResourcesPlugin.getWorkspace().addResourceChangeListener(this,
				IResourceChangeEvent.POST_CHANGE);
	}

	/**
	 * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)
	 */
	public Object[] getChildren(Object parentElement) {
		Object[] retValue = null;
		// Right kind of parent?
		if (parentElement instanceof IdentifiableTreeNode) {
			// Yes
			// if IdentifiableTreeNode
			final List<Identifiable> temp = new ArrayList<Identifiable>();

			final IdentifiableTreeNode itn = (IdentifiableTreeNode) parentElement;

			final IFolder folder = itn.getProject().getFolder(
					itn.getFolderName());

			// Does the folder exist?
			if (folder.exists()) {
				// Yes
				try {
					for (final IResource identifiableFile : folder.members()) {
						if(identifiableFile instanceof IFile) {
							IFile ifile = (IFile) identifiableFile;
							// exclude any operating system files starting with '.'
							if((ifile.getName().length()>0)&&( ifile.getName().charAt(0)!='.' ) && !ifile.getName().endsWith("~")) {
								try {
									final Identifiable identifiable = Utility.getIdentifiable((IFile) identifiableFile);
									if(identifiable != null) temp.add(identifiable);
								} catch (final Throwable t) {
									// here we want to protect the user and allow non STEM files in each Directory
									// Just catch any exception and continue
									Activator.logInformation("Error loading file "+ifile.getName()+" for display", t);
								}

							}
						} // if instanceOF IFILE else might be folder or some other object created outside of STEM ...
						
					}
				} catch (final CoreException ce) {
					Activator.logError("", ce);
				} // for each IResource folder.members()
			} // if folder exists

			retValue = temp.toArray();

		} else {
			retValue = new Object[0];
		}

		return retValue;
	} // getChildren

	/**
	 * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object)
	 */
	public Object getParent(Object element) {
		Object retValue = null;
		if (element instanceof IdentifiableInstanceTreeNode) {
			retValue = ((IdentifiableInstanceTreeNode) element).getParent();
		} // if IdentifiableInstanceTreeNode
		return retValue;
	}

	/**
	 * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)
	 */
	public boolean hasChildren(Object element) {
		Object[] children = getChildren(element);
		return children != null && children.length > 0;
	}

	/**
	 * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
	 */
	public Object[] getElements(Object inputElement) {
		return null;
	}

	/**
	 * @see org.eclipse.jface.viewers.IContentProvider#dispose()
	 */
	public void dispose() {
		ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
	}

	/**
	 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
	 *      java.lang.Object, java.lang.Object)
	 */
	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		this.viewer = viewer;
		
		((StructuredViewer)viewer).setComparer(new IElementComparer() {
			
			public int hashCode(Object element) {
				return element.hashCode();
			}
			
			public boolean equals(Object a, Object b) {
				Object aRep=a, bRep=b;
				while(aRep instanceof DelegatingWrapperItemProvider)
					aRep = ((DelegatingWrapperItemProvider)aRep).getValue();
				while(bRep instanceof DelegatingWrapperItemProvider)
					bRep = ((DelegatingWrapperItemProvider)bRep).getValue();
				
				if(aRep instanceof Identifiable && bRep instanceof Identifiable)
					return ((Identifiable)aRep).getURI().toString().equals(((Identifiable)bRep).getURI().toString());
				
				return aRep.equals(bRep);
			}
		});
	}

	/**
	 * @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org
	 *      .eclipse.core.resources.IResourceChangeEvent)
	 */
	public void resourceChanged(final IResourceChangeEvent event) {
		try {
			event.getDelta().accept(this);
		} catch (final CoreException e) {
			Activator.logError("", e);
		}
	} // resourceChanged

	/**
	 * @see org.eclipse.core.resources.IResourceDeltaVisitor#visit(org.eclipse.core
	 *      .resources.IResourceDelta)
	 */
	public boolean visit(final IResourceDelta delta) throws CoreException {
		
		final IResource source = delta.getResource(); 

	
		IPath path = delta.getFullPath();

/*		Activator.logInformation("Path: "+path);
		if((delta.getKind()&IResourceDelta.ADDED) == IResourceDelta.ADDED) Activator.logInformation("ADDED");
		if((delta.getKind()&IResourceDelta.ADDED_PHANTOM) == IResourceDelta.ADDED_PHANTOM) Activator.logInformation("ADDED_PHANTOM");
		if((delta.getKind()&IResourceDelta.ALL_WITH_PHANTOMS) == IResourceDelta.ALL_WITH_PHANTOMS) Activator.logInformation("ALL_WITH_PHANTOMS");
		if((delta.getKind()&IResourceDelta.CHANGED) == IResourceDelta.CHANGED) Activator.logInformation("CHANGED");
		if((delta.getKind()&IResourceDelta.CONTENT) == IResourceDelta.CONTENT) Activator.logInformation("CONTENT");
		if((delta.getKind()&IResourceDelta.COPIED_FROM) == IResourceDelta.COPIED_FROM) Activator.logInformation("COPIED_FROM");
		if((delta.getKind()&IResourceDelta.DESCRIPTION) == IResourceDelta.DESCRIPTION) Activator.logInformation("DESCRIPTION");
		if((delta.getKind()&IResourceDelta.ENCODING) == IResourceDelta.ENCODING) Activator.logInformation("ENCODING");
		if((delta.getKind()&IResourceDelta.LOCAL_CHANGED) == IResourceDelta.LOCAL_CHANGED) Activator.logInformation("LOCAL_CHANGED");
		if((delta.getKind()&IResourceDelta.MARKERS) == IResourceDelta.MARKERS) Activator.logInformation("MARKERS");
		if((delta.getKind()&IResourceDelta.MOVED_FROM) == IResourceDelta.MOVED_FROM) Activator.logInformation("MOVED_FROM");
		if((delta.getKind()&IResourceDelta.MOVED_TO) == IResourceDelta.MOVED_TO) Activator.logInformation("MOVED_TO");
		//if((delta.getKind()&IResourceDelta.NO_CHANGE) == IResourceDelta.NO_CHANGE) Activator.logInformation("NO_CHANGE");
		if((delta.getKind()&IResourceDelta.OPEN) == IResourceDelta.OPEN) Activator.logInformation("OPEN");
		if((delta.getKind()&IResourceDelta.REMOVED) == IResourceDelta.REMOVED) Activator.logInformation("REMOVED");
		if((delta.getKind()&IResourceDelta.REMOVED_PHANTOM) == IResourceDelta.REMOVED_PHANTOM) Activator.logInformation("REMOVED_PHANTOM");
		if((delta.getKind()&IResourceDelta.REPLACED) == IResourceDelta.REPLACED) Activator.logInformation("REPLACED");
		if((delta.getKind()&IResourceDelta.REMOVED_PHANTOM) == IResourceDelta.REMOVED_PHANTOM) Activator.logInformation("REMOVED_PHANTOM");
		if((delta.getKind()&IResourceDelta.REPLACED) == IResourceDelta.REPLACED) Activator.logInformation("REPLACED");
		if((delta.getKind()&IResourceDelta.SYNC) == IResourceDelta.SYNC) Activator.logInformation("SYNC");
		if((delta.getKind()&IResourceDelta.TYPE) == IResourceDelta.TYPE) Activator.logInformation("TYPE");
*/	
				
		
		URI uri = URI.createPlatformResourceURI(path.toString(), false);
		
		for(Resource r: org.eclipse.stem.core.Utility.resourceSet.getResources()) 
			if(r.getURI().equals(uri)) {
				r.setModified(true);
				break;
			}
		
		switch ( source.getType() ) { 
			case IResource.FOLDER: 
				final IFolder f = (IFolder)source; 
				new UIJob("Update Folder") { 
					public IStatus runInUIThread(IProgressMonitor monitor) { 
						if (viewer != null 
								&& !viewer.getControl().isDisposed()) {
							refreshViewer((CommonViewer)viewer, f);						
						} 
						return Status.OK_STATUS; 
					} 
				}.schedule(); 
				break;
		case IResource.ROOT: 
			new UIJob("Update Root") { 
				public IStatus runInUIThread(IProgressMonitor monitor) { 
					if (viewer != null 
							&& !viewer.getControl().isDisposed()) { 
						refreshViewer((CommonViewer)viewer, source);
					} 
					return Status.OK_STATUS; 
				} 
			}.schedule(); 
			break;
		case IResource.PROJECT: 
			final IProject project = (IProject)source; 
			new UIJob("Update Project") { 
				public IStatus runInUIThread(IProgressMonitor monitor) { 
					if (viewer != null 
							&& !viewer.getControl().isDisposed()) { 
						refreshViewer((CommonViewer)viewer, project);
					} 
					return Status.OK_STATUS; 
				} 
			}.schedule();  
			break;
		case IResource.FILE: 
			final IFile file = (IFile) source; 
			// When files are updated, we need to mark as modified other files that also needs to 
			// be refreshed since they are indirectly referencing the changed file
			this.markIndirectFiles(delta);
			new UIJob("Update File") { 
				public IStatus runInUIThread(IProgressMonitor monitor) 
				{ 
					if (viewer != null 
							&& !viewer.getControl().isDisposed()) { 
						refreshViewer((CommonViewer)viewer, file);
					} 
					return Status.OK_STATUS; 
				} 
			}.schedule(); 
			return false; 
		default: 
			break;
		}
		return true; 		
	} // visit

	private void refreshViewer(CommonViewer v, Object elm) {
		TreePath [] expPaths = v.getExpandedTreePaths();
		v.refresh(elm); 
		// The last element in the tree paths containing models, scenarios etc. have
		// potentially been reloaded in the viewer, so the values in expPaths are 
		// wrong. We need to find the new ones and expand those.
		
		ArrayList<TreeItem>allItems = new ArrayList<TreeItem>();
		getAllItems(v.getControl(), allItems);
		ArrayList<TreePath> newPathsToExpand = new ArrayList<TreePath>();
		for(TreePath tp:expPaths) {
			Object lastSeg = tp.getLastSegment();
			while(lastSeg instanceof DelegatingWrapperItemProvider)
				lastSeg = ((DelegatingWrapperItemProvider)lastSeg).getValue();


			if(lastSeg instanceof Identifiable) {
				// See if we can find the new identifiable object in the list of items
				boolean foundNewPath = false;
				for(TreeItem ti:allItems) {
					Object data = ti.getData();
					while(data instanceof DelegatingWrapperItemProvider)
						data = ((DelegatingWrapperItemProvider)data).getValue();
					
//					Activator.logInformation("Comparing "+data+" with "+lastSeg);
					if(data instanceof Identifiable && 
							((Identifiable)data).getURI().equals(((Identifiable)lastSeg).getURI()) &&
							!data.equals(lastSeg))
					{
						Object [] segments = new Object[tp.getSegmentCount()];
						int i = 0;
						for(i=0;i<tp.getSegmentCount()-1;++i) segments[i] = tp.getSegment(i);
						segments[i] = ti.getData();
						TreePath newPath = new TreePath(segments);
						newPathsToExpand.add(newPath);
						foundNewPath = true;
					}
				}
				if(!foundNewPath) {
					// Try and expand anyway using the old object
					Object [] segments = new Object[tp.getSegmentCount()];
					int i=0;
					for(i=0;i<tp.getSegmentCount();++i) segments[i] = tp.getSegment(i);
					TreePath newPath = new TreePath(segments);
					newPathsToExpand.add(newPath);
				}
			}
		}
		v.setExpandedTreePaths(expPaths);
		for(TreePath tp:newPathsToExpand)
			v.expandToLevel(tp, 1);
	}
	
	private void getAllItems(Object o, ArrayList<TreeItem>items) {
		
		if(o instanceof Tree)
			for(TreeItem t:((Tree)o).getItems()) {
				items.add(t);
				for(TreeItem t2:t.getItems())
					getAllItems(t2, items);
			}
		
		if(o instanceof TreeItem) 
			for(TreeItem t:((TreeItem)o).getItems()) {
				items.add(t);
				getAllItems(t, items);
			}
	}
	
	private static class MyRunnable implements Runnable {
		public IEditorReference [] references;
		public void run() {
			references = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getEditorReferences();
		}
		public IEditorReference [] getReferences() {
			return references;
		}
	}
	/**
	 * In STEM, models contain other models and graphs, and scenarios contain other models etc. When a resource is changed, we need to see
	 * what other resources are potentially affected and need to be marked as modified
	 * 
	 * @param delta The delta
	 */
	
	private void markIndirectFiles(IResourceDelta delta) {
		URI uri = URI.createPlatformResourceURI(delta.getResource().getFullPath().toString(), false);
		//String filename = uri.lastSegment();
		String project = getProject(uri);
		String type = getType(uri);
		MyRunnable runnable = new MyRunnable();
		
		final IEditorReference [] editorReferences;
		Display.getDefault().syncExec(runnable);
		
		editorReferences = runnable.getReferences();
	
		
		// We need to get a snapshot of the resources currently in the resource set since 
		// the loop below could potentially add more elements to the list inside it.
		
		EList<Resource> resSnap = new BasicEList<Resource>();
		synchronized(org.eclipse.stem.core.Utility.resourceSet) {			
			for(Resource r:org.eclipse.stem.core.Utility.resourceSet.getResources()) resSnap.add(r);
		
			// The reason we do not release the synchronization lock here
			// is that Utility.getIdentifiable(...) could be called asynchronously
			// by the project explorer tree viewer, and the method will iterate
			// over the resources searching for a match. That loop need to be
			// protected by calls below adding new resources to the resource set.
			
			for(Resource r:resSnap) {
				String p_project = getProject(r.getURI());
				if(!project.equals(p_project)) continue;
				EList<EObject> content = r.getContents();
				if(content == null || content.size() == 0) continue;
				EObject first = content.get(0);
				URI u = ((Identifiable)first).getURI();
				
				
				if(u == null) continue;
				
				if(u.equals(uri)) {
					r.setModified(true);
					r.unload();
					continue;
				}
				String proj = getProject(u);
				if(proj == null) continue;
				if(!proj.equals(project)) continue; // wrong project
				boolean modified = false;
				if(type.equals("models")) {
					if(!(first instanceof Model) && !(first instanceof Scenario)
							&& !(first instanceof Experiment)) continue; // only models,scenarios and experiments contain other models				
					if(first instanceof Model)
						modified = checkModel((Model)first, uri);
					else if(first instanceof Scenario)
						modified = checkScenario((Scenario)first, uri);			
					else if(first instanceof Experiment)
						modified = checkExperiment((Experiment)first, uri);	
					if(modified) r.setModified(true);						
				} else if(type.equals("decorators")) {
					if(!(first instanceof Model) && !(first instanceof Scenario)) continue; // only models and scenarios contain decorators				
					if(first instanceof Model)
						modified = checkModelDecorators((Model)first, uri);
					else if(first instanceof Scenario)
						modified = checkScenarioDecorators((Scenario)first, uri);			
				} else if(type.equals("graphs")) {
					if(!(first instanceof Model) && !(first instanceof Scenario)) continue; // only models & scenarios  contain graphs		
					if(first instanceof Model) modified = checkModelGraphs((Model)first, uri);
					else modified = checkScenarioGraphs((Scenario)first, uri);
				}  else if (type.equals("predicates")) {
					if(!(first instanceof Scenario) && !(first instanceof Trigger)) continue; // Only scenarios & triggers & boolean expressions have predicates in them
					if(first instanceof Scenario) modified = checkScenarioPredicate((Scenario)first, uri);
					else modified = checkTriggerPredicate((Trigger)first, uri);
				} else if(type.equals("modifiers")) {
					if(!(first instanceof Scenario) && !(first instanceof Trigger)) continue; // Only scenarios & triggers have modifiers in them
					if(first instanceof Scenario) modified = checkScenarioModifier((Scenario)first, uri);
					else modified = checkTriggerModifier((Trigger)first, uri);
					
				} else if(type.equals("triggers")) {
					if(!(first instanceof Scenario)) continue; // Only scenarios have triggers in them
					modified = checkScenarioTriggers((Scenario)first, uri);
				}
				if(modified) 
					r.setModified(true);
			} // for each resource
			
			// Finally check any editors open that needs to be reloaded
			checkEditors(editorReferences, uri);
		}
	} // resourceSet is not thread safe
	
	private void checkEditors(IEditorReference [] editorReferences, URI uri) {
/*		for(IEditorReference ier:editorReferences) {
			Activator.logInformation(ier);
			try {
				IEditorInput input = ier.getEditorInput();
				FileEditorInput fei = (FileEditorInput)input;
				IEditorPart editor = ier.getEditor(false);
				
			} catch(Exception e) {
				e.printStackTrace();
			}
		}
*/
	}
	
	private boolean checkModel(Model model, URI modifiedURI) {
		if(model == null || modifiedURI == null) 
			CorePlugin.logError("Null model", new Exception());
		if(model.getURI().lastSegment().equals(modifiedURI.lastSegment())) return true;
		for(Model m:model.getModels()) {
			boolean modified = checkModel(m, modifiedURI);
			if(modified) return true;
		}
		return false;
	}
	
	private boolean checkScenario(Scenario scenario, URI modifiedURI) {
		Model m = scenario.getModel();
		if(m == null) return false; // no model in scenario
		return checkModel(m, modifiedURI);
	}
	
	private boolean checkExperiment(Experiment experiment, URI modifiedURI) {
		Scenario scenario = experiment.getScenario();
		if(scenario == null) return false;
		return checkScenario(scenario, modifiedURI);
	}
	
	private boolean checkModelDecorators(Model model, URI modifiedURI) {
		if(model == null || modifiedURI == null) 
			CorePlugin.logError("Null model or decorator", new Exception());
		
		for(Decorator d:model.getNodeDecorators())
			if(d.getURI().lastSegment().equals(modifiedURI.lastSegment())) return true;
		
		// Check sub model
		for(Model m:model.getModels()) {
			boolean modified = checkModelDecorators(m, modifiedURI);
			if(modified) return true;
		}
		return false;
	}
	
	private boolean checkScenarioDecorators(Scenario scenario, URI modifiedURI) {
		Model m = scenario.getModel();
		if(m == null) return false;
		boolean modified =  checkModelDecorators(m, modifiedURI);
		if(modified) return true;
		// Check scenario decorator
		for(Decorator d:scenario.getScenarioDecorators()) 
			if(!d.eIsProxy() && d.getURI().lastSegment().equals(modifiedURI.lastSegment())) return true;
		return false;
	}
	
	private boolean checkModelGraphs(Model model, URI modifiedURI) {
		if(model == null || modifiedURI == null) 
			CorePlugin.logError("Null model or uri", new Exception());
		
		for(Graph g:model.getGraphs())
			if(g.getURI().lastSegment().equals(modifiedURI.lastSegment())) return true;
		
		// Check sub model
		for(Model m:model.getModels()) {
			boolean modified = checkModelGraphs(m, modifiedURI);
			if(modified) return true;
		}
		return false;
	}
	
	private boolean checkScenarioGraphs(Scenario scenario, URI modifiedURI) {
		if(scenario == null || modifiedURI == null) 
			CorePlugin.logError("Null model or uri", new Exception());
		
		Model m = scenario.getModel();
		
		return checkModelGraphs(m, modifiedURI);
	}

	
	private boolean checkScenarioPredicate(Scenario scenario, URI modifiedURI) {
		if(scenario == null || modifiedURI == null) 
			CorePlugin.logError("Null model or uri", new Exception());
		
		for(Decorator d : scenario.getScenarioDecorators())
			if(d instanceof Trigger) {
				Trigger tg = (Trigger)d;
				IdentifiablePredicateExpression ipe = (IdentifiablePredicateExpression)tg.getPredicate();
				if(ipe != null && ipe.getURI().equals(modifiedURI))
					return true;
			}
		
		return false;
	}
	
	private boolean checkTriggerPredicate(Trigger trigger, URI modifiedURI) {
		if(trigger == null || modifiedURI == null) 
			CorePlugin.logError("Null model or uri", new Exception());
		
	 	 IdentifiablePredicateExpression ipe = (IdentifiablePredicateExpression)trigger.getPredicate();
		 if(ipe != null && ipe.getURI().equals(modifiedURI))
					return true;
		
		return false;
	}

	private boolean checkScenarioModifier(Scenario scenario, URI modifiedURI) {
		if(scenario == null || modifiedURI == null) 
			CorePlugin.logError("Null model or uri", new Exception());
		
		for(Decorator d : scenario.getScenarioDecorators())
			if(d instanceof Trigger) {
				Trigger tg = (Trigger)d;
				for(Decorator dec:tg.getActions()) {
					if(dec.getURI().equals(modifiedURI))
						return true;
				}
			}
		
		return false;
	}
	
	private boolean checkScenarioTriggers(Scenario scenario, URI modifiedURI) {
		if(scenario == null || modifiedURI == null) 
			CorePlugin.logError("Null model or uri", new Exception());
		
		for(Decorator d : scenario.getScenarioDecorators())
			if(d instanceof Trigger) {
				Trigger tg = (Trigger)d;
				if(tg.getURI().equals(modifiedURI))
					return true;
			}
		
		return false;
	}
	
	private boolean checkTriggerModifier(Trigger trigger, URI modifiedURI) {
		if(trigger == null || modifiedURI == null) 
			CorePlugin.logError("Null model or uri", new Exception());
		
		 for(Decorator dec:trigger.getActions()) {
			 if(dec != null && dec.getURI() != null && dec.getURI().equals(modifiedURI))
				 return true;
		 }
		
		return false;
	}

	private String getProject(URI uri) {
		if(!uri.toString().startsWith("platform:/resource")) return null;

		String s1 = uri.toString().substring(19); // "platform:/resource"
		int is = s1.indexOf("/");
		String project = s1.substring(0, is); 
		return project;
	}
	
	private String getType(URI uri) {
		if(!uri.toString().startsWith("platform:/resource")) return null;

		String s1 = uri.toString().substring(19); // "platform:/resource"
		int is = s1.indexOf("/");
		String _project = s1.substring(is+1);
		int is2 = _project.indexOf("/");
		if(is2 == -1) return ""; // no type
		String type = _project.substring(0, is2);
		return type;
	}
} // IdentifiableContentProvider