Attachment #151049 for bug #289767

Lines 40-45 Link Here

(-)META-INF/MANIFEST.MF (-1 / +4 lines)
40	org.eclipse.ui.navigator;bundle-version="[3.2.0,4.0.0)",	40	org.eclipse.ui.navigator;bundle-version="[3.2.0,4.0.0)",
41	org.eclipse.ui.ide;bundle-version="[3.2.0,4.0.0)",	41	org.eclipse.ui.ide;bundle-version="[3.2.0,4.0.0)",
42	org.eclipse.emf.edit;bundle-version="[2.2.0,3.0.0)",	42	org.eclipse.emf.edit;bundle-version="[2.2.0,3.0.0)",
43	org.eclipse.jst.jee.ui;bundle-version="1.0.100"	43	org.eclipse.jst.jee.ui;bundle-version="1.0.100",
		44	org.eclipse.jface.text;bundle-version="[3.2.0,4.0.0)",
		45	org.eclipse.ltk.core.refactoring;bundle-version="[3.2.0,4.0.0)",
		46	org.eclipse.ltk.ui.refactoring;bundle-version="[3.2.0,4.0.0)"
44	Eclipse-LazyStart: true	47	Eclipse-LazyStart: true
45	Bundle-RequiredExecutionEnvironment: J2SE-1.5	48	Bundle-RequiredExecutionEnvironment: J2SE-1.5

Added Link Here

(-)icons/full/delete.gif (+5 lines)
1	GIF89aÕÇ35ôqtôstórtósuØ*/à,4ß,3Ç)0æ6>å6>Å +å09òU`ôckócjóckódkÅ'Æ(Å'Æ ,òT`Å%ñ?Rð?QòHXñHXÔetß¨Ê]IÎn^ÊWFÊXFÉXFÕ\|ÉPCÜ¦ ÉG>ÉG?ÈG?Ç=9àa[õ?}Ç=:ãROõ~ô~ãÄÄÿÿÿ!ù1,\|ÀpH,?GgTy`DX¨b
2	G¢*,\+Ò§ô!½Â%âE¨LªAàd%rXÈÃñHq?
3
4
5	H1HEB ¦C0¨C«\B±£B«¹ÀÁ1A;




        <adapter type="org.eclipse.jdt.core.IJavaElement"/>
     </factory>
  </extension>
  <extension
        point="org.eclipse.ui.popupMenus">
     <objectContribution
           adaptable="true"
           id="org.eclipse.jst.servlet.ui.RemoveWebObject"
           objectClass="java.lang.Object">
        <action
              class="org.eclipse.jst.servlet.ui.internal.actions.DeleteWebArtifacts"
              enablesFor="+"
              icon="icons/full/delete.gif"
              id="org.eclipse.jst.servlet.ui.delete.web"
              label="Delete"
              menubarPath="delete">
        </action>
        <enablement>
				<or>
					<instanceof value="org.eclipse.jst.javaee.web.ServletMapping">
					</instanceof>
					<instanceof value="org.eclipse.jst.javaee.web.Servlet">
					</instanceof>
					<instanceof value="org.eclipse.jst.javaee.web.Filter">
					</instanceof>
					<instanceof value="org.eclipse.jst.javaee.web.FilterMapping">
					</instanceof>
					<instanceof value="org.eclipse.jst.javaee.core.Listener">
					</instanceof>
				</or>
			</enablement>
     </objectContribution>
  </extension>
  
</plugin>




package org.eclipse.jst.servlet.ui.internal.actions;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jst.j2ee.internal.web.operations.WebPropertiesUtil;
import org.eclipse.jst.j2ee.model.IModelProvider;
import org.eclipse.jst.j2ee.model.ModelProviderManager;
import org.eclipse.jst.j2ee.ui.ltkbasedrefactoring.J2eeDeleteRefactoringWizard;
import org.eclipse.jst.javaee.core.Listener;
import org.eclipse.jst.javaee.web.Filter;
import org.eclipse.jst.javaee.web.FilterMapping;
import org.eclipse.jst.javaee.web.Servlet;
import org.eclipse.jst.javaee.web.ServletMapping;
import org.eclipse.jst.javaee.web.WebApp;
import org.eclipse.jst.jee.ui.internal.navigator.web.WebAppProvider;
import org.eclipse.jst.jee.ui.plugin.JEEUIPlugin;
import org.eclipse.jst.servlet.ui.internal.navigator.AvailableWebArtifactsDialogContentProvider;
import org.eclipse.jst.servlet.ui.internal.navigator.AvailableWebArtifactsDialogLabelProvider;
import org.eclipse.jst.servlet.ui.internale.ltkbasedrefactoring.WebArtifactDeleteProcessor;
import org.eclipse.jst.servlet.ui.internale.ltkbasedrefactoring.WebRefactoringUtils;
import org.eclipse.ltk.ui.refactoring.RefactoringWizardOpenOperation;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.CheckedTreeSelectionDialog;

public class DeleteWebArtifacts implements IObjectActionDelegate{

	private ISelection sel = new StructuredSelection();
	private IWorkbenchPart targetPart;
	private String fullyQualifiedName;

	public void setActivePart(IAction action, IWorkbenchPart targetPart) {
		this.setTargetPart(targetPart);
		
	}
	
	public void run(IAction action) {
		if (sel == null)
			return;
		
		IStructuredSelection selection = (StructuredSelection) sel;
		if (!selection.isEmpty()) {
			List<Object> selections = new ArrayList<Object>();
			Iterator it = selection.iterator();
			while(it.hasNext()){
				selections.add(it.next());
			}
			delete(selections);
		}		
	}
	
    private void delete(List<Object> objects){
    	Map<Object, List<IResource>> map = new HashMap<Object, List<IResource>>();
    	for(Object object : objects){
    		getObjectsToBeDeleted(map, object);
    	  }
    	
    	deleteResources(objects, map);
    	}

	private void deleteResources(List<Object> objects, Map<Object, List<IResource>> map ){
		
		List<Object> javaObjects = new ArrayList<Object>();
		for (int i = 0; i < objects.size(); i++) {
			Object obj = objects.get(i);
			getArtifactByMappingToBeDeleted(objects, javaObjects, obj);
		}

		if (!javaObjects.isEmpty()) {
			Object[] obj = openDialog(javaObjects);
			if (obj != null && obj.length != 0) {
				for (Object ob : obj) {
					objects.add(ob);
					getObjectsToBeDeleted(map, ob);
				}
			}
		}
		 
		
		WebArtifactDeleteProcessor processor = new WebArtifactDeleteProcessor(objects, map);
		J2eeDeleteRefactoringWizard wiz = new J2eeDeleteRefactoringWizard(processor, objects);
		
		RefactoringWizardOpenOperation op = new RefactoringWizardOpenOperation(wiz); 
		try { 
			String titleForFailedChecks = ""; //$NON-NLS-1$ 
			op.run(new Shell(), titleForFailedChecks ); 
		} catch( InterruptedException irex ) { 
			// operation was cancelled 
		}
	}

	private void getObjectsToBeDeleted(Map<Object, List<IResource>> map,
			Object object) {
		List<IResource> resourcesToBeMappedToObject = new ArrayList<IResource>();
		IProject project = ProjectUtilities.getProject(object);
		IModelProvider modelProvider = ModelProviderManager.getModelProvider(project);
		WebApp webApp = (WebApp) modelProvider.getModelObject();
		String container = WebPropertiesUtil.getJavaSourceFolder(project).getName();

		WebAppProvider prov = new WebAppProvider(webApp, project);
		IFile webXML = prov.getDDFile();
		specifyObjectNameByItsType(object);
		
		getObjectResource(resourcesToBeMappedToObject, project,
				container);
		
		if(!resourcesToBeMappedToObject.contains(webXML)){
		    resourcesToBeMappedToObject.add(webXML);
		}
		map.put(object, resourcesToBeMappedToObject);
	}
	

	private void specifyObjectNameByItsType(Object object) {
		if(object instanceof Servlet){
			fullyQualifiedName = ((Servlet)object).getServletClass();
		} else if(object instanceof Filter){
			fullyQualifiedName = ((Filter)object).getFilterClass();
		} else if (object instanceof Listener){
			fullyQualifiedName = ((Listener)object).getListenerClass();
		}
	}

	private void getObjectResource(List<IResource> resourcesToBeMappedToObject, IProject project,
			String container) {
		if(fullyQualifiedName!=null){
			IResource resource = project.getFile(new Path(
				container + "/" + (fullyQualifiedName).replace(".", "/") + ".java"));   //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
		 if(resource !=null && resource.exists()){
			 if(!resourcesToBeMappedToObject.contains(resource)){
		        resourcesToBeMappedToObject.add(resource);
			 }
			 getPackage(resourcesToBeMappedToObject, project,
					resource);
		 }
		}
	}

	private void getPackage(List<IResource> resourcesToBeMappedToObject, IProject project,
			IResource resource) {
		IResource packageResource = resource.getParent();
			if (getWebArtifactPackage(fullyQualifiedName, fullyQualifiedName
					.replaceAll(packageResource.getName() + ".", ""), project)) {  //$NON-NLS-1$ //$NON-NLS-2$
				if(!resourcesToBeMappedToObject.contains(packageResource)){
				    resourcesToBeMappedToObject.add(packageResource);
				}
		    }
	}
	
	private void getArtifactByMappingToBeDeleted(List<Object> objects,
			List<Object> javaObjects, Object obj) {
		
		if(obj instanceof FilterMapping){
			IProject project = ProjectUtilities.getProject(obj);
			IModelProvider modelProvider = ModelProviderManager.getModelProvider(project);
			WebApp webApp = (WebApp) modelProvider.getModelObject();
		    Filter filter = getFilter(webApp, ((FilterMapping)obj).getFilterName());
		    List<FilterMapping> mappings = WebRefactoringUtils.getFilterMappings(webApp, filter.getFilterName());
		    if(objects.containsAll(mappings) && !objects.contains(filter) && !javaObjects.contains(filter)){
		    	javaObjects.add(filter);
		    }
		} else if(obj instanceof ServletMapping){
			IProject project = ProjectUtilities.getProject(obj);
			IModelProvider modelProvider = ModelProviderManager.getModelProvider(project);
			WebApp webApp = (WebApp) modelProvider.getModelObject();
		    Servlet servlet = getServlet(webApp, ((ServletMapping)obj).getServletName());
		    List<ServletMapping> mappings = WebRefactoringUtils.getServletMappings(webApp, servlet.getServletName());
		    if(objects.containsAll(mappings) && !objects.contains(servlet) && !javaObjects.contains(servlet)){
		    	javaObjects.add(servlet);
		    }
		}
	}
	

    private Servlet getServlet(WebApp webApp, String servletName) {
        if (webApp == null || servletName == null) return null;
        List servlets = webApp.getServlets();
        for (Iterator iterator = servlets.iterator(); iterator.hasNext();) {
            Servlet servlet = (Servlet) iterator.next();
            if (servletName.equals(servlet.getServletName())) {
                return servlet;
            }
        }
        return null;
    }
	
	private Object[] openDialog(final List<Object> list){
				
				CheckedTreeSelectionDialog dialog = new CheckedTreeSelectionDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), new AvailableWebArtifactsDialogLabelProvider(), new AvailableWebArtifactsDialogContentProvider());
		
				dialog.setTitle("Delete Artifact Confirm"); //$NON-NLS-1$
				dialog.setMessage("All mappings of these elements will be deleted. It is recommended to delete the elements.");  //$NON-NLS-1$
				dialog.setInput(list);       
		        
		        int pressed = dialog.open();
		        if(pressed == IDialogConstants.OK_ID){
		        	return dialog.getResult();
		        }
		        return null;
			}
	
	private Filter getFilter(WebApp webApp, String filterName) {
	       if (webApp == null || filterName == null) return null;
	       List filters = webApp.getFilters();
	       for (Iterator iterator = filters.iterator(); iterator.hasNext();) {
	           Filter filter = (Filter) iterator.next();
	           if (filterName.equals(filter.getFilterName())) {
	               return filter;
	           }
	       }
	       return null;
	   }
	
 	private boolean getWebArtifactPackage(
			String webArtifactClass, String webArtifactName, IProject project) {
		IPackageFragment webArtifactPackage = null;
		try {
			IType webArtifact = JavaCore.create(project).findType(webArtifactClass);
		    if(webArtifact!=null){
			     webArtifactPackage = webArtifact.getPackageFragment();
		    if(webArtifactPackage.hasChildren()){
		    	IJavaElement[] el = webArtifactPackage.getChildren();
		    	if(el.length==1){
		    		if(el[0].getElementName().equals(webArtifactName+".java")){ //$NON-NLS-1$
		    			return true;
		    		}
		    	}
			} else {
				return true;
			}
		    }
		} catch (JavaModelException e1) {
			JEEUIPlugin.logError("Cannot find resource.", e1); //$NON-NLS-1$
		}
		return false;
	}
	
	public void selectionChanged(IAction action, ISelection selection) {
		sel = selection;				
	}

	public void setTargetPart(IWorkbenchPart targetPart) {
		this.targetPart = targetPart;
	}

	public IWorkbenchPart getTargetPart() {
		return targetPart;
	}

}





package org.eclipse.jst.servlet.ui.internal.navigator;

import java.util.List;

import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;

public class AvailableWebArtifactsDialogContentProvider implements
		ITreeContentProvider {

	public Object[] getChildren(Object parentElement) {
		return null;
	}

	public Object getParent(Object element) {
		return null;
	}

	public boolean hasChildren(Object element) {
		return false;
	}

	public Object[] getElements(Object inputElement) {
		if(inputElement instanceof List){
              return ((List)inputElement).toArray(new Object[((List)inputElement).size()]);
		}
		return null;
	}

	public void dispose() {
	}

	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
	}

}




package org.eclipse.jst.servlet.ui.internal.navigator;

import java.net.URL;

import org.eclipse.core.resources.IProject;
import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
import org.eclipse.jst.javaee.web.Filter;
import org.eclipse.jst.javaee.web.Servlet;
import org.eclipse.jst.jee.ui.plugin.JEEUIPluginIcons;
import org.eclipse.swt.graphics.Image;

public class AvailableWebArtifactsDialogLabelProvider implements ILabelProvider{
	
	public Image getImage(Object element) {
		Image image = null;
		if(element instanceof Filter){
			URL url = (URL) J2EEPlugin.getPlugin().getImage(JEEUIPluginIcons.FILTER_MAPPING);
			ImageDescriptor imageDescriptor = ImageDescriptor.createFromURL(url); 
		    image = imageDescriptor.createImage();
		} else if (element instanceof Servlet){
			URL url = (URL) J2EEPlugin.getPlugin().getImage(JEEUIPluginIcons.GROUP_SERVLET);
			ImageDescriptor imageDescriptor = ImageDescriptor.createFromURL(url); 
		    image = imageDescriptor.createImage();
		}
		return image;
	}

	public String getText(Object element) {
		String name = null;
        if(element instanceof Filter){
        	name = ((Filter)element).getFilterClass();
        } else if(element instanceof Servlet){
        	name = ((Servlet)element).getServletClass();
        }
        IProject project = ProjectUtilities.getProject(element);
        name = name + "-" + project.getFullPath().toString(); //$NON-NLS-1$
		return name;
	}

	public void addListener(ILabelProviderListener listener) {
	}

	public void dispose() {
	}

	public boolean isLabelProperty(Object element, String property) {
		return false;
	}

	public void removeListener(ILabelProviderListener listener) {
	}

}





package org.eclipse.jst.servlet.ui.internale.ltkbasedrefactoring;

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

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.ecore.util.FeatureMap;
import org.eclipse.emf.ecore.util.FeatureMap.Entry;
import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jst.j2ee.internal.web.operations.WebPropertiesUtil;
import org.eclipse.jst.j2ee.model.IModelProvider;
import org.eclipse.jst.javaee.core.Listener;
import org.eclipse.jst.javaee.core.UrlPatternType;
import org.eclipse.jst.javaee.ltk.core.delete.J2eeDeleteProcessorImpl;
import org.eclipse.jst.javaee.web.Filter;
import org.eclipse.jst.javaee.web.FilterMapping;
import org.eclipse.jst.javaee.web.Servlet;
import org.eclipse.jst.javaee.web.ServletMapping;
import org.eclipse.jst.javaee.web.WebApp;
import org.eclipse.jst.jee.ui.internal.navigator.web.WebAppProvider;
import org.eclipse.ltk.core.refactoring.TextFileChange;
import org.eclipse.text.edits.DeleteEdit;

public class WebArtifactDeleteProcessor extends J2eeDeleteProcessorImpl {
	
	private String fObjectFullyQualifiedName;
	private String fObjectName;
	private List<DeleteEdit> deletes = new ArrayList<DeleteEdit>();	
	private List<Object> fObjects = new ArrayList<Object>();
	private String fStartTag;
	private String fEndTag;

	public WebArtifactDeleteProcessor(List<Object> objects,
			Map<Object, List<IResource>> map) {
		super(objects, map);
		fObjects = objects;
	}
	

	public Object specifyXMLFile(IProject project,
			IModelProvider modelProvider) {
		WebApp webApp = (WebApp) modelProvider.getModelObject();
		WebAppProvider prov = new WebAppProvider(webApp, project);

		if(getXmlFile() == null){
			setXmlFile(prov.getDDFile());
		} else {
			if(!getXmlFile().equals(prov.getDDFile())){
				setXmlFile(prov.getDDFile());
			}
		}
		
		if(!getFiles().contains(getXmlFile())){
			getFiles().add(getXmlFile());
		}
		return webApp;
	}


	public void modifyXML(IFile file, Object modelObject, TextFileChange result,
			Object fObject) throws CoreException {
		WebApp webApp = (WebApp) modelObject; 
		
		String xmlContent = result.getCurrentContent(new NullProgressMonitor());
		
		List<String> listString = new ArrayList<String>();

		IDocument doc = new Document();
		doc.set(xmlContent);

		if (fObject instanceof Listener) {
			listenerObjectChanges(file, fObject, xmlContent, listString, doc);
		}
		if (fObject instanceof Filter) {
			filterChanges(file, webApp, fObject, xmlContent, listString, doc);
		}
		if (fObject instanceof Servlet) {
			servletChanges(file, webApp, fObject, xmlContent, listString, doc);
		}
		if (fObject instanceof FilterMapping) {
			filterMappingChanges(file, fObject, xmlContent, listString, doc);
		}
		if (fObject instanceof ServletMapping) {
			servletMappingsChanges(file, fObject, xmlContent, listString, doc);
		}
	}
	
	   
		public String getObjectName(Object object){
	    	String name = null;
	    	if(object instanceof Servlet){
	    		name = ((Servlet)object).getServletName();
	    	} else if(object instanceof Filter){
	    		name = ((Filter)object).getFilterName();
	    	} else if(object instanceof Listener){
	    		name = ((Listener)object).getListenerClass();
	    	} else if(object instanceof FilterMapping){
	    		name = getFilterMappingDisplay((FilterMapping)object);
	    	} else if(object instanceof ServletMapping){
	    		name = getServletMappingDisplay((ServletMapping)object);
	    	}
	    	return name;
	    }
	  
	    
		public String getObjectType(Object object){
	    	String objectType = null;
	    	if(object instanceof Servlet){
	    		objectType = "servlet"; //$NON-NLS-1$
	    	} else if(object instanceof Filter){
	    		objectType = "filter"; //$NON-NLS-1$
	    	} else if(object instanceof Listener){
	    		objectType = "listener"; //$NON-NLS-1$
	    	} else if(object instanceof FilterMapping){
	    		objectType = "filter-mapping"; //$NON-NLS-1$
	    	} else if(object instanceof ServletMapping){
	    		objectType = "servlet-mapping"; //$NON-NLS-1$
	    	}
	    	return objectType;
	    }
	   
	    
		public IResource getObjectResource(Object object){
	    	IProject project = ProjectUtilities.getProject(object);
			String container = WebPropertiesUtil.getJavaSourceFolder(project).getName();
	    	String fullyQualifiedName = getFullyQualifiedName(object);
	    	if(fullyQualifiedName!=null){
				IResource resource = project.getFile(new Path(
					container + "/" + (fullyQualifiedName).replace(".", "/") + ".java"));   //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
	    	    return resource;
	    	}
	        return null;    
	    }
	    
	    private String getFullyQualifiedName(Object object){
	    	String name = null;
	    	if(object instanceof Servlet){
	    		name = ((Servlet)object).getServletName();
	    	} else if(object instanceof Filter){
	    		name = ((Filter)object).getFilterName();
	    	} else if(object instanceof Listener){
	    		name = ((Listener)object).getListenerClass();
	    	}
	    	return name;
	    }

	private void listenerObjectChanges(IFile file, Object fObject,
			String xmlContent, List<String> listString, IDocument doc) {
		fObjectFullyQualifiedName = ((Listener) fObject).getListenerClass();
		setfStartTag("<listener>"); //$NON-NLS-1$
		setfEndTag("</listener>"); //$NON-NLS-1$
		String identifyObject = getfStartTag().replace(">", "-class>") + fObjectFullyQualifiedName + getfEndTag().replace(">", "-class>"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
		List<String> identifyObjects = new ArrayList<String>();
		identifyObjects.add(identifyObject);
		findELementTag(file, xmlContent, listString, doc, identifyObjects);
	}

	private void filterChanges(IFile file, WebApp webApp, Object fObject,
			String xmlContent, List<String> listString, IDocument doc) {
		List<String> identifyObjects;
		filterObjectChanges(file, fObject, xmlContent, listString, doc);

		List<FilterMapping> filterMappings = WebRefactoringUtils.getFilterMappings(webApp,
				fObjectName);
		for (int j = 0; j < filterMappings.size(); j++) {
			identifyObjects = new ArrayList<String>();
			FilterMapping filterMapping = filterMappings.get(j);
			if (fObjects.contains(filterMapping))
				continue;
			urlPatternForFilterChanges(file, xmlContent, listString, doc,
					identifyObjects, filterMapping);
			servletForFilterChanges(file, xmlContent, listString, doc,
					identifyObjects, filterMapping);
		}
	}

	private void filterObjectChanges(IFile file, Object fObject,
			String xmlContent, List<String> listString, IDocument doc) {
		fObjectFullyQualifiedName = ((Filter) fObject).getFilterClass();
		fObjectName = ((Filter) fObject).getFilterName();
		setfStartTag("<filter>"); //$NON-NLS-1$
		setfEndTag("</filter>"); //$NON-NLS-1$
		String identifyObject = getfStartTag().replace(">", "-name>") + fObjectName + getfEndTag().replace(">", "-name>"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
		List<String> identifyObjects = new ArrayList<String>();
		identifyObjects.add(identifyObject);
		findELementTag(file, xmlContent, listString, doc, identifyObjects);
	}

	private void servletForFilterChanges(IFile file, String xmlContent,
			List<String> listString, IDocument doc,
			List<String> identifyObjects, FilterMapping filterMapping) {
		String identifyObject;
		if (filterMapping.getServletNames().size() > 0) {
			setfStartTag("<filter-mapping>"); //$NON-NLS-1$
			setfEndTag("</filter-mapping>"); //$NON-NLS-1$
			for (int k = 0; k < filterMapping.getServletNames().size(); k++) {
				fObjectName = filterMapping.getServletNames()
						.get(k);
				identifyObject = "<servlet-name>" + fObjectName + "</servlet-name>"; //$NON-NLS-1$ //$NON-NLS-2$
				identifyObjects.add(identifyObject);
			}
			findELementTag(file, xmlContent, listString, doc,
					identifyObjects);
		}
	}

	private void urlPatternForFilterChanges(IFile file, String xmlContent,
			List<String> listString, IDocument doc,
			List<String> identifyObjects, FilterMapping filterMapping) {
		String identifyObject;
		if (filterMapping.getUrlPatterns().size() > 0) {
			setfStartTag("<filter-mapping>"); //$NON-NLS-1$
			setfEndTag("</filter-mapping>"); //$NON-NLS-1$
			for (int k = 0; k < filterMapping.getUrlPatterns().size(); k++) {
				fObjectName = (filterMapping
						.getUrlPatterns().get(k)).getValue();
				identifyObject = "<url-pattern>" + fObjectName + "</url-pattern>"; //$NON-NLS-1$ //$NON-NLS-2$
				identifyObjects.add(identifyObject);
			}
			findELementTag(file, xmlContent, listString, doc,
					identifyObjects);
		}
	}

	private void servletMappingsChanges(IFile file, Object fObject,
			String xmlContent, List<String> listString, IDocument doc) {
		ServletMapping servletMapping = (ServletMapping) fObject;
		List<String> identifyObjects = new ArrayList<String>();
		if (servletMapping.getUrlPatterns().size() > 0) {
			urlPatternForServletChanges(file, xmlContent, listString, doc,
					servletMapping, identifyObjects);
		}
	}

	private void urlPatternForServletChanges(IFile file, String xmlContent,
			List<String> listString, IDocument doc,
			ServletMapping servletMapping, List<String> identifyObjects) {
		setfStartTag("<servlet-mapping>"); //$NON-NLS-1$
		setfEndTag("</servlet-mapping>"); //$NON-NLS-1$
		for (int k = 0; k < servletMapping.getUrlPatterns().size(); k++) {
			fObjectName = (servletMapping
					.getUrlPatterns().get(k)).getValue();
			String identifyObject = "<url-pattern>" + fObjectName + "</url-pattern>"; //$NON-NLS-1$ //$NON-NLS-2$
			identifyObjects.add(identifyObject);
		}
		findELementTag(file, xmlContent, listString, doc,
				identifyObjects);
	}

	private void filterMappingChanges(IFile file, Object fObject,
			String xmlContent, List<String> listString, IDocument doc) {
		FilterMapping filterMapping = (FilterMapping) fObject;
		List<String> identifyObjects = new ArrayList<String>();
		urlPatternForFilterChanges(file, xmlContent, listString, doc, identifyObjects, filterMapping);
		servletForFilterChanges(file, xmlContent, listString, doc, identifyObjects, filterMapping);
	}

	private void servletChanges(IFile file, WebApp webApp, Object fObject,
			String xmlContent, List<String> listString, IDocument doc) {
		List<String> identifyObjects;
		servletObjectChanges(file, fObject, xmlContent, listString, doc);

		List<ServletMapping> servletMappings = WebRefactoringUtils.getServletMappings(webApp,
				fObjectName);
		for (int j = 0; j < servletMappings.size(); j++) {
			identifyObjects = new ArrayList<String>();
			ServletMapping servletMapping = servletMappings.get(j);
			if (fObjects.contains(servletMapping))
				continue;
			urlPatternForServletChanges(file, xmlContent, listString, doc, servletMapping, identifyObjects);
		}
	}

	private void servletObjectChanges(IFile file, Object fObject,
			String xmlContent, List<String> listString, IDocument doc) {
		fObjectFullyQualifiedName = ((Servlet) fObject).getServletClass();
		fObjectName = ((Servlet) fObject).getServletName();
		setfStartTag("<servlet>"); //$NON-NLS-1$
		setfEndTag("</servlet>"); //$NON-NLS-1$
		String identifyObject = getfStartTag().replace(">", "-name>") + fObjectName + getfEndTag().replace(">", "-name>"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
		List<String> identifyObjects = new ArrayList<String>();
		identifyObjects.add(identifyObject);
		findELementTag(file, xmlContent, listString, doc, identifyObjects);
	}

	private void findELementTag(IFile file, String xmlContent,
			List<String> listString, IDocument doc, List<String> identifyObject) {
		if (getfStartTag() != null && getfEndTag() != null
				&& xmlContent.contains(getfStartTag())
				&& xmlContent.contains(getfEndTag())) {
			createXMLChangeToBeShown(file, xmlContent, listString, doc,
					identifyObject, getfStartTag(), getfEndTag());
		}
	}
	
	
	private void createXMLChangeToBeShown(IFile file, String xmlContent,
			List<String> listStrings, IDocument doc,
			List<String> identifyObject, String tag, String enclosingTag) {
		List<String> strings = markTextToBeDeletedFromXML(doc, tag,
				enclosingTag);
		findStartAndEndPoint(xmlContent, listStrings, strings, doc, tag,
				enclosingTag, identifyObject);
		DeleteEdit edit = new DeleteEdit(getOffset(), getLength());

		if (!getEditMap().containsKey(file)) {
			deletes = new ArrayList<DeleteEdit>();
			deletes.add(edit);
			getEditMap().put(file, deletes);
		} else {
			if (!getEditMap().get(file).contains(edit)) {
				getEditMap().get(file).add(edit);
			}
		}
	}

	private void findStartAndEndPoint(String xmlContent,
			List<String> textStrings, List<String> strings, IDocument doc,
			String startTag, String endTag, List<String> identifyObject) {
		String s = ""; //$NON-NLS-1$

		for (int p = 0; p < strings.size(); p++) {
			s = s + strings.get(p);
		}
		textStrings.add(s);

		for (int i = 0; i < strings.size(); i++) {
			String st = strings.get(i);
			st = st.trim();
			strings.remove(i);
			strings.add(i, st);
		}

		if (strings.containsAll(identifyObject)) {
			setOffset(xmlContent.indexOf(s));
			setLength(s.length());
		} else {
			String textDoc = xmlContent;
			for (int j = 0; j < textStrings.size(); j++) {
				if (textDoc.contains(textStrings.get(j))) {
					textDoc = textDoc.replace(textStrings.get(j), ""); //$NON-NLS-1$
				}
			}

			IDocument doc1 = new Document(textDoc);
			List<String> strings1 = markTextToBeDeletedFromXML(doc1, startTag,
					endTag);
			findStartAndEndPoint(xmlContent, textStrings, strings1, doc,
					startTag, endTag, identifyObject);
		}
	}

	private List<String> markTextToBeDeletedFromXML(IDocument doc,
			String startTag, String endTag) {
		int linesSum = doc.getNumberOfLines();
		List<String> strings = new ArrayList<String>();
		findElementInXML: for (int l = 0; l < linesSum; l++) {
			try {
				int start = doc.getLineOffset(l);
				
				int lengthOfString = doc.getLineLength(l);

				if (start != 0 && lengthOfString != 0) {
					String stringOfWebArtifact = doc.get(start, lengthOfString);
					if (stringOfWebArtifact.contains(startTag)) {
						strings.add(stringOfWebArtifact);
						for (int m = l + 1; m < linesSum; m++) {
							int nextStart = doc.getLineOffset(m);
							int nextStringLength = doc.getLineLength(m);
							String nextStringOfWebArtifact = doc.get(nextStart,
									nextStringLength);
							strings.add(nextStringOfWebArtifact);
							if (nextStringOfWebArtifact.contains(endTag)) {
								break findElementInXML;
							}
						}
					}
				}

			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return strings;
	}
 
    private String getFilterMappingDisplay(FilterMapping element) {
		UrlPatternType urlPatterns = null;
		String value = null;
		if (element.getUrlPatterns().size() > 0){
			urlPatterns = element.getUrlPatterns().get(0);
			value = urlPatterns.getValue();
		}else{
			FeatureMap group = element.getGroup();
			if (group.size() >0) {
				Entry entry = group.get(0);
				value = entry.getValue().toString();
			}
		}
		return value + " -> " + element.getFilterName(); //$NON-NLS-1$
	}

	private String getServletMappingDisplay(ServletMapping element) {
		UrlPatternType urlPatterns = element.getUrlPatterns().get(0);
		return urlPatterns.getValue() + " -> " + element.getServletName(); //$NON-NLS-1$;
	}

	public void setfStartTag(String startTag) {
		this.fStartTag = startTag;
	}

	public String getfStartTag() {
		return fStartTag;
	}

	public void setfEndTag(String endTag) {
		this.fEndTag = endTag;
	}

	public String getfEndTag() {
		return fEndTag;
	}

}






package org.eclipse.jst.servlet.ui.internale.ltkbasedrefactoring;

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

import org.eclipse.jst.javaee.web.FilterMapping;
import org.eclipse.jst.javaee.web.ServletMapping;
import org.eclipse.jst.javaee.web.WebApp;

public class WebRefactoringUtils {
	public static List<ServletMapping> getServletMappings(WebApp webApp, String servletName) {
        List<ServletMapping> mappings = new ArrayList<ServletMapping>();
		if (webApp == null || servletName == null) return null;
        List servletMappings = webApp.getServletMappings();
        for (Iterator iterator = servletMappings.iterator(); iterator.hasNext();) {
            ServletMapping servletMapping = (ServletMapping) iterator.next();
            if (servletName.equals(servletMapping.getServletName())) {
                mappings.add(servletMapping);
            }
        }
        return mappings;
    }
	
	public static List<FilterMapping> getFilterMappings(WebApp webApp, String filterName) {
    	List<FilterMapping> mappings = new ArrayList<FilterMapping>();
    	if (webApp == null || filterName == null ) return null;
        List filterMappings = webApp.getFilterMappings();
        for (Iterator iterator = filterMappings.iterator(); iterator.hasNext();) {
            FilterMapping filterMapping = (FilterMapping) iterator.next();
            if (filterName.equals(filterMapping.getFilterName())) {
                mappings.add(filterMapping);
            }
        }
        return mappings;
    }
}

Return to bug 289767

Lines 461-465 Link Here

(-)plugin.xml (+30 lines)
461	<adapter type="org.eclipse.jdt.core.IJavaElement"/>	461	<adapter type="org.eclipse.jdt.core.IJavaElement"/>
462	</factory>	462	</factory>
463	</extension>	463	</extension>
		464	<extension
		465	point="org.eclipse.ui.popupMenus">
		466	<objectContribution
		467	adaptable="true"
		468	id="org.eclipse.jst.servlet.ui.RemoveWebObject"
		469	objectClass="java.lang.Object">
		470	<action
		471	class="org.eclipse.jst.servlet.ui.internal.actions.DeleteWebArtifacts"
		472	enablesFor="+"
		473	icon="icons/full/delete.gif"
		474	id="org.eclipse.jst.servlet.ui.delete.web"
		475	label="Delete"
		476	menubarPath="delete">
		477	</action>
		478	<enablement>
		479	<or>
		480	<instanceof value="org.eclipse.jst.javaee.web.ServletMapping">
		481	</instanceof>
		482	<instanceof value="org.eclipse.jst.javaee.web.Servlet">
		483	</instanceof>
		484	<instanceof value="org.eclipse.jst.javaee.web.Filter">
		485	</instanceof>
		486	<instanceof value="org.eclipse.jst.javaee.web.FilterMapping">
		487	</instanceof>
		488	<instanceof value="org.eclipse.jst.javaee.core.Listener">
		489	</instanceof>
		490	</or>
		491	</enablement>
		492	</objectContribution>
		493	</extension>
464		494
465	</plugin>	495	</plugin>

Added Link Here

(-)servlet_ui/org/eclipse/jst/servlet/ui/internal/navigator/AvailableWebArtifactsDialogContentProvider.java (+36 lines)
1	package org.eclipse.jst.servlet.ui.internal.navigator;
2
3	import java.util.List;
4
5	import org.eclipse.jface.viewers.ITreeContentProvider;
6	import org.eclipse.jface.viewers.Viewer;
7
8	public class AvailableWebArtifactsDialogContentProvider implements
9	ITreeContentProvider {
10
11	public Object[] getChildren(Object parentElement) {
12	return null;
13	}
14
15	public Object getParent(Object element) {
16	return null;
17	}
18
19	public boolean hasChildren(Object element) {
20	return false;
21	}
22
23	public Object[] getElements(Object inputElement) {
24	if(inputElement instanceof List){
25	return ((List)inputElement).toArray(new Object[((List)inputElement).size()]);
26	}
27	return null;
28	}
29
30	public void dispose() {
31	}
32
33	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
34	}
35
36	}

Added Link Here

(-)servlet_ui/org/eclipse/jst/servlet/ui/internal/actions/DeleteWebArtifacts.java (+272 lines)
1	package org.eclipse.jst.servlet.ui.internal.actions;
2
3	import java.util.ArrayList;
4	import java.util.HashMap;
5	import java.util.Iterator;
6	import java.util.List;
7	import java.util.Map;
8
9	import org.eclipse.core.resources.IFile;
10	import org.eclipse.core.resources.IProject;
11	import org.eclipse.core.resources.IResource;
12	import org.eclipse.core.runtime.Path;
13	import org.eclipse.jdt.core.IJavaElement;
14	import org.eclipse.jdt.core.IPackageFragment;
15	import org.eclipse.jdt.core.IType;
16	import org.eclipse.jdt.core.JavaCore;
17	import org.eclipse.jdt.core.JavaModelException;
18	import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
19	import org.eclipse.jface.action.IAction;
20	import org.eclipse.jface.dialogs.IDialogConstants;
21	import org.eclipse.jface.viewers.ISelection;
22	import org.eclipse.jface.viewers.IStructuredSelection;
23	import org.eclipse.jface.viewers.StructuredSelection;
24	import org.eclipse.jst.j2ee.internal.web.operations.WebPropertiesUtil;
25	import org.eclipse.jst.j2ee.model.IModelProvider;
26	import org.eclipse.jst.j2ee.model.ModelProviderManager;
27	import org.eclipse.jst.j2ee.ui.ltkbasedrefactoring.J2eeDeleteRefactoringWizard;
28	import org.eclipse.jst.javaee.core.Listener;
29	import org.eclipse.jst.javaee.web.Filter;
30	import org.eclipse.jst.javaee.web.FilterMapping;
31	import org.eclipse.jst.javaee.web.Servlet;
32	import org.eclipse.jst.javaee.web.ServletMapping;
33	import org.eclipse.jst.javaee.web.WebApp;
34	import org.eclipse.jst.jee.ui.internal.navigator.web.WebAppProvider;
35	import org.eclipse.jst.jee.ui.plugin.JEEUIPlugin;
36	import org.eclipse.jst.servlet.ui.internal.navigator.AvailableWebArtifactsDialogContentProvider;
37	import org.eclipse.jst.servlet.ui.internal.navigator.AvailableWebArtifactsDialogLabelProvider;
38	import org.eclipse.jst.servlet.ui.internale.ltkbasedrefactoring.WebArtifactDeleteProcessor;
39	import org.eclipse.jst.servlet.ui.internale.ltkbasedrefactoring.WebRefactoringUtils;
40	import org.eclipse.ltk.ui.refactoring.RefactoringWizardOpenOperation;
41	import org.eclipse.swt.widgets.Shell;
42	import org.eclipse.ui.IObjectActionDelegate;
43	import org.eclipse.ui.IWorkbenchPart;
44	import org.eclipse.ui.PlatformUI;
45	import org.eclipse.ui.dialogs.CheckedTreeSelectionDialog;
46
47	public class DeleteWebArtifacts implements IObjectActionDelegate{
48
49	private ISelection sel = new StructuredSelection();
50	private IWorkbenchPart targetPart;
51	private String fullyQualifiedName;
52
53	public void setActivePart(IAction action, IWorkbenchPart targetPart) {
54	this.setTargetPart(targetPart);
55
56	}
57
58	public void run(IAction action) {
59	if (sel == null)
60	return;
61
62	IStructuredSelection selection = (StructuredSelection) sel;
63	if (!selection.isEmpty()) {
64	List<Object> selections = new ArrayList<Object>();
65	Iterator it = selection.iterator();
66	while(it.hasNext()){
67	selections.add(it.next());
68	}
69	delete(selections);
70	}
71	}
72
73	private void delete(List<Object> objects){
74	Map<Object, List<IResource>> map = new HashMap<Object, List<IResource>>();
75	for(Object object : objects){
76	getObjectsToBeDeleted(map, object);
77	}
78
79	deleteResources(objects, map);
80	}
81
82	private void deleteResources(List<Object> objects, Map<Object, List<IResource>> map ){
83
84	List<Object> javaObjects = new ArrayList<Object>();
85	for (int i = 0; i < objects.size(); i++) {
86	Object obj = objects.get(i);
87	getArtifactByMappingToBeDeleted(objects, javaObjects, obj);
88	}
89
90	if (!javaObjects.isEmpty()) {
91	Object[] obj = openDialog(javaObjects);
92	if (obj != null && obj.length != 0) {
93	for (Object ob : obj) {
94	objects.add(ob);
95	getObjectsToBeDeleted(map, ob);
96	}
97	}
98	}
99
100
101	WebArtifactDeleteProcessor processor = new WebArtifactDeleteProcessor(objects, map);
102	J2eeDeleteRefactoringWizard wiz = new J2eeDeleteRefactoringWizard(processor, objects);
103
104	RefactoringWizardOpenOperation op = new RefactoringWizardOpenOperation(wiz);
105	try {
106	String titleForFailedChecks = ""; //$NON-NLS-1$
107	op.run(new Shell(), titleForFailedChecks );
108	} catch( InterruptedException irex ) {
109	// operation was cancelled
110	}
111	}
112
113	private void getObjectsToBeDeleted(Map<Object, List<IResource>> map,
114	Object object) {
115	List<IResource> resourcesToBeMappedToObject = new ArrayList<IResource>();
116	IProject project = ProjectUtilities.getProject(object);
117	IModelProvider modelProvider = ModelProviderManager.getModelProvider(project);
118	WebApp webApp = (WebApp) modelProvider.getModelObject();
119	String container = WebPropertiesUtil.getJavaSourceFolder(project).getName();
120
121	WebAppProvider prov = new WebAppProvider(webApp, project);
122	IFile webXML = prov.getDDFile();
123	specifyObjectNameByItsType(object);
124
125	getObjectResource(resourcesToBeMappedToObject, project,
126	container);
127
128	if(!resourcesToBeMappedToObject.contains(webXML)){
129	resourcesToBeMappedToObject.add(webXML);
130	}
131	map.put(object, resourcesToBeMappedToObject);
132	}
133
134
135	private void specifyObjectNameByItsType(Object object) {
136	if(object instanceof Servlet){
137	fullyQualifiedName = ((Servlet)object).getServletClass();
138	} else if(object instanceof Filter){
139	fullyQualifiedName = ((Filter)object).getFilterClass();
140	} else if (object instanceof Listener){
141	fullyQualifiedName = ((Listener)object).getListenerClass();
142	}
143	}
144
145	private void getObjectResource(List<IResource> resourcesToBeMappedToObject, IProject project,
146	String container) {
147	if(fullyQualifiedName!=null){
148	IResource resource = project.getFile(new Path(
149	container + "/" + (fullyQualifiedName).replace(".", "/") + ".java")); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
150	if(resource !=null && resource.exists()){
151	if(!resourcesToBeMappedToObject.contains(resource)){
152	resourcesToBeMappedToObject.add(resource);
153	}
154	getPackage(resourcesToBeMappedToObject, project,
155	resource);
156	}
157	}
158	}
159
160	private void getPackage(List<IResource> resourcesToBeMappedToObject, IProject project,
161	IResource resource) {
162	IResource packageResource = resource.getParent();
163	if (getWebArtifactPackage(fullyQualifiedName, fullyQualifiedName
164	.replaceAll(packageResource.getName() + ".", ""), project)) { //$NON-NLS-1$ //$NON-NLS-2$
165	if(!resourcesToBeMappedToObject.contains(packageResource)){
166	resourcesToBeMappedToObject.add(packageResource);
167	}
168	}
169	}
170
171	private void getArtifactByMappingToBeDeleted(List<Object> objects,
172	List<Object> javaObjects, Object obj) {
173
174	if(obj instanceof FilterMapping){
175	IProject project = ProjectUtilities.getProject(obj);
176	IModelProvider modelProvider = ModelProviderManager.getModelProvider(project);
177	WebApp webApp = (WebApp) modelProvider.getModelObject();
178	Filter filter = getFilter(webApp, ((FilterMapping)obj).getFilterName());
179	List<FilterMapping> mappings = WebRefactoringUtils.getFilterMappings(webApp, filter.getFilterName());
180	if(objects.containsAll(mappings) && !objects.contains(filter) && !javaObjects.contains(filter)){
181	javaObjects.add(filter);
182	}
183	} else if(obj instanceof ServletMapping){
184	IProject project = ProjectUtilities.getProject(obj);
185	IModelProvider modelProvider = ModelProviderManager.getModelProvider(project);
186	WebApp webApp = (WebApp) modelProvider.getModelObject();
187	Servlet servlet = getServlet(webApp, ((ServletMapping)obj).getServletName());
188	List<ServletMapping> mappings = WebRefactoringUtils.getServletMappings(webApp, servlet.getServletName());
189	if(objects.containsAll(mappings) && !objects.contains(servlet) && !javaObjects.contains(servlet)){
190	javaObjects.add(servlet);
191	}
192	}
193	}
194
195
196	private Servlet getServlet(WebApp webApp, String servletName) {
197	if (webApp == null \|\| servletName == null) return null;
198	List servlets = webApp.getServlets();
199	for (Iterator iterator = servlets.iterator(); iterator.hasNext();) {
200	Servlet servlet = (Servlet) iterator.next();
201	if (servletName.equals(servlet.getServletName())) {
202	return servlet;
203	}
204	}
205	return null;
206	}
207
208	private Object[] openDialog(final List<Object> list){
209
210	CheckedTreeSelectionDialog dialog = new CheckedTreeSelectionDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), new AvailableWebArtifactsDialogLabelProvider(), new AvailableWebArtifactsDialogContentProvider());
211
212	dialog.setTitle("Delete Artifact Confirm"); //$NON-NLS-1$
213	dialog.setMessage("All mappings of these elements will be deleted. It is recommended to delete the elements."); //$NON-NLS-1$
214	dialog.setInput(list);
215
216	int pressed = dialog.open();
217	if(pressed == IDialogConstants.OK_ID){
218	return dialog.getResult();
219	}
220	return null;
221	}
222
223	private Filter getFilter(WebApp webApp, String filterName) {
224	if (webApp == null \|\| filterName == null) return null;
225	List filters = webApp.getFilters();
226	for (Iterator iterator = filters.iterator(); iterator.hasNext();) {
227	Filter filter = (Filter) iterator.next();
228	if (filterName.equals(filter.getFilterName())) {
229	return filter;
230	}
231	}
232	return null;
233	}
234
235	private boolean getWebArtifactPackage(
236	String webArtifactClass, String webArtifactName, IProject project) {
237	IPackageFragment webArtifactPackage = null;
238	try {
239	IType webArtifact = JavaCore.create(project).findType(webArtifactClass);
240	if(webArtifact!=null){
241	webArtifactPackage = webArtifact.getPackageFragment();
242	if(webArtifactPackage.hasChildren()){
243	IJavaElement[] el = webArtifactPackage.getChildren();
244	if(el.length==1){
245	if(el[0].getElementName().equals(webArtifactName+".java")){ //$NON-NLS-1$
246	return true;
247	}
248	}
249	} else {
250	return true;
251	}
252	}
253	} catch (JavaModelException e1) {
254	JEEUIPlugin.logError("Cannot find resource.", e1); //$NON-NLS-1$
255	}
256	return false;
257	}
258
259	public void selectionChanged(IAction action, ISelection selection) {
260	sel = selection;
261	}
262
263	public void setTargetPart(IWorkbenchPart targetPart) {
264	this.targetPart = targetPart;
265	}
266
267	public IWorkbenchPart getTargetPart() {
268	return targetPart;
269	}
270
271	}
272

Added Link Here

(-)servlet_ui/org/eclipse/jst/servlet/ui/internal/navigator/AvailableWebArtifactsDialogLabelProvider.java (+58 lines)
1	package org.eclipse.jst.servlet.ui.internal.navigator;
2
3	import java.net.URL;
4
5	import org.eclipse.core.resources.IProject;
6	import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
7	import org.eclipse.jface.resource.ImageDescriptor;
8	import org.eclipse.jface.viewers.ILabelProvider;
9	import org.eclipse.jface.viewers.ILabelProviderListener;
10	import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
11	import org.eclipse.jst.javaee.web.Filter;
12	import org.eclipse.jst.javaee.web.Servlet;
13	import org.eclipse.jst.jee.ui.plugin.JEEUIPluginIcons;
14	import org.eclipse.swt.graphics.Image;
15
16	public class AvailableWebArtifactsDialogLabelProvider implements ILabelProvider{
17
18	public Image getImage(Object element) {
19	Image image = null;
20	if(element instanceof Filter){
21	URL url = (URL) J2EEPlugin.getPlugin().getImage(JEEUIPluginIcons.FILTER_MAPPING);
22	ImageDescriptor imageDescriptor = ImageDescriptor.createFromURL(url);
23	image = imageDescriptor.createImage();
24	} else if (element instanceof Servlet){
25	URL url = (URL) J2EEPlugin.getPlugin().getImage(JEEUIPluginIcons.GROUP_SERVLET);
26	ImageDescriptor imageDescriptor = ImageDescriptor.createFromURL(url);
27	image = imageDescriptor.createImage();
28	}
29	return image;
30	}
31
32	public String getText(Object element) {
33	String name = null;
34	if(element instanceof Filter){
35	name = ((Filter)element).getFilterClass();
36	} else if(element instanceof Servlet){
37	name = ((Servlet)element).getServletClass();
38	}
39	IProject project = ProjectUtilities.getProject(element);
40	name = name + "-" + project.getFullPath().toString(); //$NON-NLS-1$
41	return name;
42	}
43
44	public void addListener(ILabelProviderListener listener) {
45	}
46
47	public void dispose() {
48	}
49
50	public boolean isLabelProperty(Object element, String property) {
51	return false;
52	}
53
54	public void removeListener(ILabelProviderListener listener) {
55	}
56
57	}
58