| /******************************************************************************* |
| * Copyright (c) 2001, 2004 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 |
| *******************************************************************************/ |
| package org.eclipse.wst.wsdl.ui.internal.graph; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.ISelectionProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.KeyAdapter; |
| import org.eclipse.swt.events.KeyEvent; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.actions.ActionFactory; |
| import org.eclipse.wst.wsdl.Definition; |
| import org.eclipse.wst.wsdl.WSDLElement; |
| import org.eclipse.wst.wsdl.XSDSchemaExtensibilityElement; |
| import org.eclipse.wst.wsdl.ui.internal.WSDLEditor; |
| import org.eclipse.wst.wsdl.ui.internal.WSDLTextEditor; |
| import org.eclipse.wst.wsdl.ui.internal.actions.CopyGlobalAction; |
| import org.eclipse.wst.wsdl.ui.internal.actions.DeleteWSDLAndXSDAction; |
| import org.eclipse.wst.wsdl.ui.internal.actions.PasteGlobalAction; |
| import org.eclipse.wst.wsdl.ui.internal.graph.editparts.ComponentViewerRootEditPart; |
| import org.eclipse.wst.wsdl.ui.internal.graph.editparts.GroupEditPart; |
| import org.eclipse.wst.wsdl.ui.internal.graph.editparts.TreeNodeEditPart; |
| import org.eclipse.wst.wsdl.ui.internal.model.WSDLGroupObject; |
| import org.eclipse.wst.wsdl.ui.internal.util.SelectionAdapter; |
| import org.eclipse.wst.wsdl.ui.internal.util.WSDLEditorUtil; |
| import org.eclipse.wst.xml.core.document.IDOMNode; |
| import org.eclipse.xsd.XSDComplexTypeDefinition; |
| import org.eclipse.xsd.XSDConcreteComponent; |
| import org.eclipse.xsd.XSDElementDeclaration; |
| import org.eclipse.xsd.XSDModelGroupDefinition; |
| import org.eclipse.xsd.XSDSchema; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| |
| public class WSDLGraphViewer implements ISelectionChangedListener |
| { |
| protected Control componentViewerControl; |
| protected WSDLComponentViewer componentViewer; |
| protected Definition definition; |
| protected WSDLEditor editor; |
| protected InternalSelectionAdapter internalSelectionAdapter = new InternalSelectionAdapter(); |
| |
| GraphViewToolBar form; // Tool bar view form |
| |
| public WSDLGraphViewer(WSDLEditor editor) |
| { |
| super(); |
| this.editor = editor; |
| } |
| |
| public void setDefinition(Definition definition) |
| { |
| this.definition = definition; |
| } |
| |
| public ISelectionProvider getSelectionProvider() |
| { |
| return internalSelectionAdapter; |
| } |
| |
| public Control createControl(Composite parent) |
| { |
| componentViewer = new WSDLComponentViewer(editor, null); |
| |
| componentViewer.addSelectionChangedListener(internalSelectionAdapter); |
| internalSelectionAdapter.addSelectionChangedListener(editor.getSelectionManager()); |
| |
| form = new GraphViewToolBar(editor, parent, SWT.NONE); |
| |
| componentViewerControl = componentViewer.createControl(form); |
| form.setContent(componentViewerControl); |
| |
| editor.getSelectionManager().addSelectionChangedListener(this); |
| |
| componentViewerControl.addKeyListener(new KeyAdapter() { |
| public void keyPressed(KeyEvent e) { |
| if (e.character == SWT.DEL) { |
| List selections = ((IStructuredSelection) editor.getSelectionManager().getSelection()).toList(); |
| DeleteWSDLAndXSDAction deleteAction = new DeleteWSDLAndXSDAction(selections, editor.getDefinition().getElement(), editor); |
| deleteAction.run(); |
| } |
| } |
| }); |
| |
| return componentViewerControl; |
| } |
| |
| public WSDLComponentViewer getComponentViewer() |
| { |
| return componentViewer; |
| } |
| |
| |
| Node inputNode; |
| public void setInput(Object object) |
| { |
| componentViewer.setInput(object); |
| } |
| |
| public void setBackButtonEnabled(boolean state) |
| { |
| form.setBackButtonEnabled(state); |
| } |
| |
| //protected boolean isDeleted(Object object) |
| //} |
| |
| |
| // this is called when selection changes in the selection manager |
| // |
| |
| |
| |
| protected Object getInputComponentForNode(Node node) |
| { |
| // TODO... logic to get WSDLElement or other object (e.g. XSD or extension for the Node) |
| // TODO... consider case where the model is simply a chunk of DOM |
| return null; |
| } |
| |
| protected Object getSelectionComponentForNode(Node node) |
| { |
| // TODO... logic to get WSDLElement or other object (e.g. XSD or extension for the Node) |
| // TODO... consider case where the model is simply a chunk of DOM |
| return null; |
| } |
| |
| protected class InternalSelectionAdapter extends SelectionAdapter implements ISelectionChangedListener |
| { |
| public Object getObjectForOtherModel(Object object) |
| { |
| Object result = null; |
| if (object instanceof EditPart) |
| { |
| // fix for defect 4294 ... this test prevents selection from changing |
| // when a component is renamed which indirectly causes it to be removed and |
| // re-added from the 'sorted' list |
| // |
| if (!(object instanceof ComponentViewerRootEditPart)) |
| { |
| EditPart editPart = (EditPart)object; |
| result = editPart.getModel(); |
| } |
| } |
| return result; |
| } |
| |
| public void selectionChanged(SelectionChangedEvent event) |
| { |
| setSelection(event.getSelection()); |
| } |
| } |
| |
| // this gets called when the selection changes within the selection manager |
| // |
| public void selectionChanged(SelectionChangedEvent event) |
| { |
| //System.out.println("WSDLGraphViewer.selectionChanged( " + event.getSource() + ")"); |
| |
| IStructuredSelection selectionObject = (IStructuredSelection)event.getSelection(); |
| Object modelObject = selectionObject.getFirstElement(); |
| if (modelObject instanceof WSDLElement) { |
| Element node = ((WSDLElement) modelObject).getElement(); |
| boolean isEditable = (node instanceof IDOMNode); |
| |
| Action copyAction = new CopyGlobalAction((WSDLElement) modelObject, editor); |
| Action pasteAction = new PasteGlobalAction((WSDLElement) modelObject, editor); |
| |
| IActionBars actionBars = editor.getEditorSite().getActionBars(); |
| actionBars.setGlobalActionHandler(ActionFactory.COPY.getId(), copyAction); |
| actionBars.setGlobalActionHandler(ActionFactory.PASTE.getId(), pasteAction); |
| actionBars.updateActionBars(); |
| |
| if (!isEditable) { |
| copyAction.setEnabled(false); |
| pasteAction.setEnabled(false); |
| } |
| } |
| |
| if (event.getSource() != internalSelectionAdapter && event.getSource() != ((WSDLTextEditor)editor.getTextEditor()).getInternalSelectionProvider()) |
| { |
| boolean isEmptySelectionRequired = true; |
| if (event.getSelection() instanceof IStructuredSelection) |
| { |
| IStructuredSelection selection = (IStructuredSelection)event.getSelection(); |
| Object model = selection.getFirstElement(); |
| |
| if (model != null) |
| { |
| EditPart editPart = getEditPart(componentViewer.getRootEditPart(), model); |
| if (editPart == null) |
| { |
| editPart = expandToReveal(componentViewer.getRootEditPart(), model); |
| } |
| if (editPart == null) |
| { |
| if (model instanceof XSDConcreteComponent) { |
| model = getTopLevelComponent((XSDConcreteComponent) model); |
| |
| if (model instanceof XSDElementDeclaration || |
| model instanceof XSDComplexTypeDefinition || |
| model instanceof XSDModelGroupDefinition || |
| model instanceof XSDSchema) { |
| componentViewer.setInput(model); |
| } |
| } |
| else if (model instanceof WSDLElement || model instanceof WSDLGroupObject) { |
| // We need to switch the output to Definition |
| componentViewer.setInput(editor.getDefinition()); |
| editPart = getEditPart(componentViewer.getRootEditPart(), model); |
| if (editPart == null) |
| { |
| editPart = expandToReveal(componentViewer.getRootEditPart(), model); |
| } |
| } |
| else |
| { |
| // bad hack to convert xsd editor category to xsd object |
| // see also WSDLTabbedPropertySheetPage |
| Node node = WSDLEditorUtil.getInstance().getNodeForObject(model); |
| Object o = WSDLEditorUtil.getInstance().findModelObjectForElement(editor.getDefinition(), (Element)node); |
| if (o instanceof XSDSchemaExtensibilityElement) |
| { |
| Object obj = ((XSDSchemaExtensibilityElement)o).getSchema(); |
| componentViewer.setInput(obj); |
| } |
| } |
| } |
| if (editPart != null) |
| { |
| isEmptySelectionRequired = false; |
| componentViewer.setSelection(new StructuredSelection(editPart)); |
| scrollIntoView(editPart); |
| } |
| } |
| } |
| if (isEmptySelectionRequired) |
| { |
| componentViewer.setSelection(new StructuredSelection()); |
| } |
| } |
| } |
| |
| protected XSDConcreteComponent getTopLevelComponent(XSDConcreteComponent component) |
| { |
| XSDConcreteComponent prev = component; |
| XSDConcreteComponent container = component; |
| while ( container != null && !(container instanceof XSDSchema)) |
| { |
| prev = container; |
| container = container.getContainer(); |
| } |
| return container != null ? prev : null; |
| } |
| |
| protected EditPart getEditPart(EditPart editPart, Object model) |
| { |
| EditPart result = null; |
| if (editPart.getModel() == model) |
| { |
| result = editPart; |
| } |
| else |
| { |
| for (Iterator i = editPart.getChildren().iterator(); i.hasNext(); ) |
| { |
| result = getEditPart((EditPart)i.next(), model); |
| if (result != null) |
| { |
| break; |
| } |
| } |
| } |
| return result; |
| } |
| |
| |
| public EditPart expandToReveal(EditPart editPart, Object model) |
| { |
| // here we create the parent list |
| // |
| List parentList = new ArrayList(); |
| for (Object o = model; o != null; o = getParent(o)) |
| { |
| parentList.add(0, o); |
| } |
| EditPart result = expandToRevealHelper(editPart, parentList, 0); |
| |
| return result; |
| } |
| |
| |
| public EditPart expandToRevealHelper(EditPart editPart, List parentList, int index) |
| { |
| EditPart result = null; |
| int parentListSize = parentList.size(); |
| Object model = index < parentListSize ? parentList.get(index) : null; |
| if (model != null && editPart != null) |
| { |
| // search editpart and its descendants to find a match for this model object |
| // |
| result = getEditPart(editPart, model); |
| //System.out.println("getEditPart(" + index + ", " + model + ") = " + result); |
| } |
| |
| if (result != null) |
| { |
| if (index < (parentListSize - 1)) |
| { |
| // we've found the editPart for the item in the parentList |
| // now we need to find the next item |
| if (result instanceof TreeNodeEditPart) |
| { |
| ((TreeNodeEditPart)result).setExpanded(true); |
| } |
| result = expandToRevealHelper(result, parentList, index + 1); |
| } |
| } |
| return result; |
| } |
| |
| |
| protected Object getParent(Object model) |
| { |
| Object parent = null; |
| if (model instanceof EObject) |
| { |
| parent = ((EObject)model).eContainer(); |
| } |
| return parent; |
| } |
| |
| |
| public void scrollIntoView(EditPart editPart) |
| { |
| for (EditPart parent = editPart.getParent(); parent != null; parent = parent.getParent()) |
| { |
| if (parent instanceof GroupEditPart) |
| { |
| GroupEditPart groupEditPart = (GroupEditPart)parent; |
| groupEditPart.scrollToRevealEditPart(editPart); |
| break; |
| } |
| } |
| } |
| } |
