| /******************************************************************************* |
| * 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; |
| |
| import java.util.ArrayList; |
| import java.util.EventObject; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.emf.common.command.BasicCommandStack; |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.common.command.CommandStackListener; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.util.IPropertyChangeListener; |
| import org.eclipse.jface.util.PropertyChangeEvent; |
| import org.eclipse.jface.viewers.DoubleClickEvent; |
| import org.eclipse.jface.viewers.IDoubleClickListener; |
| import org.eclipse.jface.viewers.IPostSelectionProvider; |
| 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.widgets.Control; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorSite; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IPartListener; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.editors.text.ILocationProvider; |
| import org.eclipse.ui.views.contentoutline.IContentOutlinePage; |
| import org.eclipse.ui.views.properties.IPropertySheetPage; |
| import org.eclipse.wst.common.ui.properties.internal.provisional.ITabbedPropertySheetPageContributor; |
| import org.eclipse.wst.sse.core.internal.provisional.INodeNotifier; |
| import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel; |
| import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion; |
| import org.eclipse.wst.sse.core.internal.provisional.events.IStructuredDocumentListener; |
| import org.eclipse.wst.sse.core.internal.undo.IStructuredTextUndoManager; |
| import org.eclipse.wst.sse.ui.StructuredTextEditor; |
| import org.eclipse.wst.sse.ui.internal.contentoutline.ConfigurableContentOutlinePage; |
| import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel; |
| import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode; |
| import org.eclipse.wst.xsd.ui.internal.graph.XSDGraphViewer; |
| import org.eclipse.wst.xsd.ui.internal.properties.section.XSDTabbedPropertySheetPage; |
| import org.eclipse.wst.xsd.ui.internal.provider.CategoryAdapter; |
| import org.eclipse.wst.xsd.ui.internal.provider.XSDAdapterFactoryLabelProvider; |
| import org.eclipse.wst.xsd.ui.internal.provider.XSDModelAdapterFactoryImpl; |
| import org.eclipse.wst.xsd.ui.internal.text.XSDModelAdapter; |
| import org.eclipse.wst.xsd.ui.internal.util.OpenOnSelectionHelper; |
| import org.eclipse.xsd.XSDComponent; |
| import org.eclipse.xsd.XSDConcreteComponent; |
| import org.eclipse.xsd.XSDSchema; |
| import org.eclipse.xsd.util.XSDConstants; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.ProcessingInstruction; |
| |
| // public class XSDEditor extends StructuredTextMultiPageEditorPart |
| public class XSDEditor extends XSDMultiPageEditorPart implements ITabbedPropertySheetPageContributor { |
| protected StructuredTextEditor textEditor; |
| IFile resourceFile; |
| XSDSelectionManager xsdSelectionManager; |
| XSDModelAdapter schemalNodeAdapter; |
| |
| private IStructuredModel result; |
| |
| /** |
| * Listener on SSE's outline page's selections that converts DOM |
| * selections into wsdl selections and notifies WSDL selection manager |
| */ |
| class OutlineTreeSelectionChangeListener implements ISelectionChangedListener, IDoubleClickListener { |
| public OutlineTreeSelectionChangeListener() { |
| } |
| |
| private ISelection getXSDSelection(ISelection selection) { |
| ISelection sel = null; |
| if (selection instanceof IStructuredSelection) { |
| IStructuredSelection structuredSelection = (IStructuredSelection) selection; |
| Object o = structuredSelection.getFirstElement(); |
| if (o != null) |
| sel = new StructuredSelection(o); |
| } |
| return sel; |
| } |
| |
| /** |
| * Determines DOM node based on object (xsd node) |
| * |
| * @param object |
| * @return |
| */ |
| private Object getObjectForOtherModel(Object object) { |
| Node node = null; |
| |
| if (object instanceof Node) { |
| node = (Node) object; |
| } |
| else if (object instanceof XSDComponent) { |
| node = ((XSDComponent) object).getElement(); |
| } |
| else if (object instanceof CategoryAdapter) { |
| node = ((CategoryAdapter) object).getXSDSchema().getElement(); |
| } |
| |
| // the text editor can only accept sed nodes! |
| // |
| if (!(node instanceof IDOMNode)) { |
| node = null; |
| } |
| return node; |
| } |
| |
| public void doubleClick(DoubleClickEvent event) { |
| /* |
| * Selection in outline tree changed so set outline tree's |
| * selection into editor's selection and say it came from outline |
| * tree |
| */ |
| if (getSelectionManager() != null && getSelectionManager().enableNotify) { |
| ISelection selection = getXSDSelection(event.getSelection()); |
| if (selection != null) { |
| getSelectionManager().setSelection(selection, fOutlinePage); |
| } |
| |
| if (getTextEditor() != null && selection instanceof IStructuredSelection) { |
| int start = -1; |
| int length = 0; |
| Object o = ((IStructuredSelection) selection).getFirstElement(); |
| if (o != null) |
| o = getObjectForOtherModel(o); |
| if (o instanceof IndexedRegion) { |
| start = ((IndexedRegion) o).getStartOffset(); |
| length = ((IndexedRegion) o).getEndOffset() - start; |
| } |
| if (start > -1) { |
| getTextEditor().selectAndReveal(start, length); |
| } |
| } |
| } |
| } |
| |
| public void selectionChanged(SelectionChangedEvent event) { |
| /* |
| * Selection in outline tree changed so set outline tree's |
| * selection into editor's selection and say it came from outline |
| * tree |
| */ |
| if (getSelectionManager() != null) { // && getSelectionManager().enableNotify) { |
| |
| ISelection selection = getXSDSelection(event.getSelection()); |
| if (selection != null) { |
| getSelectionManager().setSelection(selection, fOutlinePage); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Listener on SSE's source editor's selections that converts DOM |
| * selections into xsd selections and notifies XSD selection manager |
| */ |
| private class SourceEditorSelectionListener implements ISelectionChangedListener { |
| /** |
| * Determines XSD node based on object (DOM node) |
| * |
| * @param object |
| * @return |
| */ |
| private Object getXSDNode(Object object) { |
| // get the element node |
| Element element = null; |
| if (object instanceof Node) { |
| Node node = (Node) object; |
| if (node != null) { |
| if (node.getNodeType() == Node.ELEMENT_NODE) { |
| element = (Element) node; |
| } |
| else if (node.getNodeType() == Node.ATTRIBUTE_NODE) { |
| element = ((Attr) node).getOwnerElement(); |
| } |
| } |
| } |
| Object o = element; |
| if (element != null) { |
| Object modelObject = getXSDSchema().getCorrespondingComponent(element); |
| if (modelObject != null) { |
| o = modelObject; |
| } |
| } |
| return o; |
| } |
| |
| public void selectionChanged(SelectionChangedEvent event) { |
| ISelection selection = event.getSelection(); |
| if (selection instanceof IStructuredSelection) { |
| List xsdSelections = new ArrayList(); |
| for (Iterator i = ((IStructuredSelection) selection).iterator(); i.hasNext();) { |
| Object domNode = i.next(); |
| Object xsdNode = getXSDNode(domNode); |
| if (xsdNode != null) { |
| xsdSelections.add(xsdNode); |
| } |
| } |
| |
| if (!xsdSelections.isEmpty()) { |
| StructuredSelection xsdSelection = new StructuredSelection(xsdSelections); |
| getSelectionManager().setSelection(xsdSelection, getTextEditor().getSelectionProvider()); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Listener on XSD's selection manager's selections that converts XSD |
| * selections into DOM selections and notifies SSE's selection provider |
| */ |
| private class XSDSelectionManagerSelectionListener implements ISelectionChangedListener { |
| /** |
| * Determines DOM node based on object (xsd node) |
| * |
| * @param object |
| * @return |
| */ |
| private Object getObjectForOtherModel(Object object) { |
| Node node = null; |
| |
| if (object instanceof Node) { |
| node = (Node) object; |
| } |
| else if (object instanceof XSDComponent) { |
| node = ((XSDComponent) object).getElement(); |
| } |
| else if (object instanceof CategoryAdapter) { |
| node = ((CategoryAdapter) object).getXSDSchema().getElement(); |
| } |
| |
| // the text editor can only accept sed nodes! |
| // |
| if (!(node instanceof IDOMNode)) { |
| node = null; |
| } |
| return node; |
| } |
| |
| public void selectionChanged(SelectionChangedEvent event) { |
| // do not fire selection in source editor if selection event came |
| // from source editor |
| if (event.getSource() != getTextEditor().getSelectionProvider()) { |
| ISelection selection = event.getSelection(); |
| if (selection instanceof IStructuredSelection) { |
| List otherModelObjectList = new ArrayList(); |
| for (Iterator i = ((IStructuredSelection) selection).iterator(); i.hasNext();) { |
| Object modelObject = i.next(); |
| Object otherModelObject = getObjectForOtherModel(modelObject); |
| if (otherModelObject != null) { |
| otherModelObjectList.add(otherModelObject); |
| } |
| } |
| if (!otherModelObjectList.isEmpty()) { |
| StructuredSelection nodeSelection = new StructuredSelection(otherModelObjectList); |
| getTextEditor().getSelectionProvider().setSelection(nodeSelection); |
| } |
| } |
| } |
| } |
| } |
| |
| public XSDEditor() { |
| super(); |
| xsdSelectionManager = new XSDSelectionManager(); |
| } |
| |
| InternalPartListener partListener = new InternalPartListener(this); |
| |
| // show outline view - defect 266116 |
| public void init(IEditorSite site, IEditorInput editorInput) throws PartInitException { |
| super.init(site, editorInput); |
| IWorkbenchWindow dw = PlatformUI.getWorkbench().getActiveWorkbenchWindow(); |
| IWorkbenchPage page = dw.getActivePage(); |
| getSite().getPage().addPartListener(partListener); |
| try { |
| if (page != null) { |
| // page.showView("org.eclipse.ui.views.ContentOutline"); |
| page.showView("org.eclipse.ui.views.PropertySheet"); |
| } |
| } |
| catch (PartInitException e) { |
| // e.printStackTrace(); |
| } |
| } |
| |
| // For team support |
| // protected PropertyDirtyChangeListener propertyChangeListener; |
| |
| /** |
| * Creates the pages of this multi-page editor. |
| * <p> |
| * Subclasses of <code>MultiPageEditor</code> must implement this |
| * method. |
| * </p> |
| */ |
| protected void createPages() { |
| try { |
| if (!loadFile()) |
| return; |
| |
| xsdModelAdapterFactory = XSDModelAdapterFactoryImpl.getInstance(); |
| adapterFactoryLabelProvider = new XSDAdapterFactoryLabelProvider(xsdModelAdapterFactory); |
| |
| // source page MUST be created before design page, now |
| createSourcePage(); |
| |
| addSourcePage(); |
| buildXSDModel(); |
| |
| // comment this line out to hide the graph page |
| // |
| createAndAddGraphPage(); |
| |
| int pageIndexToShow = getDefaultPageTypeIndex(); |
| setActivePage(pageIndexToShow); |
| |
| openOnSelectionHelper = new OpenOnSelectionHelper(textEditor, getXSDSchema()); |
| // added selection listeners after setting selection to avoid |
| // navigation exception |
| ISelectionProvider provider = getTextEditor().getSelectionProvider(); |
| fSourceEditorSelectionListener = new SourceEditorSelectionListener(); |
| if (provider instanceof IPostSelectionProvider) { |
| ((IPostSelectionProvider) provider).addPostSelectionChangedListener(fSourceEditorSelectionListener); |
| } |
| else { |
| provider.addSelectionChangedListener(fSourceEditorSelectionListener); |
| } |
| fXSDSelectionListener = new XSDSelectionManagerSelectionListener(); |
| getSelectionManager().addSelectionChangedListener(fXSDSelectionListener); |
| |
| addCommandStackListener(); |
| |
| XSDEditorPlugin.getPlugin().getPreferenceStore().addPropertyChangeListener(preferenceStoreListener); |
| } |
| catch (PartInitException e) { |
| // log for now, unless we find reason not to |
| Logger.log(Logger.INFO, e.getMessage()); |
| } |
| } |
| |
| |
| public void buildXSDModel() { |
| try { |
| Document document = ((IDOMModel) getModel()).getDocument(); |
| |
| boolean schemaNodeExists = document.getElementsByTagNameNS(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001, "schema").getLength() == 1; |
| |
| if (document.getChildNodes().getLength() == 0 || !schemaNodeExists) { |
| createDefaultSchemaNode(document); |
| } |
| |
| if (document instanceof INodeNotifier) { |
| INodeNotifier notifier = (INodeNotifier) document; |
| schemalNodeAdapter = (XSDModelAdapter) notifier.getAdapterFor(XSDModelAdapter.class); |
| if (schemalNodeAdapter == null) { |
| schemalNodeAdapter = new XSDModelAdapter(); |
| notifier.addAdapter(schemalNodeAdapter); |
| schemalNodeAdapter.createSchema(document.getDocumentElement()); |
| } |
| } |
| } |
| catch (Exception e) { |
| // XSDEditorPlugin.getPlugin().getMsgLogger().write("Failed to |
| // create Model"); |
| // XSDEditorPlugin.getPlugin().getMsgLogger().write(e); |
| // e.printStackTrace(); |
| } |
| |
| |
| |
| // XSDResourceFactoryImpl.validate(xsdSchema, |
| // input.getFile().getContents(true)); |
| } |
| |
| public String[] getPropertyCategories() { |
| return new String[]{"general", "namespace", "other", "attributes", "documentation", "facets"}; //$NON-NLS-1$ |
| } |
| |
| /** |
| * @see org.eclipse.wst.common.ui.properties.internal.provisional.ITabbedPropertySheetPageContributor#getContributorId() |
| */ |
| public String getContributorId() { |
| return "org.eclipse.wst.xsd.ui.internal.XSDEditor"; |
| // return getSite().getId(); |
| } |
| |
| protected CommandStackListener commandStackListener; |
| |
| protected void addCommandStackListener() { |
| if (commandStackListener == null) { |
| IStructuredTextUndoManager undoManager = getModel().getUndoManager(); |
| commandStackListener = new CommandStackListener() { |
| /** |
| * @see org.eclipse.emf.common.command.CommandStackListener#commandStackChanged(EventObject) |
| */ |
| public void commandStackChanged(EventObject event) { |
| Object obj = event.getSource(); |
| if (obj instanceof BasicCommandStack) { |
| BasicCommandStack stack = (BasicCommandStack) obj; |
| Command recentCommand = stack.getMostRecentCommand(); |
| Command redoCommand = stack.getRedoCommand(); |
| Command undoCommand = stack.getUndoCommand(); |
| if (recentCommand == redoCommand) { |
| // there must have been an undo reset info tasks |
| resetInformationTasks(); |
| } |
| } |
| } |
| }; |
| |
| // TODO WTP Port |
| // undoManager.getCommandStack().addCommandStackListener(commandStackListener); |
| |
| } |
| } |
| |
| protected void pageChange(int arg) { |
| super.pageChange(arg); |
| } |
| |
| protected void removeCommandStackListener() { |
| if (commandStackListener != null) { |
| IStructuredTextUndoManager undoManager = getModel().getUndoManager(); |
| // TODO WTP Port |
| // undoManager.getCommandStack().removeCommandStackListener(commandStackListener); |
| } |
| } |
| |
| // This is from the IValidateEditEditor interface |
| /* |
| * public void undoChange() { StructuredTextUndoManager undoManager = |
| * textEditor.getModel().getUndoManager(); undoManager.undo(); // Make the |
| * editor clean textEditor.getModel().setDirtyState(false); } |
| */ |
| |
| private class PreferenceStoreListener implements IPropertyChangeListener { |
| /** |
| * @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(PropertyChangeEvent) |
| */ |
| public void propertyChange(PropertyChangeEvent event) { |
| } |
| } |
| |
| protected IPropertyChangeListener preferenceStoreListener = new PreferenceStoreListener(); |
| |
| protected int getDefaultPageTypeIndex() { |
| int pageIndex = sourcePageIndex; |
| |
| if (XSDEditorPlugin.getPlugin().getDefaultPage().equals(XSDEditorPlugin.GRAPH_PAGE)) { |
| if (graphPageIndex != -1) |
| pageIndex = graphPageIndex; |
| } |
| |
| return pageIndex; |
| } |
| |
| int currentPage = -1; |
| |
| public String getCurrentPageType() { |
| // should update pref. for valid pages |
| if (getActivePage() != -1) { |
| currentPage = getActivePage(); |
| } |
| if (currentPage == graphPageIndex) { |
| return XSDEditorPlugin.GRAPH_PAGE; |
| } |
| else { |
| return XSDEditorPlugin.SOURCE_PAGE; |
| } |
| } |
| |
| public Object getActivePart() { |
| return getSite().getWorkbenchWindow().getActivePage().getActivePart(); |
| } |
| |
| public void dispose() { |
| // some things in the configuration need to clean |
| // up after themselves |
| if (fOutlinePage != null) { |
| if (fOutlinePage instanceof ConfigurableContentOutlinePage && fOutlineListener != null) { |
| ((ConfigurableContentOutlinePage) fOutlinePage).removeDoubleClickListener(fOutlineListener); |
| } |
| if (fOutlineListener != null) { |
| fOutlinePage.removeSelectionChangedListener(fOutlineListener); |
| } |
| } |
| ISelectionProvider provider = getTextEditor().getSelectionProvider(); |
| if (provider instanceof IPostSelectionProvider) { |
| ((IPostSelectionProvider) provider).removePostSelectionChangedListener(fSourceEditorSelectionListener); |
| } |
| else { |
| provider.removeSelectionChangedListener(fSourceEditorSelectionListener); |
| } |
| getSelectionManager().removeSelectionChangedListener(fXSDSelectionListener); |
| |
| // propertyChangeListener.dispose(); |
| removeCommandStackListener(); |
| |
| XSDEditorPlugin.getPlugin().setDefaultPage(getCurrentPageType()); |
| XSDEditorPlugin.getPlugin().getPreferenceStore().removePropertyChangeListener(preferenceStoreListener); |
| |
| getSite().getPage().removePartListener(partListener); |
| |
| // KB: Temporary solution for bug 99468 |
| IStructuredModel myModel = textEditor.getModel(); |
| if (myModel != null && myModel instanceof IStructuredDocumentListener) |
| myModel.getStructuredDocument().removeDocumentChangingListener((IStructuredDocumentListener) myModel); |
| |
| textEditor = null; |
| resourceFile = null; |
| xsdSelectionManager = null; |
| schemalNodeAdapter = null; |
| result = null; |
| partListener = null; |
| commandStackListener = null; |
| preferenceStoreListener = null; |
| openOnSelectionHelper = null; |
| graphViewer = null; |
| |
| super.dispose(); |
| |
| // release the schema model |
| // |
| if (schemalNodeAdapter != null) { |
| schemalNodeAdapter.clear(); |
| schemalNodeAdapter = null; |
| } |
| } |
| |
| protected boolean loadFile() { |
| Object input = getEditorInput(); |
| |
| if (input instanceof IFileEditorInput) { |
| resourceFile = ((IFileEditorInput) input).getFile(); |
| } |
| else if (input instanceof ILocationProvider) { |
| IPath path = ((ILocationProvider) input).getPath(input); |
| String ext = path.getFileExtension(); |
| if (ext != null && ext.equals("xsd")) { |
| return true; |
| } |
| return false; |
| } |
| else { |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Method openOnGlobalReference. The comp argument is a resolved xsd |
| * schema object from another file. This is created and called from |
| * another schema model to allow F3 navigation to open a new editor and |
| * choose the referenced object within that editor context |
| * |
| * @param comp |
| */ |
| public void openOnGlobalReference(XSDConcreteComponent comp) { |
| openOnSelectionHelper.openOnGlobalReference(comp); |
| } |
| |
| protected OpenOnSelectionHelper openOnSelectionHelper; |
| |
| public OpenOnSelectionHelper getOpenOnSelectionHelper() { |
| return openOnSelectionHelper; |
| } |
| |
| /** |
| * @see org.eclipse.wst.xsd.ui.internal.XSDMultiPageEditorPart#createTextEditor() |
| */ |
| protected StructuredTextEditor createTextEditor() { |
| textEditor = new StructuredTextEditor(); |
| return textEditor; |
| } |
| |
| /* |
| * @see StructuredTextMultiPageEditorPart#createSourcePage() |
| */ |
| protected void createSourcePage() throws PartInitException { |
| super.createSourcePage(); |
| } |
| |
| int sourcePageIndex = -1; |
| |
| /** |
| * Adds the source page of the multi-page editor. |
| */ |
| protected void addSourcePage() throws PartInitException { |
| |
| sourcePageIndex = addPage(textEditor, getEditorInput()); |
| setPageText(sourcePageIndex, XSDEditorPlugin.getXSDString("_UI_TAB_SOURCE")); |
| |
| // the update's critical, to get viewer selection manager and |
| // highlighting to work |
| textEditor.update(); |
| firePropertyChange(PROP_TITLE); |
| } |
| |
| int graphPageIndex = -1; |
| XSDGraphViewer graphViewer; |
| |
| /** |
| * Creates the graph page and adds it to the multi-page editor. |
| */ |
| protected void createAndAddGraphPage() throws PartInitException { |
| graphViewer = new XSDGraphViewer(this); |
| graphViewer.setSchema(getXSDSchema()); |
| Control graphControl = graphViewer.createControl(getContainer()); |
| graphPageIndex = addPage(graphControl); |
| setPageText(graphPageIndex, XSDEditorPlugin.getXSDString("_UI_TAB_GRAPH")); |
| |
| // graphViewer.setViewerSelectionManager(textEditor.getViewerSelectionManager()); |
| graphViewer.setSelectionManager(getSelectionManager()); |
| |
| // this forces the editor to initially select the top level schema |
| // object |
| // |
| if (getXSDSchema() != null) { |
| getSelectionManager().setSelection(new StructuredSelection(getXSDSchema())); |
| } |
| } |
| |
| protected XSDModelAdapterFactoryImpl xsdModelAdapterFactory; |
| protected XSDAdapterFactoryLabelProvider adapterFactoryLabelProvider; |
| private IPropertySheetPage fPropertySheetPage; |
| private IContentOutlinePage fOutlinePage; |
| private OutlineTreeSelectionChangeListener fOutlineListener; |
| private SourceEditorSelectionListener fSourceEditorSelectionListener; |
| private XSDSelectionManagerSelectionListener fXSDSelectionListener; |
| |
| /* |
| * @see IAdaptable#getAdapter(Class) |
| */ |
| public Object getAdapter(Class key) { |
| Object result = null; |
| if (key == ISelectionProvider.class) { |
| result = xsdSelectionManager; |
| } |
| if (IPropertySheetPage.class.equals(key)) { |
| fPropertySheetPage = new XSDTabbedPropertySheetPage(this); |
| |
| ((XSDTabbedPropertySheetPage) fPropertySheetPage).setXSDModelAdapterFactory(xsdModelAdapterFactory); |
| ((XSDTabbedPropertySheetPage) fPropertySheetPage).setSelectionManager(getSelectionManager()); |
| ((XSDTabbedPropertySheetPage) fPropertySheetPage).setXSDSchema(getXSDSchema()); |
| |
| return fPropertySheetPage; |
| } |
| else if (IContentOutlinePage.class.equals(key)) { |
| if (fOutlinePage == null || fOutlinePage.getControl() == null || fOutlinePage.getControl().isDisposed()) { |
| IContentOutlinePage page = (IContentOutlinePage) super.getAdapter(key); |
| if (page != null) { |
| fOutlineListener = new OutlineTreeSelectionChangeListener(); |
| page.addSelectionChangedListener(fOutlineListener); |
| if (page instanceof ConfigurableContentOutlinePage) { |
| ((ConfigurableContentOutlinePage) page).addDoubleClickListener(fOutlineListener); |
| } |
| } |
| fOutlinePage = page; |
| // XSDContentOutlinePage outlinePage = new |
| // XSDContentOutlinePage(this); |
| // XSDContentProvider xsdContentProvider = new |
| // XSDContentProvider(xsdModelAdapterFactory); |
| // xsdContentProvider.setXSDSchema(getXSDSchema()); |
| // outlinePage.setContentProvider(xsdContentProvider); |
| // outlinePage.setLabelProvider(adapterFactoryLabelProvider); |
| // outlinePage.setModel(getXSDSchema().getDocument()); |
| // |
| // fOutlinePage = outlinePage; |
| } |
| return fOutlinePage; |
| } |
| else { |
| result = super.getAdapter(key); |
| } |
| return result; |
| } |
| |
| |
| public XSDModelAdapterFactoryImpl getXSDModelAdapterFactory() { |
| return xsdModelAdapterFactory; |
| } |
| |
| public XSDAdapterFactoryLabelProvider getLabelProvider() { |
| return adapterFactoryLabelProvider; |
| } |
| |
| |
| public XSDSelectionManager getSelectionManager() { |
| return xsdSelectionManager; |
| } |
| |
| /** |
| * @see org.eclipse.wst.xsd.ui.internal.XSDMultiPageEditorPart#doSaveAs() |
| */ |
| public void doSaveAs() { |
| super.doSaveAs(); |
| } |
| |
| public void doSave(org.eclipse.core.runtime.IProgressMonitor monitor) { |
| super.doSave(monitor); |
| } |
| |
| public void reparseSchema() { |
| // TODO cs : Are there no better ways to make the model |
| // reload it's dependencies? This seems rather extreme. |
| // |
| Document document = ((IDOMModel) getModel()).getDocument(); |
| if (schemalNodeAdapter != null) { |
| schemalNodeAdapter.createSchema(document.getDocumentElement()); |
| } |
| } |
| |
| /** |
| * Returns the xsdSchema. |
| * |
| * @return XSDSchema |
| */ |
| public XSDSchema getXSDSchema() { |
| return schemalNodeAdapter != null ? schemalNodeAdapter.getSchema() : null; |
| } |
| |
| |
| /** |
| * Returns the resourceFile. |
| * |
| * @return IFile |
| */ |
| public IFile getFileResource() { |
| return resourceFile; |
| } |
| |
| /** |
| * Get the IDocument from the text viewer |
| */ |
| public IDocument getEditorIDocument() { |
| IDocument document = textEditor.getTextViewer().getDocument(); |
| return document; |
| } |
| |
| /** |
| * Create ref integrity tasks in task list |
| */ |
| public void createTasksInTaskList(ArrayList messages) { |
| // DisplayErrorInTaskList tasks = new |
| // DisplayErrorInTaskList(getEditorIDocument(), getFileResource(), |
| // messages); |
| // tasks.run(); |
| } |
| |
| public void resetInformationTasks() { |
| // DisplayErrorInTaskList.removeInfoMarkers(getFileResource()); |
| } |
| |
| public XSDGraphViewer getGraphViewer() { |
| return graphViewer; |
| } |
| |
| public IEditorPart getActiveEditorPage() { |
| return getActiveEditor(); |
| } |
| |
| public StructuredTextEditor getTextEditor() { |
| return textEditor; |
| } |
| |
| class InternalPartListener implements IPartListener { |
| XSDEditor editor; |
| |
| public InternalPartListener(XSDEditor editor) { |
| this.editor = editor; |
| } |
| |
| public void partActivated(IWorkbenchPart part) { |
| if (part == editor) { |
| ISelection selection = getSelectionManager().getSelection(); |
| if (selection != null) { |
| if (getCurrentPageType().equals(XSDEditorPlugin.GRAPH_PAGE)) { |
| getSelectionManager().selectionChanged(new SelectionChangedEvent(editor.getGraphViewer().getComponentViewer(), selection)); |
| } |
| else if (getCurrentPageType().equals(XSDEditorPlugin.SOURCE_PAGE)) { |
| getSelectionManager().setSelection(selection); |
| } |
| } |
| } |
| } |
| |
| public void partBroughtToTop(IWorkbenchPart part) { |
| } |
| |
| public void partClosed(IWorkbenchPart part) { |
| } |
| |
| public void partDeactivated(IWorkbenchPart part) { |
| } |
| |
| public void partOpened(IWorkbenchPart part) { |
| } |
| } |
| |
| |
| /** |
| * Method createDefaultSchemaNode. Should only be called to insert a |
| * schema node into an empty document |
| */ |
| public void createDefaultSchemaNode(Document document) { |
| if (document.getChildNodes().getLength() == 0) { |
| // if it is a completely empty file, then add the encoding and |
| // version processing instruction |
| // TODO String encoding = EncodingHelper.getDefaultEncodingTag(); |
| String encoding = "UTF-8"; |
| ProcessingInstruction instr = document.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"" + encoding + "\""); |
| document.appendChild(instr); |
| } |
| |
| // Create a default schema tag now |
| |
| // String defaultPrefixForTargetNamespace = |
| // getFileResource().getProjectRelativePath().removeFileExtension().lastSegment(); |
| String defaultPrefixForTargetNamespace = "tns"; |
| String prefixForSchemaNamespace = ""; |
| String schemaNamespaceAttribute = "xmlns"; |
| if (XSDEditorPlugin.getPlugin().isQualifyXMLSchemaLanguage()) { |
| // Added this if check before disallowing blank prefixes in the |
| // preferences... |
| // Can take this out. See also NewXSDWizard |
| if (XSDEditorPlugin.getPlugin().getXMLSchemaPrefix().trim().length() > 0) { |
| prefixForSchemaNamespace = XSDEditorPlugin.getPlugin().getXMLSchemaPrefix() + ":"; |
| schemaNamespaceAttribute += ":" + XSDEditorPlugin.getPlugin().getXMLSchemaPrefix(); |
| } |
| } |
| |
| document.appendChild(document.createTextNode("\n")); |
| Element element = document.createElement(prefixForSchemaNamespace + XSDConstants.SCHEMA_ELEMENT_TAG); |
| |
| element.setAttribute(schemaNamespaceAttribute, "http://www.w3.org/2001/XMLSchema"); |
| |
| String defaultTargetURI = XSDEditorPlugin.getPlugin().getXMLSchemaTargetNamespace(); |
| element.setAttribute(XSDConstants.TARGETNAMESPACE_ATTRIBUTE, defaultTargetURI); |
| element.setAttribute("xmlns:" + defaultPrefixForTargetNamespace, defaultTargetURI); |
| |
| document.appendChild(element); |
| } |
| } |
