//------------------------------------------------------------------------------
// Copyright (c) 2005, 2007 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 implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.authoring.ui.util;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.epf.authoring.ui.AuthoringUIPlugin;
import org.eclipse.epf.common.utils.ExtensionHelper;
import org.eclipse.epf.common.utils.IMarkerAttributeContributer;
import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.library.LibraryServiceListener;
import org.eclipse.epf.library.configuration.closure.IConfigurationError;
import org.eclipse.epf.library.edit.navigator.ConfigurationsItemProvider;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.project.MethodLibraryProject;
import org.eclipse.epf.persistence.FileManager;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.views.markers.MarkerViewUtil;
/**
* Helper class to handle Configuration error markers
* @author Jeff Hardy
* @author Jinhua Xi
*
*/
public class ConfigurationMarkerHelper {
public static final ConfigurationMarkerHelper INSTANCE = new ConfigurationMarkerHelper();
public static final String ATTR_ERROR_ID = "errorID"; //$NON-NLS-1$
public static final String ATTR_CONFIG_GUID = "configGuid"; //$NON-NLS-1$
public static final String ATTR_MESSAGE_ID = "messageId"; //$NON-NLS-1$
public static final String ATTR_ERROR_ELEMENT_GUID = "elementGuid"; //$NON-NLS-1$
public static final String ATTR_CAUSE_ELEMENT_GUID = "causeGuid"; //$NON-NLS-1$
// marker ID
public static final String MARKER_ID = "org.eclipse.epf.authoring.ui.configuration"; //$NON-NLS-1$
private int maxMarkerCount = 2000;
// private Map<ElementDependencyError, IMarker> errorMarkerMap = new HashMap<ElementDependencyError, IMarker>();
// private constructor
private ConfigurationMarkerHelper() {
}
private static class ContainerMap extends HashMap<Object, Integer> {
/**
*
*/
private static final long serialVersionUID = 1L;
private Map<MethodConfiguration, Map<String, IMarker>> configMakerMap;
public ContainerMap() {
super();
initMap();
LibraryService.getInstance().addListener(new LibraryServiceListener() {
public void libraryOpened(MethodLibrary library) {
initMap();
}
public void libraryClosed(MethodLibrary library) {
clear();
}
public void libraryReopened(MethodLibrary library) {
initMap();
}
});
}
private void initMap() {
clear();
configMakerMap = new HashMap<MethodConfiguration, Map<String, IMarker>>();
// fill this set with containers of marked objects
//
MethodLibrary lib = LibraryService.getInstance().getCurrentMethodLibrary();
if(lib != null) {
IProject prj = MethodLibraryProject.findProject(lib);
if(prj != null) {
try {
IMarker[] markers = prj.findMarkers(INSTANCE.getMarkerID(), false, IResource.DEPTH_INFINITE);
for (int i = 0; i < markers.length; i++) {
IMarker marker = markers[i];
String guid = (String) marker.getAttribute(ATTR_CONFIG_GUID);
MethodElement e = LibraryService.getInstance().getCurrentLibraryManager().getMethodElement(guid);
if(e != null) {
// remove its containers from containersOfMarkedObjects
//
markContainers(e);
}
}
} catch (CoreException e) {
}
}
}
}
private void increment(Object object) {
Integer count;
if (containsKey(object)) {
count = get(object);
} else {
count = new Integer(0);
}
count++;
put(object, count);
}
private void decrement(Object object) {
if (containsKey(object)) {
Integer count = get(object);
if (count == 1) {
// remove object
remove(object);
} else {
count--;
put(object, count);
}
}
}
private void markContainers(MethodElement e) {
for(EObject container = e.eContainer(); container != null; container = container.eContainer()) {
increment(container);
}
}
private void unmarkContainers(MethodElement e) {
for(EObject container = e.eContainer(); container != null; container = container.eContainer()) {
decrement(container);
}
}
public Map<MethodConfiguration, Map<String, IMarker>> getConfigMakerMap() {
return configMakerMap;
}
}
private static ContainerMap containersOfMarkedObjects = new ContainerMap();
protected String getMarkerID() {
return MARKER_ID;
}
/* (non-Javadoc)
* @see org.eclipse.emf.common.ui.MarkerHelper#getFile(org.eclipse.emf.common.util.URI)
*/
protected IFile getFile(URI uri) {
if(uri.isFile()) {
return (IFile) FileManager.getResourceForLocation(uri.toFileString());
}
String scheme = uri.scheme();
if ("platform".equals(scheme) && uri.segmentCount() > 1 && "resource".equals(uri.segment(0))) //$NON-NLS-1$ //$NON-NLS-2$
{
StringBuffer platformResourcePath = new StringBuffer();
for (int j = 1, size = uri.segmentCount(); j < size; ++j)
{
platformResourcePath.append('/');
platformResourcePath.append(URI.decode(uri.segment(j)));
}
return ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(platformResourcePath.toString()));
}
return null;
}
/**
* Used by decorators to determine to put an error tick on the Object
* @param object
* @return
*/
public static boolean isInvalid(Object object) {
if (object instanceof ConfigurationsItemProvider) {
Collection children = ((ConfigurationsItemProvider)object).getChildren(object);
for (Iterator iter = children.iterator(); iter.hasNext();) {
Object obj = TngUtil.unwrap(iter.next());
if(containersOfMarkedObjects.containsKey(obj)) {
return true;
}
if (obj instanceof MethodConfiguration) {
if (INSTANCE.hasMarkers((MethodConfiguration)obj)) {
return true;
}
}
}
return false;
} else if (object instanceof MethodConfiguration) {
if (INSTANCE.hasMarkers((MethodConfiguration)object)) {
return true;
}
}
return containersOfMarkedObjects.containsKey(object);
}
public void deleteMarker(MethodConfiguration config, IConfigurationError error) {
try {
IMarker marker = getMarker(config, error);
if (marker != null) {
marker.delete();
containersOfMarkedObjects.unmarkContainers(config);
unregisterMarker(config, error.getId());
}
} catch (CoreException e) {
AuthoringUIPlugin.getDefault().getLogger().logError(e);
}
}
public IMarker createMarker(MethodConfiguration config, IConfigurationError error) {
// if (error.getErrorMethodElement() == null) return null;
// if (error.getCauseMethodElement() == null) return null;
IMarker existingMarker = getMarker(config, error);
if (existingMarker != null) {
adjustMarker(existingMarker, config, error);
return existingMarker;
}
try {
if (getMarkerCount(config) >= maxMarkerCount) {
return null;
}
IResource resource = getIResource(config);
if (resource != null && resource.exists()) {
IMarker marker = resource.createMarker(getMarkerID());
marker.setAttribute(IDE.EDITOR_ID_ATTR, "org.eclipse.epf.authoring.ui.editors.ConfigurationEditor"); //$NON-NLS-1$
adjustMarker(marker, config, error);
containersOfMarkedObjects.markContainers(config);
registerNewMarker(config, error.getId(), marker);
return marker;
}
} catch (CoreException e) {
AuthoringUIPlugin.getDefault().getLogger().logError(e);
}
return null;
}
public void adjustMarker(IMarker marker, MethodConfiguration config, IConfigurationError error) {
if (config == null || error == null) return;
try {
if (marker == null) {
// try to find marker
marker = getMarker(config, error);
}
if (marker == null) return;
marker.setAttribute(IMarker.SEVERITY, error.getSeverity());
String message = getMessage(error);
marker.setAttribute(IMarker.MESSAGE, message);
marker.setAttribute(IMarker.LINE_NUMBER, 0);
marker.setAttribute(ATTR_CONFIG_GUID, config.getGuid());
marker.setAttribute(ATTR_ERROR_ID, error.getId());
marker.setAttribute(ATTR_MESSAGE_ID, error.getMessageId());
if (error.getErrorMethodElement() != null) {
marker.setAttribute(IMarker.LOCATION, TngUtil.getLabelWithPath(error.getErrorMethodElement()));
marker.setAttribute(ATTR_ERROR_ELEMENT_GUID, error.getErrorMethodElement().getGuid());
marker.setAttribute(MarkerViewUtil.NAME_ATTRIBUTE, error.getErrorMethodElement().getName());
}
if (error.getCauseMethodElement() != null) {
marker.setAttribute(ATTR_CAUSE_ELEMENT_GUID, error.getCauseMethodElement().getGuid());
}
IMarkerAttributeContributer attAdder = ExtensionHelper.getMarkerAttributeContributer();
if (attAdder != null) {
attAdder.addAddtionalAttributes(marker, error);
}
} catch (CoreException e) {
AuthoringUIPlugin.getDefault().getLogger().logError(e);
}
}
public boolean hasMarker(MethodConfiguration config, IConfigurationError error) {
if (getMarker(config, error) != null) {
return true;
}
return false;
}
/**
* Returns whether the a maker with id equals to the return of {@link #getMarkerID()}
* is available in the IResource computed from the specified object.
* @param object
* @return boolean
*/
public boolean hasMarkers(MethodConfiguration config) {
IResource resource = getIResource(config);
if (resource != null && resource.exists()) {
try {
IMarker[] markers = resource.findMarkers(getMarkerID(), true, IResource.DEPTH_ZERO);
return markers.length > 0;
} catch (CoreException e) {
AuthoringUIPlugin.getDefault().getLogger().logError(e);
}
}
return false;
}
public IMarker getMarker(MethodConfiguration config, IConfigurationError error) {
if (config == null || error == null) {
return null;
}
return findMarker(config, error.getId());
// try {
// IResource resource = getIResource(config);
// if (resource != null) {
// IMarker[] markers = resource.findMarkers(getMarkerID(), false, IResource.DEPTH_ZERO);
// for (int i = 0; i < markers.length; i++) {
// IMarker marker = markers[i];
// String markerErrorId = (String) marker.getAttribute(ATTR_ERROR_ID);
// if (error.getId().equals(markerErrorId)) {
// return marker;
// }
// }
// }
// } catch (CoreException e) {
// AuthoringUIPlugin.getDefault().getLogger().logError(e);
// }
// return null;
}
private String getMessage(IConfigurationError error) {
return error.getErrorMessage();
}
private IResource getIResource(MethodConfiguration config) {
Resource resource = config.eResource();
URI uri = resource.getURI();
uri = resource.getResourceSet().getURIConverter().normalize(uri);
return getFile(uri);
}
public MethodConfiguration getConfig(IMarker marker) {
if (marker == null) {
return null;
}
try {
String configGuid = (String) marker.getAttribute(ATTR_CONFIG_GUID);
MethodElement e = LibraryService.getInstance().getCurrentLibraryManager().getMethodElement(configGuid);
if (e instanceof MethodConfiguration) {
return (MethodConfiguration)e;
}
} catch (CoreException e) {
AuthoringUIPlugin.getDefault().getLogger().logError(e);
}
return null;
}
public MethodElement getErrorMethodElement(IMarker marker) {
if (marker == null) {
return null;
}
try {
String errorGuid = (String) marker.getAttribute(ATTR_ERROR_ELEMENT_GUID);
if (errorGuid != null) {
MethodElement e = LibraryService.getInstance().getCurrentLibraryManager().getMethodElement(errorGuid);
if (e instanceof MethodElement) {
return (MethodElement)e;
}
}
} catch (CoreException e) {
AuthoringUIPlugin.getDefault().getLogger().logError(e);
}
return null;
}
public MethodElement getCauseMethodElement(IMarker marker) {
if (marker == null) {
return null;
}
try {
String causeGuid = (String) marker.getAttribute(ATTR_CAUSE_ELEMENT_GUID);
if (causeGuid != null) {
MethodElement e = LibraryService.getInstance().getCurrentLibraryManager().getMethodElement(causeGuid);
if (e instanceof MethodElement) {
return (MethodElement)e;
}
}
} catch (CoreException e) {
AuthoringUIPlugin.getDefault().getLogger().logError(e);
}
return null;
}
private void registerNewMarker(MethodConfiguration config, String id, IMarker marker) {
Map<String, IMarker> map = containersOfMarkedObjects.getConfigMakerMap().get(config);
if (map == null) {
map = new HashMap<String, IMarker>();
containersOfMarkedObjects.getConfigMakerMap().put(config, map);
}
map.put(id, marker);
}
private void unregisterMarker(MethodConfiguration config, String id) {
Map<String, IMarker> map = containersOfMarkedObjects.getConfigMakerMap().get(config);
if (map == null) {
return;
}
map.remove(id);
}
private IMarker findMarker(MethodConfiguration config, String id) {
Map<String, IMarker> map = containersOfMarkedObjects.getConfigMakerMap().get(config);
if (map == null) {
return null;
}
return map.get(id);
}
private int getMarkerCount(MethodConfiguration config) {
Map<String, IMarker> map = containersOfMarkedObjects.getConfigMakerMap().get(config);
if (map == null) {
return 0;
}
return map.size();
}
public void removeAllMarkers(MethodConfiguration config) {
Map<String, IMarker> map = containersOfMarkedObjects.getConfigMakerMap().remove(config);
if (map == null) {
return;
}
for (IMarker marker : map.values()) {
try {
marker.delete();
} catch (CoreException e) {
AuthoringUIPlugin.getDefault().getLogger().logError(e);
}
}
}
}