| /******************************************************************************* |
| * 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.xsd.ui.internal.graph; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.viewers.ISelection; |
| 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.custom.SashForm; |
| import org.eclipse.swt.custom.ViewForm; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.TraverseEvent; |
| import org.eclipse.swt.events.TraverseListener; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.MenuItem; |
| import org.eclipse.swt.widgets.ToolBar; |
| import org.eclipse.swt.widgets.ToolItem; |
| import org.eclipse.ui.part.PageBook; |
| import org.eclipse.wst.xsd.ui.internal.XSDEditor; |
| import org.eclipse.wst.xsd.ui.internal.XSDEditorPlugin; |
| import org.eclipse.wst.xsd.ui.internal.XSDSelectionManager; |
| import org.eclipse.wst.xsd.ui.internal.graph.editparts.TopLevelComponentEditPart; |
| import org.eclipse.wst.xsd.ui.internal.provider.CategoryAdapter; |
| import org.eclipse.wst.xsd.ui.internal.util.ViewUtility; |
| import org.eclipse.xsd.XSDAttributeGroupContent; |
| import org.eclipse.xsd.XSDAttributeGroupDefinition; |
| import org.eclipse.xsd.XSDConcreteComponent; |
| import org.eclipse.xsd.XSDNotationDeclaration; |
| import org.eclipse.xsd.XSDSchema; |
| import org.eclipse.xsd.XSDSchemaDirective; |
| import org.eclipse.xsd.XSDSimpleTypeDefinition; |
| import org.eclipse.xsd.XSDWildcard; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.Text; |
| public class XSDGraphViewer implements ISelectionChangedListener |
| { |
| protected PageBook pageBook; |
| protected Control componentViewerControl; |
| protected Control inheritanceViewerControl; |
| protected Control subGroupsViewerControl; |
| protected XSDComponentViewer componentViewer; |
| protected XSDInheritanceViewer inheritanceViewer; |
| protected XSDSubstitutionGroupsViewer subGroupsViewer; |
| protected XSDSelectionManager xsdSelectionManager; |
| protected XSDSchema schema; |
| protected InternalSelectionProvider internalSelectionProvider = new InternalSelectionProvider(); |
| protected XSDEditor editor; |
| protected PrintGraphAction printGraphAction; |
| protected SashForm sashForm; |
| protected ToolItem backButton; |
| |
| public XSDGraphViewer(XSDEditor editor) |
| { |
| super(); |
| this.editor = editor; |
| } |
| |
| public void setSchema(XSDSchema schema) |
| { |
| this.schema = schema; |
| } |
| ToolBar graphToolBar; // the toolbar at the top of the graph view |
| ToolItem toolItem; // the view tool item |
| ViewForm form; // view form for holding all the views |
| Composite frameBar; // The composite that contains the toolbar |
| Composite c; // temporary blank page. Clean this up when all views completed |
| LinkedGraphViewer linkInheritanceViewer; |
| |
| protected void createInheritanceViewer(Composite parent) |
| { |
| linkInheritanceViewer = new LinkedGraphViewer(editor, internalSelectionProvider); |
| BaseGraphicalViewer graphViewer = new XSDInheritanceViewer(editor, internalSelectionProvider); |
| linkInheritanceViewer.setMajorViewer(graphViewer); |
| graphViewer = new XSDComponentViewer(editor, editor.getSelectionManager()); |
| linkInheritanceViewer.setMinorViewer(graphViewer); |
| linkInheritanceViewer.createControl(parent); |
| } |
| LinkedGraphViewer linkSubstitutionGroupViewer; |
| |
| protected void createSubstitutionGroupViewer(Composite parent) |
| { |
| linkSubstitutionGroupViewer = new LinkedGraphViewer(editor, internalSelectionProvider); |
| BaseGraphicalViewer graphViewer = new XSDSubstitutionGroupsViewer(editor, internalSelectionProvider); |
| linkSubstitutionGroupViewer.setMajorViewer(graphViewer); |
| graphViewer = new XSDComponentViewer(editor, internalSelectionProvider); |
| linkSubstitutionGroupViewer.setMinorViewer(graphViewer); |
| linkSubstitutionGroupViewer.createControl(parent); |
| } |
| static private Color dividerColor; |
| |
| public Control createControl(Composite parent) |
| { |
| pageBook = new PageBook(parent, 0); |
| |
| //componentViewer = new XSDComponentViewer(editor, internalSelectionProvider); |
| componentViewer = new XSDComponentViewer(editor, editor.getSelectionManager()); |
| ViewUtility util = new ViewUtility(); |
| final Composite client; |
| String designLayoutPosition = XSDEditorPlugin.getPlugin().getDesignLayoutPosition(); |
| form = new ViewForm(pageBook, SWT.NONE); |
| frameBar = new Composite(form, SWT.NONE); |
| org.eclipse.swt.layout.GridLayout frameLayout = new org.eclipse.swt.layout.GridLayout(); |
| frameLayout.marginWidth = 0; |
| frameLayout.marginHeight = 0; |
| frameBar.setLayout(frameLayout); |
| graphToolBar = new ToolBar(frameBar, SWT.FLAT); |
| graphToolBar.addTraverseListener(new TraverseListener() |
| { |
| public void keyTraversed(TraverseEvent e) |
| { |
| if (e.detail == SWT.TRAVERSE_MNEMONIC) |
| e.doit = false; |
| } |
| }); |
| backButton = new ToolItem(graphToolBar, SWT.PUSH); |
| backButton.setImage(XSDEditorPlugin.getXSDImage("icons/back.gif")); //$NON-NLS-1$ |
| backButton.setToolTipText(XSDEditorPlugin.getXSDString("_UI_HOVER_BACK_TO_SCHEMA_VIEW")); //$NON-NLS-1$ |
| backButton.setEnabled(false); |
| backButton.addSelectionListener(new SelectionAdapter() |
| { |
| public void widgetSelected(SelectionEvent e) |
| { |
| editor.getGraphViewer().setInput(editor.getXSDSchema()); |
| // internalSelectionProvider.setSelection(new StructuredSelection(editor.getXSDSchema())); |
| editor.getSelectionManager().setSelection(new StructuredSelection(editor.getXSDSchema())); |
| } |
| }); |
| // TEMPORARILY REMOVE DIFFERENT VIEWS |
| // toolItem = new ToolItem(graphToolBar, SWT.DROP_DOWN); |
| // |
| // // set default to containment |
| //// toolItem.setText(XSDEditorPlugin.getXSDString("_UI_CONTAINMENT")); |
| // toolItem.addSelectionListener(new SelectionAdapter() |
| // { |
| // public void widgetSelected(SelectionEvent e) |
| // { |
| // Menu menu = new Menu(graphToolBar); |
| // if (menu != null) |
| // { |
| // if (!showGraphMenu(menu)) |
| // { |
| // frameBar.setVisible(false); |
| // return; |
| // } |
| // Rectangle b = toolItem.getBounds(); |
| // org.eclipse.swt.graphics.Point p = toolItem.getParent().toDisplay(new |
| // org.eclipse.swt.graphics.Point(b.x, b.y + b.height)); |
| // menu.setLocation(p.x, p.y); |
| // menu.setVisible(true); |
| // } |
| // } |
| // }); |
| form.setTopLeft(frameBar); |
| // createInheritanceViewer(form); |
| // createSubstitutionGroupViewer(form); |
| componentViewerControl = componentViewer.createControl(form); |
| //inheritanceViewerControl = inheritanceViewer.createControl(form); |
| //subGroupsViewerControl = subGroupsViewer.createControl(form); |
| c = ViewUtility.createComposite(form, 1); |
| form.setContent(componentViewerControl); |
| // componentViewerControl.setData("layout ratio", new Float(0.65)); |
| form.setData("layout ratio", new Float(0.65)); |
| if (dividerColor == null) |
| { |
| dividerColor = new Color(componentViewerControl.getDisplay(), 143, 141, 138); |
| } |
| //KCPort |
| // client.addPaintListener(new PaintListener() |
| // { |
| // /** |
| // * @see org.eclipse.swt.events.PaintListener#paintControl(PaintEvent) |
| // */ |
| // public void paintControl(PaintEvent e) |
| // { |
| // Object source = e.getSource(); |
| // if (source instanceof Composite) |
| // { |
| // Composite comp = (Composite)source; |
| // Rectangle boundary = comp.getClientArea(); |
| // e.gc.setForeground(dividerColor); |
| // e.gc.drawLine(boundary.x, boundary.y, boundary.x + boundary.width, |
| // boundary.y); |
| // editor.setDesignWeights(sashForm.getWeights(), true); |
| // } |
| // } |
| // }); |
| // KCPort |
| // designView = new DesignViewer(editor); |
| // final Control design = designView.createControl(client); |
| // design.setLayoutData(ViewUtility.createFill()); |
| // client.setData("layout ratio", new Float(0.35)); |
| // enableDesignView(editor.isCombinedDesignAndSourceView()); |
| // pageBook.showPage(sashForm); |
| pageBook.showPage(form); |
| componentViewer.addSelectionChangedListener(internalSelectionProvider); |
| //inheritanceViewer.addSelectionChangedListener(this); |
| // Temporarily remove graph tool bar |
| // linkInheritanceViewer.addSelectionChangedListener(this); |
| // linkSubstitutionGroupViewer.addSelectionChangedListener(this); |
| printGraphAction = new PrintGraphAction(componentViewer); |
| return pageBook; |
| // return form; |
| } |
| |
| private boolean showGraphMenu(Menu menu) |
| { |
| MenuItem containmentMenuItem = new MenuItem(menu, SWT.RADIO); |
| containmentMenuItem.setText(XSDEditorPlugin.getXSDString("_UI_CONTAINMENT")); |
| containmentMenuItem.addSelectionListener(new SelectionAdapter() |
| { |
| public void widgetSelected(SelectionEvent e) |
| { |
| toolItem.setText(XSDEditorPlugin.getXSDString("_UI_CONTAINMENT")); |
| frameBar.layout(true); |
| graphToolBar.layout(true); |
| form.setContent(componentViewerControl); |
| // retrieve latest input which could have changed...from designView ?? |
| // get it directly? |
| // KCPort |
| // setInput(designView.getInput()); |
| } |
| }); |
| MenuItem inheritanceMenuItem = new MenuItem(menu, SWT.RADIO); |
| inheritanceMenuItem.setText(XSDEditorPlugin.getXSDString("_UI_INHERITANCE")); |
| inheritanceMenuItem.addSelectionListener(new SelectionAdapter() |
| { |
| public void widgetSelected(SelectionEvent e) |
| { |
| toolItem.setText(XSDEditorPlugin.getXSDString("_UI_INHERITANCE")); |
| frameBar.layout(true); |
| graphToolBar.layout(true); |
| // form.setContent(inheritanceViewerControl); |
| form.setContent(linkInheritanceViewer.getControl()); |
| if (linkInheritanceViewer.getInput() == null) |
| { |
| linkInheritanceViewer.setInput(schema); |
| } |
| } |
| }); |
| MenuItem subGroupsMenuItem = new MenuItem(menu, SWT.RADIO); |
| subGroupsMenuItem.setText(XSDEditorPlugin.getXSDString("_UI_SUBSTITUTION_GROUPS")); |
| subGroupsMenuItem.addSelectionListener(new SelectionAdapter() |
| { |
| public void widgetSelected(SelectionEvent e) |
| { |
| toolItem.setText(XSDEditorPlugin.getXSDString("_UI_SUBSTITUTION_GROUPS")); |
| frameBar.layout(true); |
| graphToolBar.layout(true); |
| form.setContent(linkSubstitutionGroupViewer.getControl()); |
| // retrieve latest input which could have changed...from designView ?? |
| // get it directly? |
| // setInput(designView.getInput()); |
| if (linkSubstitutionGroupViewer.getInput() == null) |
| { |
| linkSubstitutionGroupViewer.setInput(schema); |
| } |
| } |
| }); |
| if (toolItem.getText().equals(XSDEditorPlugin.getXSDString("_UI_CONTAINMENT"))) |
| { |
| containmentMenuItem.setSelection(true); |
| } |
| else if (toolItem.getText().equals(XSDEditorPlugin.getXSDString("_UI_INHERITANCE"))) |
| { |
| inheritanceMenuItem.setSelection(true); |
| } |
| else if (toolItem.getText().equals(XSDEditorPlugin.getXSDString("_UI_SUBSTITUTION_GROUPS"))) |
| { |
| subGroupsMenuItem.setSelection(true); |
| } |
| return true; |
| } |
| |
| public Action getPrintGraphAction() |
| { |
| return printGraphAction; |
| } |
| |
| public void updateDesignLayout(int newLayout) |
| { |
| sashForm.setOrientation(newLayout); |
| sashForm.layout(); |
| } |
| |
| public SashForm getSashForm() |
| { |
| return sashForm; |
| } |
| |
| public void enableDesignView(boolean enable) |
| { |
| } |
| |
| public XSDComponentViewer getComponentViewer() |
| { |
| return componentViewer; |
| } |
| |
| public void setBackButtonEnabled(boolean state) |
| { |
| backButton.setEnabled(state); |
| } |
| |
| public void setInput(Object object) |
| { |
| if (object instanceof XSDConcreteComponent) |
| { |
| XSDConcreteComponent xsdComp = (XSDConcreteComponent) object; |
| if (xsdComp instanceof XSDSchema) |
| { |
| setBackButtonEnabled(false); |
| } |
| else |
| { |
| setBackButtonEnabled(true); |
| } |
| componentViewer.setInput(xsdComp); |
| componentViewer.setSelection(xsdComp); |
| } |
| } |
| |
| protected boolean isDeleted(XSDConcreteComponent component) |
| { |
| boolean result = false; |
| if (component != null && component.getElement() != null) |
| { |
| result = component.getElement().getParentNode() == null; |
| } |
| return result; |
| } |
| |
| public void setSelectionManager(XSDSelectionManager newSelectionManager) |
| { |
| // disconnect from old one |
| if (xsdSelectionManager != null) |
| { |
| xsdSelectionManager.removeSelectionChangedListener(this); |
| internalSelectionProvider.removeSelectionChangedListener(xsdSelectionManager); |
| } |
| xsdSelectionManager = newSelectionManager; |
| // connect to new one |
| if (xsdSelectionManager != null) |
| { |
| xsdSelectionManager.addSelectionChangedListener(this); |
| internalSelectionProvider.addSelectionChangedListener(xsdSelectionManager); |
| } |
| } |
| |
| // this method is called by the SelectionManager to notify the graph view |
| // that the editor selection has changed |
| // |
| public void selectionChanged(SelectionChangedEvent event) |
| { |
| // here we check the selection source to ensure that this selection came |
| // from a different view (not from the graph view) |
| if (event.getSource() != getComponentViewer()) |
| { |
| handleSelection(event, true); |
| } |
| } |
| |
| 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; |
| } |
| |
| // TODO.. we need to clean this method up and add comments to clarify what's going on |
| // |
| protected void handleSelection(SelectionChangedEvent event, boolean isSelectionRequired) |
| { |
| StructuredSelection s = (StructuredSelection)event.getSelection(); |
| Object obj = s.getFirstElement(); |
| if (obj instanceof XSDConcreteComponent) |
| { |
| XSDConcreteComponent selectedComponent = (XSDConcreteComponent)obj; |
| Object currentInput = getComponentViewer().getInput(); |
| |
| // in this case we're looking at a top level view |
| // so if the selection is a 'non-top-level' component we need to do a set input |
| XSDSchema topLevelSchema = null; |
| if (currentInput instanceof XSDSchema) |
| { |
| if (selectedComponent instanceof XSDSchema || |
| selectedComponent.getContainer() instanceof XSDSchema) |
| { |
| topLevelSchema = (XSDSchema)currentInput; |
| } |
| } |
| if (selectedComponent instanceof XSDSchemaDirective || |
| selectedComponent instanceof XSDNotationDeclaration) |
| { |
| topLevelSchema = selectedComponent.getSchema(); |
| } |
| else if (selectedComponent instanceof XSDAttributeGroupContent || |
| selectedComponent instanceof XSDWildcard) |
| { |
| if (selectedComponent.getContainer() instanceof XSDAttributeGroupDefinition) |
| { |
| topLevelSchema = selectedComponent.getSchema(); |
| } |
| } |
| else if (selectedComponent instanceof XSDSimpleTypeDefinition) |
| { |
| XSDSimpleTypeDefinition st = (XSDSimpleTypeDefinition)selectedComponent; |
| EditPart editPart = componentViewer.getEditPart(componentViewer.getRootEditPart(), st); |
| if (editPart == null) |
| { |
| if (st.getContainer() == editor.getXSDSchema()) |
| { |
| topLevelSchema = selectedComponent.getSchema(); |
| } |
| } |
| } |
| |
| if (topLevelSchema != null) |
| { |
| setInput(topLevelSchema); |
| // TODO... this is not 'quite' right |
| // it should be possible to view in |
| } |
| else |
| { |
| EditPart editPart = getComponentViewer().getEditPart(getComponentViewer().getRootEditPart(), obj); |
| if (editPart == null) |
| { |
| XSDConcreteComponent topLevelComponent = getTopLevelComponent(selectedComponent); |
| if (topLevelComponent != null) |
| { |
| setInput(topLevelComponent); |
| } |
| } |
| } |
| // now we handle the selection |
| // |
| if (isSelectionRequired) |
| { |
| EditPart editPart = getComponentViewer().getRootEditPart(); |
| EditPart newSelectedEditPart = getComponentViewer().getEditPart(editPart, obj); |
| if (newSelectedEditPart != null) |
| { |
| if (newSelectedEditPart instanceof TopLevelComponentEditPart) |
| { |
| ((TopLevelComponentEditPart)newSelectedEditPart).setScroll(true); |
| } |
| getComponentViewer().setSelection(new StructuredSelection(newSelectedEditPart)); |
| } |
| } |
| } |
| else if (obj instanceof CategoryAdapter) |
| { |
| setInput(((CategoryAdapter)obj).getXSDSchema()); |
| } |
| } |
| |
| protected Element getElementNode(Node node) |
| { |
| while (!(node instanceof Element)) |
| { |
| if (node instanceof Attr) |
| { |
| node = ((Attr) node).getOwnerElement(); |
| } |
| else if (node instanceof Text) |
| { |
| Node sibling = node.getNextSibling(); |
| if (sibling == null) |
| { |
| break; |
| } |
| node = sibling; |
| } |
| else |
| { |
| Node parent = node.getParentNode(); |
| if (parent == null) |
| { |
| break; |
| } |
| node = node.getParentNode(); |
| } |
| } |
| return node instanceof Element ? (Element) node : null; |
| } |
| |
| |
| |
| // This class listens to the graph view and converts edit part selection |
| // events |
| // into XSD component selection events that can be 'fired' to the |
| // selectionManager |
| // |
| class InternalSelectionProvider implements ISelectionProvider, ISelectionChangedListener |
| { |
| protected List listenerList = new ArrayList(); |
| protected ISelection selection = new StructuredSelection(); |
| |
| public void addSelectionChangedListener(ISelectionChangedListener listener) |
| { |
| listenerList.add(listener); |
| } |
| |
| public void removeSelectionChangedListener(ISelectionChangedListener listener) |
| { |
| listenerList.remove(listener); |
| } |
| |
| public ISelection getSelection() |
| { |
| return selection; |
| } |
| |
| protected void notifyListeners(SelectionChangedEvent event) |
| { |
| for (Iterator i = listenerList.iterator(); i.hasNext();) |
| { |
| ISelectionChangedListener listener = (ISelectionChangedListener) i.next(); |
| listener.selectionChanged(event); |
| } |
| } |
| |
| public StructuredSelection convertSelectionFromEditPartToModel(ISelection editPartSelection) |
| { |
| List selectedModelObjectList = new ArrayList(); |
| if (editPartSelection instanceof IStructuredSelection) |
| { |
| for (Iterator i = ((IStructuredSelection) editPartSelection).iterator(); i.hasNext();) |
| { |
| Object obj = i.next(); |
| Object model = null; |
| if (obj instanceof EditPart) |
| { |
| EditPart editPart = (EditPart) obj; |
| model = editPart.getModel(); |
| // Convert category to XSDSchema |
| // if (editPart instanceof CategoryEditPart) |
| // { |
| // model = ((Category)((CategoryEditPart)editPart).getModel()).getXSDSchema(); |
| // } |
| } |
| else if (obj instanceof XSDConcreteComponent) |
| { |
| //cs .. not sure why would we'd ever hit this case? |
| model = obj; |
| } |
| if (model != null)//&& model instanceof XSDConcreteComponent) |
| { |
| selectedModelObjectList.add(model); |
| } |
| } |
| } |
| return new StructuredSelection(selectedModelObjectList); |
| } |
| |
| public void setSelection(ISelection selection) |
| { |
| this.selection = selection; |
| } |
| |
| // This method gets called when an edit part in the graph view is selected |
| // |
| public void selectionChanged(SelectionChangedEvent event) |
| { |
| ISelection newSelection = convertSelectionFromEditPartToModel(event.getSelection()); |
| this.selection = newSelection; |
| SelectionChangedEvent newEvent = new SelectionChangedEvent(getComponentViewer(), newSelection); |
| notifyListeners(newEvent); |
| } |
| } |
| } |
