/******************************************************************************* | |
* Copyright (c) 2010 Shane Clarke. | |
* 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: | |
* Shane Clarke - initial API and implementation | |
*******************************************************************************/ | |
package org.eclipse.jst.ws.internal.jaxws.ui.wizards; | |
import java.io.FileInputStream; | |
import java.io.IOException; | |
import java.util.ArrayList; | |
import java.util.List; | |
import org.eclipse.core.resources.IFile; | |
import org.eclipse.core.resources.ResourcesPlugin; | |
import org.eclipse.core.runtime.IPath; | |
import org.eclipse.core.runtime.IStatus; | |
import org.eclipse.core.runtime.Status; | |
import org.eclipse.jdt.core.ICompilationUnit; | |
import org.eclipse.jdt.core.IJavaProject; | |
import org.eclipse.jdt.core.IType; | |
import org.eclipse.jdt.core.ITypeHierarchy; | |
import org.eclipse.jdt.core.JavaCore; | |
import org.eclipse.jdt.core.JavaModelException; | |
import org.eclipse.jdt.core.dom.AST; | |
import org.eclipse.jdt.core.dom.ASTParser; | |
import org.eclipse.jdt.core.dom.ASTVisitor; | |
import org.eclipse.jdt.core.dom.CompilationUnit; | |
import org.eclipse.jdt.core.dom.ITypeBinding; | |
import org.eclipse.jdt.core.dom.ParameterizedType; | |
import org.eclipse.jdt.core.dom.TypeDeclaration; | |
import org.eclipse.jdt.ui.JavaElementLabelProvider; | |
import org.eclipse.jdt.ui.StandardJavaElementContentProvider; | |
import org.eclipse.jface.dialogs.Dialog; | |
import org.eclipse.jface.viewers.ColumnLabelProvider; | |
import org.eclipse.jface.viewers.ISelection; | |
import org.eclipse.jface.viewers.IStructuredSelection; | |
import org.eclipse.jface.viewers.ITreeContentProvider; | |
import org.eclipse.jface.viewers.StructuredSelection; | |
import org.eclipse.jface.viewers.TreeViewer; | |
import org.eclipse.jface.viewers.TreeViewerColumn; | |
import org.eclipse.jface.viewers.Viewer; | |
import org.eclipse.jface.window.Window; | |
import org.eclipse.jface.wizard.WizardPage; | |
import org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSHandlerUtils; | |
import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIMessages; | |
import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIPlugin; | |
import org.eclipse.jst.ws.internal.jaxws.ui.filters.NewHandlerChainViewerFilter; | |
import org.eclipse.swt.SWT; | |
import org.eclipse.swt.events.SelectionAdapter; | |
import org.eclipse.swt.events.SelectionEvent; | |
import org.eclipse.swt.graphics.Image; | |
import org.eclipse.swt.layout.GridData; | |
import org.eclipse.swt.layout.GridLayout; | |
import org.eclipse.swt.widgets.Button; | |
import org.eclipse.swt.widgets.Composite; | |
import org.eclipse.swt.widgets.TreeColumn; | |
import org.eclipse.ui.PlatformUI; | |
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog; | |
import org.eclipse.ui.dialogs.ISelectionStatusValidator; | |
import org.jdom.Document; | |
import org.jdom.Element; | |
import org.jdom.JDOMException; | |
import org.jdom.input.SAXBuilder; | |
public class OrderHandlerChainPage extends WizardPage { | |
private static final String LOGICAL_HANDLER = "javax.xml.ws.handler.LogicalHandler"; //$NON-NLS-1$ | |
private static final String SOAP_HANDLER = "javax.xml.ws.handler.soap.SOAPHandler"; //$NON-NLS-1$ | |
private IStatus ok_status = new Status(IStatus.OK, JAXWSUIPlugin.PLUGIN_ID, ""); //$NON-NLS-1$ | |
private TreeViewer treeViewer; | |
private Document doc; | |
private Element root; | |
private IPath handlerChainPath; | |
private IJavaProject javaProject; | |
private boolean configure; | |
private String newHandlerClassName; | |
private String newHandlerType; | |
public OrderHandlerChainPage() { | |
super("order.handlerchain.wizard.page"); //$NON-NLS-1$ | |
setTitle(JAXWSUIMessages.JAXWS_ORDER_HANDLER_WIZARD_PAGE_TITLE); | |
setDescription(JAXWSUIMessages.JAXWS_ORDER_HANDLER_WIZARD_PAGE_DESCRIPTION); | |
} | |
public OrderHandlerChainPage(IPath handlerChainPath, IJavaProject javaProject) { | |
this(); | |
this.handlerChainPath = handlerChainPath; | |
this.javaProject = javaProject; | |
this.configure = true; | |
} | |
public Document getDocument() { | |
return doc; | |
} | |
public void refreshViewer() { | |
treeViewer.refresh(); | |
} | |
public void setSelection(ISelection selection) { | |
treeViewer.setSelection(selection, true); | |
} | |
public void createControl(Composite parent) { | |
final Composite composite = new Composite(parent, SWT.NONE); | |
GridLayout gridLayout = new GridLayout(2, false); | |
composite.setLayout(gridLayout); | |
treeViewer = new TreeViewer(composite, SWT.SINGLE | SWT.FULL_SELECTION | SWT.BORDER); | |
treeViewer.getTree().setHeaderVisible(true); | |
treeViewer.getTree().setLinesVisible(true); | |
treeViewer.setContentProvider(new HandlerChainContentProvider()); | |
TreeViewerColumn nameViewerColumn = new TreeViewerColumn(treeViewer, SWT.LEFT); | |
TreeColumn nameColumn = nameViewerColumn.getColumn(); | |
nameColumn.setWidth(200); | |
nameColumn.setMoveable(false); | |
nameColumn.setText(JAXWSUIMessages.JAXWS_HANDLER_NAME_COLUMN); | |
nameViewerColumn.setLabelProvider(new ColumnLabelProvider() { | |
@Override | |
public String getText(Object element) { | |
if (element instanceof Element) { | |
Element node = (Element) element; | |
if (node.getName().equals(JAXWSHandlerUtils.HANDLER)) { | |
Element handlerNameElement = node.getChild(JAXWSHandlerUtils.HANDLER_NAME, JAXWSHandlerUtils.JAVAEE_NS); | |
if (handlerNameElement != null) { | |
return handlerNameElement.getText().trim(); | |
} | |
} | |
if (node.getName().equals(JAXWSHandlerUtils.HANDLER_CHAIN)) { | |
return node.getName(); | |
} | |
} | |
return null; | |
} | |
@Override | |
public Image getImage(Object element) { | |
if (element instanceof Element) { | |
return PlatformUI.getWorkbench().getSharedImages().getImage( | |
org.eclipse.ui.ISharedImages.IMG_OBJ_FILE); | |
} | |
return null; | |
} | |
}); | |
TreeViewerColumn classViewerColumn = new TreeViewerColumn(treeViewer, SWT.LEFT); | |
TreeColumn classColumn = classViewerColumn.getColumn(); | |
classColumn.setWidth(200); | |
classColumn.setMoveable(false); | |
classColumn.setText(JAXWSUIMessages.JAXWS_HANDLER_CLASS_COLUMN); | |
classViewerColumn.setLabelProvider(new ColumnLabelProvider() { | |
@Override | |
public String getText(Object element) { | |
if (element instanceof Element) { | |
Element node = (Element) element; | |
if (node.getName().equals(JAXWSHandlerUtils.HANDLER)) { | |
Element handlerNameElement = node.getChild(JAXWSHandlerUtils.HANDLER_CLASS, JAXWSHandlerUtils.JAVAEE_NS); | |
if (handlerNameElement != null) { | |
return handlerNameElement.getText().trim(); | |
} | |
} | |
} | |
return null; | |
} | |
}); | |
TreeViewerColumn typeViewerColumn = new TreeViewerColumn(treeViewer, SWT.LEFT); | |
TreeColumn typeColumn = typeViewerColumn.getColumn(); | |
typeColumn.setWidth(100); | |
typeColumn.setMoveable(false); | |
typeColumn.setText(JAXWSUIMessages.JAXWS_HANDLER_TYPE_COLUMN); | |
typeViewerColumn.setLabelProvider(new ColumnLabelProvider() { | |
@Override | |
public String getText(Object element) { | |
if (element instanceof Element) { | |
Element node = (Element) element; | |
if (node.getName().equals(JAXWSHandlerUtils.HANDLER)) { | |
Element handlerClassElement = node.getChild(JAXWSHandlerUtils.HANDLER_CLASS, JAXWSHandlerUtils.JAVAEE_NS); | |
if (handlerClassElement != null) { | |
if (newHandlerClassName != null && newHandlerClassName.equals(handlerClassElement.getValue().trim())) { | |
return newHandlerType; | |
} | |
try { | |
IType handler = javaProject.findType(handlerClassElement.getText().trim()); | |
if (handler != null) { | |
ITypeHierarchy typeHierarchy = handler.newTypeHierarchy(javaProject, null); | |
IType[] allInterfaces = typeHierarchy.getAllInterfaces(); | |
for (IType aInterface : allInterfaces) { | |
if (aInterface.getFullyQualifiedName().equals(LOGICAL_HANDLER)) { | |
return JAXWSUIMessages.JAXWS_LOGICAL; | |
} | |
if (aInterface.getFullyQualifiedName().equals(SOAP_HANDLER)) { | |
return JAXWSUIMessages.JAXWS_PROTOCOL; | |
} | |
} | |
} | |
} catch (JavaModelException jme) { | |
JAXWSUIPlugin.log(jme.getStatus()); | |
} | |
} | |
} | |
} | |
return null; | |
} | |
}); | |
GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true); | |
gridData.verticalSpan = 6; | |
treeViewer.getTree().setLayoutData(gridData); | |
if (configure) { | |
Button addButton = new Button(composite, SWT.PUSH); | |
addButton.setText(JAXWSUIMessages.JAXWS_HANDLER_ADD); | |
gridData = new GridData(SWT.FILL, SWT.CENTER, true, false); | |
addButton.setLayoutData(gridData); | |
addButton.addSelectionListener(new SelectionAdapter() { | |
@Override | |
public void widgetSelected(SelectionEvent e) { | |
ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(getShell(), | |
new JavaElementLabelProvider(), new StandardJavaElementContentProvider()); | |
dialog.setTitle(JAXWSUIMessages.JAXWS_HANDLER_CONFIGURATION_HANDLER_DIALOG_TITLE); | |
dialog.setMessage(JAXWSUIMessages.JAXWS_HANDLER_CONFIGURATION_HANDLER_DIALOG_DESCRIPTION); | |
dialog.setAllowMultiple(false); | |
dialog.setInput(JavaCore.create(ResourcesPlugin.getWorkspace().getRoot())); | |
dialog.addFilter(new NewHandlerChainViewerFilter(javaProject, true, false)); | |
dialog.setValidator(new ISelectionStatusValidator() { | |
public IStatus validate(Object[] selection) { | |
if (selection.length == 1) { | |
if (selection[0] instanceof ICompilationUnit) { | |
ICompilationUnit compilationUnit = (ICompilationUnit) selection[0]; | |
if (isHandler(compilationUnit)) { | |
return ok_status; | |
} else { | |
return new Status(IStatus.ERROR, JAXWSUIPlugin.PLUGIN_ID, | |
JAXWSUIMessages.JAXWS_HANDLER_CONFIGURATION_HANDLER_DIALOG_INVALID); | |
} | |
} | |
} | |
return new Status(IStatus.ERROR, JAXWSUIPlugin.PLUGIN_ID, ""); //$NON-NLS-1$ | |
} | |
}); | |
if (dialog.open() == Window.OK) { | |
ICompilationUnit selectedHandler = (ICompilationUnit) dialog.getFirstResult(); | |
addHandler(selectedHandler.findPrimaryType().getElementName(), | |
selectedHandler.findPrimaryType().getPackageFragment().getElementName()); | |
} | |
} | |
}); | |
Button removeButton = new Button(composite, SWT.PUSH); | |
removeButton.setText(JAXWSUIMessages.JAXWS_HANDLER_REMOVE); | |
gridData = new GridData(SWT.FILL, SWT.CENTER, true, false); | |
removeButton.setLayoutData(gridData); | |
removeButton.addSelectionListener(new SelectionAdapter() { | |
@Override | |
public void widgetSelected(SelectionEvent e) { | |
IStructuredSelection selection = (IStructuredSelection) treeViewer.getSelection(); | |
if (!selection.isEmpty()) { | |
Element selected = (Element) selection.getFirstElement(); | |
if (selected.getName().equals(JAXWSHandlerUtils.HANDLER)) { | |
Element handlerChain = (Element) selected.getParent(); | |
if (handlerChain != null) { | |
handlerChain.removeContent(selected); | |
treeViewer.refresh(); | |
} | |
} | |
} | |
} | |
}); | |
} | |
Button moveUpButton = new Button(composite, SWT.PUSH); | |
moveUpButton.setText(JAXWSUIMessages.JAXWS_HANDLER_MOVE_UP); | |
gridData = new GridData(SWT.FILL, SWT.CENTER, true, false); | |
moveUpButton.setLayoutData(gridData); | |
moveUpButton.addSelectionListener(new SelectionAdapter() { | |
@Override | |
@SuppressWarnings("unchecked") | |
public void widgetSelected(SelectionEvent e) { | |
IStructuredSelection selection = (IStructuredSelection) treeViewer.getSelection(); | |
if (!selection.isEmpty()) { | |
Element selected = (Element) selection.getFirstElement(); | |
Element parent = (Element) selected.getParent(); | |
List children = parent.getChildren(); | |
int index = children.indexOf(selected); | |
if (index > 0) { | |
children.remove(selected); | |
children.add(index - 1, selected); | |
} else if (index == 0) { | |
Element root = (Element) parent.getParent(); | |
List handlerChains = root.getChildren(); | |
int topIndex = handlerChains.indexOf(parent); | |
if (topIndex > 0 && handlerChains.get(topIndex - 1) != null) { | |
children.remove(selected); | |
Element topChild = (Element) handlerChains.get(topIndex - 1); | |
topChild.getChildren().add(topChild.getChildren().size(), selected); | |
} | |
} | |
treeViewer.refresh(); | |
} | |
} | |
}); | |
Button moveDownButton = new Button(composite, SWT.PUSH); | |
moveDownButton.setText(JAXWSUIMessages.JAXWS_HANDLER_MOVE_DOWN); | |
gridData = new GridData(SWT.FILL, SWT.CENTER, true, false); | |
moveDownButton.setLayoutData(gridData); | |
moveDownButton.addSelectionListener(new SelectionAdapter() { | |
@Override | |
@SuppressWarnings("unchecked") | |
public void widgetSelected(SelectionEvent e) { | |
IStructuredSelection selection = (IStructuredSelection) treeViewer.getSelection(); | |
if (!selection.isEmpty()) { | |
Element selected = (Element) selection.getFirstElement(); | |
Element parent = (Element) selected.getParent(); | |
List children = parent.getChildren(); | |
int index = children.indexOf(selected); | |
if (index >= 0 && index < children.size() - 1) { | |
children.remove(selected); | |
children.add(index + 1, selected); | |
} else if (index == children.size() - 1) { | |
Element root = (Element) parent.getParent(); | |
List handlerChains = root.getChildren(); | |
int hIndex = handlerChains.indexOf(parent); | |
if (hIndex >= 0 && hIndex < handlerChains.size() - 1 && handlerChains.get(hIndex + 1) != null) { | |
children.remove(selected); | |
Element topChild = (Element) handlerChains.get(hIndex + 1); | |
topChild.getChildren().add(0, selected); | |
} | |
} | |
treeViewer.refresh(); | |
} | |
} | |
}); | |
if (handlerChainPath != null) { | |
setInput(handlerChainPath); | |
} | |
treeViewer.expandAll(); | |
composite.pack(); | |
setControl(composite); | |
Dialog.applyDialogFont(composite); | |
} | |
@Override | |
public void setVisible(boolean visible) { | |
super.setVisible(visible); | |
if (visible) { | |
setInput(handlerChainPath); | |
} | |
} | |
public void setHandlerChainPath(IPath handlerChainPath) { | |
this.handlerChainPath = handlerChainPath; | |
} | |
private boolean isHandler(ICompilationUnit source) { | |
final List<String> interfaces = new ArrayList<String>(); | |
ASTParser parser = ASTParser.newParser(AST.JLS3); | |
parser.setSource(source); | |
parser.setResolveBindings(true); | |
CompilationUnit compilationUnit = (CompilationUnit) parser.createAST(null); | |
compilationUnit.accept(new ASTVisitor() { | |
@Override | |
public boolean visit(TypeDeclaration typeDeclaration) { | |
@SuppressWarnings("unchecked") | |
List superInterfaces = typeDeclaration.superInterfaceTypes(); | |
for (Object object : superInterfaces) { | |
if (object instanceof ParameterizedType) { | |
ParameterizedType parameterizedType = (ParameterizedType) object; | |
ITypeBinding binding = parameterizedType.resolveBinding(); | |
if (binding != null) { | |
String qualifiedName = binding.getErasure().getQualifiedName(); | |
if (qualifiedName.equals(LOGICAL_HANDLER) || qualifiedName.equals(SOAP_HANDLER)) { | |
interfaces.add(qualifiedName); | |
break; | |
} | |
} | |
} | |
} | |
return false; | |
} | |
}); | |
return interfaces.size() > 0; | |
} | |
public void setInput(IPath handlerChainPath) { | |
if (handlerChainPath == null) { | |
return; | |
} | |
if (!handlerChainPath.isEmpty()) { | |
try { | |
IFile handlerChainFile = ResourcesPlugin.getWorkspace().getRoot().getFile(handlerChainPath); | |
if (handlerChainFile.getFileExtension().equals("xml")) { //$NON-NLS-1$ | |
if (handlerChainFile.exists() && JAXWSHandlerUtils.isHandlerChainFile(handlerChainFile)) { | |
FileInputStream handlerInputStream = new FileInputStream(handlerChainFile.getLocation().toFile()); | |
SAXBuilder builder = new SAXBuilder(); | |
doc = builder.build(handlerInputStream); | |
root = doc.getRootElement(); | |
treeViewer.setInput(root); | |
treeViewer.expandAll(); | |
} else { | |
JAXWSHandlerUtils.createHandlerChainFile(handlerChainPath); | |
setInput(handlerChainPath); | |
} | |
} | |
} catch (IOException ioe) { | |
JAXWSUIPlugin.log(ioe); | |
} catch (JDOMException jdome) { | |
JAXWSUIPlugin.log(jdome); | |
} | |
} | |
} | |
public void setJavaProject(IJavaProject javaProject) { | |
this.javaProject = javaProject; | |
} | |
public void addHandler(String newHandlerName, String packageName) { | |
if (root != null) { | |
Element handlerChainElement = root.getChild(JAXWSHandlerUtils.HANDLER_CHAIN, JAXWSHandlerUtils.JAVAEE_NS); | |
if (handlerChainElement == null) { | |
handlerChainElement = new Element(JAXWSHandlerUtils.HANDLER_CHAIN, JAXWSHandlerUtils.JAVAEE_NS); | |
root.addContent(handlerChainElement); | |
} | |
Element handlerElement = new Element(JAXWSHandlerUtils.HANDLER, JAXWSHandlerUtils.JAVAEE_NS); | |
Element handlerNameElement = new Element(JAXWSHandlerUtils.HANDLER_NAME, JAXWSHandlerUtils.JAVAEE_NS); | |
handlerNameElement.setText(newHandlerName); | |
Element handlerClassElement = new Element(JAXWSHandlerUtils.HANDLER_CLASS, JAXWSHandlerUtils.JAVAEE_NS); | |
if (packageName.trim().length() > 0) { | |
handlerClassElement.setText(packageName + "." + newHandlerName); | |
} else { | |
handlerClassElement.setText(newHandlerName); | |
} | |
handlerElement.addContent(handlerNameElement); | |
handlerElement.addContent(handlerClassElement); | |
handlerChainElement.addContent(handlerElement); | |
treeViewer.refresh(); | |
treeViewer.setSelection(new StructuredSelection(handlerElement)); | |
} | |
} | |
public void addHandler(String newHandlerName, String packageName, String newHandlerType) { | |
addHandler(newHandlerName, packageName); | |
this.newHandlerClassName = packageName + "." + newHandlerName; | |
this.newHandlerType = newHandlerType; | |
if (newHandlerType.equals(JAXWSUIMessages.JAXWS_LOGICAL_HANDLER)) { | |
this.newHandlerType = JAXWSUIMessages.JAXWS_LOGICAL; | |
} else if (newHandlerType.equals(JAXWSUIMessages.JAXWS_SOAP_HANDLER)) { | |
this.newHandlerType = JAXWSUIMessages.JAXWS_PROTOCOL; | |
} | |
} | |
private class HandlerChainContentProvider implements ITreeContentProvider { | |
public Object[] getChildren(Object parentElement) { | |
if (parentElement instanceof Element) { | |
Element element = (Element) parentElement; | |
return element.getChildren().toArray(); | |
} | |
return new Object[] {}; | |
} | |
public Object getParent(Object element) { | |
if (element instanceof Element) { | |
Element node = (Element) element; | |
return node.getParent(); | |
} | |
return null; | |
} | |
public boolean hasChildren(Object element) { | |
if (element instanceof Element) { | |
Element node = (Element) element; | |
if (node.getName().equals(JAXWSHandlerUtils.HANDLER_CHAIN)) { | |
return node.getChildren().size() > 0; | |
} | |
} | |
return false; | |
} | |
public Object[] getElements(Object inputElement) { | |
if (inputElement instanceof Element) { | |
Element element = (Element) inputElement; | |
return element.getChildren().toArray(); | |
} | |
return new Object[] {}; | |
} | |
public void dispose() { | |
} | |
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { | |
} | |
} | |
} |