| /** |
| * <copyright> |
| * |
| * Copyright (c) 2010 Eclipse Modeling Project 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: |
| * E.D.Willink - Initial API and implementation |
| * |
| * </copyright> |
| * |
| * $Id: OCLInEcoreEditor.java,v 1.4 2010/03/22 01:23:05 ewillink Exp $ |
| */ |
| package org.eclipse.ocl.examples.editor.ocl.ui.ecore; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.emf.common.command.BasicCommandStack; |
| import org.eclipse.emf.common.ui.editor.ProblemEditorPart; |
| import org.eclipse.emf.common.ui.viewer.IViewerProvider; |
| import org.eclipse.emf.common.util.BasicDiagnostic; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EAnnotation; |
| import org.eclipse.emf.ecore.EGenericType; |
| import org.eclipse.emf.ecore.EModelElement; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.ETypeParameter; |
| import org.eclipse.emf.ecore.EValidator; |
| import org.eclipse.emf.ecore.plugin.EcorePlugin; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain; |
| import org.eclipse.emf.edit.domain.IEditingDomainProvider; |
| import org.eclipse.emf.edit.provider.AdapterFactoryItemDelegator; |
| import org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter; |
| import org.eclipse.emf.edit.ui.dnd.LocalTransfer; |
| import org.eclipse.emf.edit.ui.dnd.ViewerDragAdapter; |
| import org.eclipse.emf.edit.ui.provider.UnwrappingSelectionProvider; |
| import org.eclipse.emf.edit.ui.util.EditUIUtil; |
| import org.eclipse.imp.editor.ModelTreeNode; |
| import org.eclipse.imp.parser.IParseController; |
| import org.eclipse.jface.action.IMenuListener; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.IStatusLineManager; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| 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.jface.viewers.StructuredViewer; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.ocl.cst.CSTNode; |
| import org.eclipse.ocl.cst.CollectionLiteralPartCS; |
| import org.eclipse.ocl.cst.OCLExpressionCS; |
| import org.eclipse.ocl.cst.SimpleNameCS; |
| import org.eclipse.ocl.cst.VariableCS; |
| import org.eclipse.ocl.ecore.Constraint; |
| import org.eclipse.ocl.ecore.delegate.OCLDelegateDomain; |
| import org.eclipse.ocl.examples.common.utils.EcoreUtils; |
| import org.eclipse.ocl.examples.editor.ui.common.ProblemIndicationManager; |
| import org.eclipse.ocl.examples.editor.ui.common.ResourceChangeManager; |
| import org.eclipse.ocl.examples.editor.ui.imp.CommonParseController; |
| import org.eclipse.ocl.examples.editor.ui.imp.CommonTextEditor; |
| import org.eclipse.ocl.examples.editor.ui.imp.ICommonParseResult; |
| import org.eclipse.swt.dnd.DND; |
| import org.eclipse.swt.dnd.Transfer; |
| import org.eclipse.swt.events.MouseAdapter; |
| import org.eclipse.swt.events.MouseEvent; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.IActionBars; |
| 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.IWorkbenchPart; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.dialogs.SaveAsDialog; |
| import org.eclipse.ui.ide.IGotoMarker; |
| import org.eclipse.ui.part.FileEditorInput; |
| |
| /** |
| * The OCL in Ecore model editor. |
| */ |
| public class OCLInEcoreEditor extends CommonTextEditor |
| implements IOCLInEcoreEditor, IEditingDomainProvider, |
| IMenuListener, IViewerProvider, IGotoMarker { |
| |
| public static final String ECORE_FILE_EXTENSION = "ecore"; |
| public static final String EMOF_FILE_EXTENSION = "emof"; |
| |
| /** |
| * This looks up a string in the plugin's plugin.properties file. |
| */ |
| private static String getString(String key) { |
| return OCLInEcorePlugin.INSTANCE.getString(key); |
| } |
| |
| /** |
| * This looks up a string in plugin.properties, making a substitution. |
| */ |
| private static String getString(String key, Object s1) { |
| return OCLInEcorePlugin.INSTANCE.getString(key, new Object[] { s1 }); |
| } |
| |
| protected ISelectionProvider selectionProvider = new ISelectionProvider() { |
| |
| /** |
| * This implements {@link org.eclipse.jface.viewers.ISelectionProvider}. |
| */ |
| public void addSelectionChangedListener( |
| ISelectionChangedListener listener) { |
| selectionChangedListeners.add(listener); |
| } |
| |
| public ISelection getSelection() { |
| return editorSelection; |
| } |
| |
| public void removeSelectionChangedListener( |
| ISelectionChangedListener listener) { |
| selectionChangedListeners.remove(listener); |
| } |
| |
| public void setSelection(ISelection selection) { |
| editorSelection = selection; |
| |
| for (ISelectionChangedListener listener : selectionChangedListeners) { |
| listener.selectionChanged(new SelectionChangedEvent(this, |
| selection)); |
| } |
| setStatusLineManager(selection); |
| } |
| }; |
| |
| /** |
| * This is the viewer that shadows the selection in the content outline. The |
| * parent relation must be correctly defined for this to work. |
| */ |
| protected TreeViewer selectionViewer; |
| |
| /** |
| * This keeps track of the active content viewer, which may be either one of |
| * the viewers in the pages or the content outline viewer. |
| */ |
| protected Viewer currentViewer; |
| |
| /** |
| * This listens to which ever viewer is active. |
| * |
| * @generated |
| */ |
| protected ISelectionChangedListener selectionChangedListener; |
| |
| /** |
| * This keeps track of all the |
| * {@link org.eclipse.jface.viewers.ISelectionChangedListener}s that are |
| * listening to this editor. |
| */ |
| protected Collection<ISelectionChangedListener> selectionChangedListeners = new ArrayList<ISelectionChangedListener>(); |
| |
| /** |
| * This keeps track of the selection of the editor as a whole. |
| */ |
| protected ISelection editorSelection = StructuredSelection.EMPTY; |
| |
| /** |
| * This listens for when the outline becomes active |
| */ |
| protected IPartListener partListener = new IPartListener() { |
| public void partActivated(IWorkbenchPart p) { |
| /* if (p instanceof ContentOutline) { |
| if (((ContentOutline) p).getCurrentPage() == contentOutlinePage) { |
| getActionBarContributor().setActiveEditor(OCLInEcoreEditor.this); |
| setCurrentViewer(contentOutlinePage.getContentOutlineViewer()); |
| } |
| } else if (p instanceof PropertySheet) { |
| if (((PropertySheet) p).getCurrentPage() == propertySheetPage) { |
| getActionBarContributor().setActiveEditor(OCLInEcoreEditor.this); |
| resourceChangeManager.handleActivate(); |
| } |
| } else */ if (p == OCLInEcoreEditor.this) { |
| resourceChangeManager.handleActivate(); |
| } |
| } |
| |
| public void partBroughtToTop(IWorkbenchPart p) { |
| // Ignore. |
| } |
| |
| public void partClosed(IWorkbenchPart p) { |
| // Ignore. |
| } |
| |
| public void partDeactivated(IWorkbenchPart p) { |
| // Ignore. |
| } |
| |
| public void partOpened(IWorkbenchPart p) { |
| // Ignore. |
| } |
| }; |
| |
| protected final ProblemIndicationManager problemIndicationManager = new ProblemIndicationManager() |
| { |
| @Override |
| protected void asyncExec(Runnable runnable) { |
| getDisplay().asyncExec(runnable); |
| } |
| |
| @Override |
| protected void createProblemEditor(BasicDiagnostic diagnostic) { |
| /* ProblemEditorPart problemEditorPart = new ProblemEditorPart(); |
| problemEditorPart.setDiagnostic(diagnostic); |
| problemEditorPart.setMarkerHelper(markerHelper); |
| try |
| { |
| int lastEditorPage = getPageCount() - 1; |
| addPage(++lastEditorPage, problemEditorPart, getEditorInput()); |
| setPageText(lastEditorPage, problemEditorPart.getPartName()); |
| setActivePage(lastEditorPage); |
| // showTabs(); |
| } |
| catch (PartInitException exception) |
| { |
| OCLExamplesEditorPlugin.INSTANCE.log(exception); |
| } */ |
| } |
| |
| @Override |
| protected ProblemEditorPart getProblemEditor() { |
| // int lastEditorPage = getPageCount() - 1; |
| // if (lastEditorPage < 0) { |
| return null; |
| // } |
| // IEditorPart lastEditor = getEditor(lastEditorPage); |
| // if (!(lastEditor instanceof ProblemEditorPart)) { |
| // return null; |
| // } |
| // return (ProblemEditorPart)lastEditor; |
| } |
| |
| @Override |
| public ResourceSet getResourceSet() { |
| return OCLInEcoreEditor.this.getResourceSet(); |
| } |
| |
| @Override |
| protected void setActiveEditor(IEditorPart editor) { |
| // OCLInEcoreEditor.this.setActiveEditor(editor); |
| } |
| }; |
| |
| /** |
| * This listens for workspace changes. |
| */ |
| |
| protected final ResourceChangeManager resourceChangeManager = new ResourceChangeManager() |
| { |
| @Override |
| protected void asyncExec(Runnable runnable) { |
| getDisplay().asyncExec(runnable); |
| } |
| |
| @Override |
| protected void closeEditor(boolean save) { |
| getSite().getPage().closeEditor(OCLInEcoreEditor.this, save); |
| } |
| |
| @Override |
| protected void flushCommandStack() { |
| getEditingDomain().getCommandStack().flush(); // FIXME operation history |
| } |
| |
| @Override |
| public AdapterFactoryEditingDomain getEditingDomain() { |
| return OCLInEcoreEditor.this.getEditingDomain(); |
| } |
| |
| @Override |
| public ResourceSet getResourceSet() { |
| return OCLInEcoreEditor.this.getResourceSet(); |
| } |
| |
| @Override |
| protected Shell getShell() { |
| return OCLInEcoreEditor.this.getSite().getShell(); |
| } |
| |
| /** |
| * Shows a dialog that asks if conflicting changes should be discarded. |
| */ |
| @Override |
| public boolean handleDirtyConflict() |
| { |
| return MessageDialog.openQuestion (getShell(), |
| getString("_UI_FileConflict_label"), |
| getString("_WARN_FileConflict")); |
| } |
| |
| @Override |
| protected void handleResourceException(Resource resource, Exception exception, boolean forceUpdate) { |
| problemIndicationManager.handleResourceException(resource, exception, forceUpdate); |
| } |
| |
| @Override |
| public boolean isActiveEditor() { |
| return getSite().getPage().getActiveEditor() == OCLInEcoreEditor.this; |
| } |
| |
| @Override |
| public boolean isDirty() { |
| return OCLInEcoreEditor.this.isDirty(); |
| } |
| |
| @Override |
| protected void refreshAfterSave() { |
| ((BasicCommandStack) getEditingDomain().getCommandStack()).saveIsDone(); // FIXME operation history |
| firePropertyChange(IEditorPart.PROP_DIRTY); |
| } |
| |
| @Override |
| protected void refreshSelection(boolean forceRefresh) { |
| ISelection selection = selectionProvider.getSelection(); |
| if (forceRefresh) { |
| selectionProvider.setSelection(selection); |
| } |
| else if (AdapterFactoryEditingDomain.isStale(selection)) { |
| selectionProvider.setSelection(StructuredSelection.EMPTY); |
| } |
| } |
| |
| @Override |
| protected void resumeProblemIndicationUpdate() { |
| problemIndicationManager.resumeProblemIndicationUpdate(); |
| } |
| |
| @Override |
| protected void resumeResourceListening() { |
| // OCLInEcoreEditor.this.resumeResourceListening(); |
| } |
| |
| @Override |
| protected void suspendResourceListening() { |
| // OCLInEcoreEditor.this.suspendResourceListening(); |
| } |
| |
| @Override |
| public void setPartName(String partName) { |
| OCLInEcoreEditor.this.setPartName(partName); |
| } |
| |
| @Override |
| protected void suspendProblemIndicationUpdate() { |
| problemIndicationManager.suspendProblemIndicationUpdate(); |
| } |
| }; |
| |
| /** |
| * This creates a model editor. |
| */ |
| public OCLInEcoreEditor() { |
| super(); |
| setDocumentProvider(new OCLInEcoreDocumentProvider(this)); |
| initializeEditingDomain(); |
| } |
| |
| /* @Override |
| protected IContentOutlinePage createASTOutlinePage() { |
| IContentOutlinePage contentOutlinePage = new OCLInEcoreContentOutlinePage(this); |
| |
| // Listen to selection so that we can handle it is a special way. |
| // |
| contentOutlinePage |
| .addSelectionChangedListener(new ISelectionChangedListener() { |
| // This ensures that we handle selections correctly. |
| // |
| public void selectionChanged(SelectionChangedEvent event) { |
| handleContentOutlineSelection(event.getSelection()); |
| } |
| }); |
| return contentOutlinePage; |
| } */ |
| |
| @Override |
| protected void createActions() { |
| super.createActions(); |
| // |
| // This is the most pragmatic intercept between creation of the language |
| // service support and scheduling the first parse (all within |
| // createPartControl. |
| // |
| IParseController parseController = getParseController(); |
| if (parseController instanceof CommonParseController) { |
| ((CommonParseController) parseController) |
| .setResourceSet(getResourceSet()); |
| } |
| } |
| |
| /** |
| * This creates a context menu for the viewer and adds a listener as well |
| * registering the menu for extension. |
| */ |
| protected void createContextMenuForGen(StructuredViewer viewer) { |
| MenuManager contextMenu = new MenuManager("#PopUp"); |
| contextMenu.add(new Separator("additions")); |
| contextMenu.setRemoveAllWhenShown(true); |
| contextMenu.addMenuListener(this); |
| Menu menu = contextMenu.createContextMenu(viewer.getControl()); |
| viewer.getControl().setMenu(menu); |
| getSite().registerContextMenu(contextMenu, |
| new UnwrappingSelectionProvider(viewer)); |
| |
| int dndOperations = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK; |
| Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance() }; |
| viewer.addDragSupport(dndOperations, transfers, new ViewerDragAdapter( |
| viewer)); |
| viewer.addDropSupport(dndOperations, transfers, |
| new EditingDomainViewerDropAdapter(editingDomain, viewer)); |
| } |
| |
| public void createContextMenuFor(StructuredViewer viewer) { |
| createContextMenuForGen(viewer); |
| |
| viewer.getControl().addMouseListener(new MouseAdapter() { |
| @Override |
| public void mouseDoubleClick(MouseEvent event) { |
| if (event.button == 1) { |
| try { |
| getEditorSite().getPage().showView( |
| "org.eclipse.ui.views.PropertySheet"); |
| } catch (PartInitException exception) { |
| OCLInEcorePlugin.INSTANCE.log(exception); |
| } |
| } |
| } |
| }); |
| } |
| |
| /** |
| * This is the method called to load a resource into the editing domain's |
| * resource set based on the editor's input. |
| */ |
| public void createModelGen() { |
| URI resourceURI = EditUIUtil.getURI(getEditorInput()); |
| Exception exception = null; |
| Resource resource = null; |
| try { |
| // Load the resource through the editing domain. |
| // |
| resource = editingDomain.getResourceSet().getResource(resourceURI, |
| true); |
| } catch (Exception e) { |
| exception = e; |
| resource = editingDomain.getResourceSet().getResource(resourceURI, |
| false); |
| } |
| |
| problemIndicationManager.initializeProblemIndication(resource, exception); |
| } |
| |
| public void createModel() { |
| editingDomain.getResourceSet().getURIConverter().getURIMap().putAll( |
| EcorePlugin.computePlatformURIMap()); |
| |
| createModelGen(); |
| |
| if (!editingDomain.getResourceSet().getResources().isEmpty()) { |
| for (Iterator<EObject> i = editingDomain.getResourceSet() |
| .getResources().get(0).getAllContents(); i.hasNext();) { |
| EObject eObject = i.next(); |
| if (eObject instanceof ETypeParameter |
| || eObject instanceof EGenericType |
| && !((EGenericType) eObject).getETypeArguments() |
| .isEmpty()) { |
| // FIXME |
| // ((EcoreActionBarContributor)getActionBarContributor()).showGenerics(true); |
| break; |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void dispose() { |
| problemIndicationManager.suspendProblemIndicationUpdate(); |
| resourceChangeManager.dispose(); |
| |
| getSite().getPage().removePartListener(partListener); |
| |
| // adapterFactory.dispose(); |
| |
| if (getActionBarContributor().getActiveEditor() == this) { |
| getActionBarContributor().setActiveEditor(null); |
| } |
| |
| // if (propertySheetPage != null) { |
| // propertySheetPage.dispose(); |
| // } |
| |
| // if (contentOutlinePage != null) { |
| // contentOutlinePage.dispose(); |
| // } |
| |
| super.dispose(); |
| } |
| |
| /** |
| * This is for implementing {@link IEditorPart} and simply saves the model |
| * file. |
| */ |
| @Override |
| public void doSave(IProgressMonitor progressMonitor) { |
| resourceChangeManager.doSave(progressMonitor); |
| } |
| |
| /** |
| * This is used to track the active viewer. <!-- begin-user-doc --> <!-- |
| * end-user-doc --> |
| * |
| * @generated |
| * |
| @Override protected void pageChange(int pageIndex) { |
| * super.pageChange(pageIndex); |
| * |
| * if (contentOutlinePage != null) { |
| * handleContentOutlineSelection( |
| * contentOutlinePage.getSelection()); } } |
| */ |
| |
| /** |
| * This is here for the listener to be able to call it. |
| */ |
| @Override |
| protected void firePropertyChange(int action) { |
| super.firePropertyChange(action); |
| } |
| |
| /** |
| * This is how the framework determines which interfaces we implement. |
| */ |
| @SuppressWarnings("rawtypes") |
| @Override |
| public Object getAdapter(Class key) { |
| /* if (key.equals(IContentOutlinePage.class)) { |
| return getContentOutlinePage(); |
| } else if (key.equals(IPropertySheetPage.class)) { |
| return getPropertySheetPage(); |
| } else */ if (key.equals(IGotoMarker.class)) { |
| return this; |
| } else { |
| return super.getAdapter(key); |
| } |
| } |
| |
| @Override |
| public List<CSTNode> getCSTNodes(ISelection selection, ICommonParseResult parseResult) { |
| List<CSTNode> cstNodes = super.getCSTNodes(selection, parseResult); |
| removeReferences(cstNodes); |
| if (cstNodes.isEmpty()) { |
| for (Iterator<?> i = ((IStructuredSelection)selection).iterator(); i.hasNext(); ) { |
| Object object = i.next(); |
| if (object instanceof ModelTreeNode) |
| object = ((ModelTreeNode)object).getASTNode(); |
| if (object instanceof EModelElement) { |
| EAnnotation eAnnotation = ((EModelElement) object).getEAnnotation(OCLDelegateDomain.OCL_DELEGATE_URI); |
| if (eAnnotation != null) { |
| for (Map.Entry<String, String> entry : eAnnotation.getDetails().entrySet()) { |
| CSTNode node = parseResult.getCSTNode(entry); |
| if (node != null) |
| cstNodes.add(node); |
| } |
| } |
| |
| } |
| } |
| } |
| return cstNodes; |
| } |
| |
| /** |
| * This accesses a cached version of the content outliner. |
| * |
| public IContentOutlinePage getContentOutlinePage() { |
| if (contentOutlinePage == null) { |
| |
| contentOutlinePage = new OCLInEcoreContentOutlinePage(this); |
| |
| // Listen to selection so that we can handle it is a special way. |
| // |
| contentOutlinePage |
| .addSelectionChangedListener(new ISelectionChangedListener() { |
| // This ensures that we handle selections correctly. |
| // |
| public void selectionChanged(SelectionChangedEvent event) { |
| handleContentOutlineSelection(event.getSelection()); |
| } |
| }); |
| } |
| |
| return contentOutlinePage; |
| } */ |
| |
| /* |
| * Overridden to provoke a walk up the Outline AST until an AST node with a |
| * structural AST mapping is found. (The more refined OCL expression tertms have |
| * no corresponding counrerpart in the Ecore AST where OCL is textual.) |
| */ |
| @Override |
| protected Object getCorrespondingASTNodeIn(CSTNode cstNode, Resource ast) { |
| Object node = cstNode.getAst(); |
| if (node == null) { |
| return null; |
| } |
| if (!(node instanceof EObject)) { |
| return null; |
| } |
| if (cstNode instanceof OCLExpressionCS) { |
| return null; |
| } |
| if (cstNode instanceof CollectionLiteralPartCS) { |
| return null; |
| } |
| if (cstNode instanceof VariableCS) { // TupleLiteralPartCS |
| return null; |
| } |
| if (node instanceof Constraint) { |
| Constraint constraint = (Constraint)node; |
| Map.Entry<String, String> entry = EcoreUtils.getEAnnotationDetail(constraint); |
| if (entry != null) { |
| node = entry; |
| } |
| else { |
| List<EModelElement> constrainedElements = constraint.getConstrainedElements(); |
| if (!constrainedElements.isEmpty()) { |
| node = constrainedElements.get(0); |
| } |
| } |
| } |
| return node; |
| } |
| |
| /** |
| * This accesses a cached version of the property sheet. |
| * |
| public IPropertySheetPage getPropertySheetPage() { |
| if (propertySheetPage == null) { |
| propertySheetPage = new ExtendedPropertySheetPage(editingDomain) { |
| @Override |
| public void setSelectionToViewer(List<?> selection) { |
| OCLInEcoreEditor.this.setSelectionToViewer(selection); |
| OCLInEcoreEditor.this.setFocus(); |
| } |
| |
| @Override |
| public void setActionBars(IActionBars actionBars) { |
| super.setActionBars(actionBars); |
| getActionBarContributor().shareGlobalActions(this, |
| actionBars); |
| } |
| }; |
| propertySheetPage |
| .setPropertySourceProvider(new AdapterFactoryContentProvider( |
| adapterFactory)); |
| } |
| |
| return propertySheetPage; |
| } */ |
| |
| /** |
| * This deals with how we want selection in the outliner to affect the other |
| * views. |
| */ |
| public void handleContentOutlineSelection(ISelection selection) { |
| if (selectionViewer != null && !selection.isEmpty() |
| && selection instanceof IStructuredSelection) { |
| Iterator<?> selectedElements = ((IStructuredSelection) selection) |
| .iterator(); |
| if (selectedElements.hasNext()) { |
| // Get the first selected element. |
| // |
| Object selectedElement = selectedElements.next(); |
| |
| ArrayList<Object> selectionList = new ArrayList<Object>(); |
| selectionList.add(selectedElement); |
| while (selectedElements.hasNext()) { |
| selectionList.add(selectedElements.next()); |
| } |
| |
| // Set the selection to the widget. |
| // |
| selectionViewer.setSelection(new StructuredSelection( |
| selectionList)); |
| } |
| } |
| } |
| |
| /** |
| * This is for implementing {@link IEditorPart} and simply tests the command |
| * stack. |
| */ |
| @Override |
| public boolean isDirty() { |
| return ((BasicCommandStack) editingDomain.getCommandStack()) |
| .isSaveNeeded(); |
| } |
| |
| /** |
| * This returns whether something has been persisted to the URI of the |
| * specified resource. The implementation uses the URI converter from the |
| * editor's resource set to try to open an input stream. |
| */ |
| protected boolean isPersisted(Resource resource) { |
| boolean result = false; |
| try { |
| InputStream stream = editingDomain.getResourceSet() |
| .getURIConverter().createInputStream(resource.getURI()); |
| if (stream != null) { |
| result = true; |
| stream.close(); |
| } |
| } catch (IOException e) { |
| // Ignore |
| } |
| return result; |
| } |
| |
| /** |
| * This always returns true because it is not currently supported. |
| */ |
| @Override |
| public boolean isSaveAsAllowed() { |
| return true; |
| } |
| |
| /** |
| * This also changes the editor's input. |
| */ |
| @Override |
| public void doSaveAs() { |
| SaveAsDialog saveAsDialog = new SaveAsDialog(getSite().getShell()); |
| saveAsDialog.create(); |
| saveAsDialog.setMessage(OCLInEcorePlugin.INSTANCE |
| .getString("_UI_SaveAs_message")); |
| saveAsDialog.open(); |
| IPath path = saveAsDialog.getResult(); |
| if (path != null) { |
| IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(path); |
| if (file != null) { |
| ResourceSet resourceSet = editingDomain.getResourceSet(); |
| Resource currentResource = resourceSet.getResources().get(0); |
| String currentExtension = currentResource.getURI() |
| .fileExtension(); |
| |
| URI newURI = URI.createPlatformResourceURI(file.getFullPath() |
| .toString(), true); |
| String newExtension = newURI.fileExtension(); |
| |
| if (currentExtension.equals(ECORE_FILE_EXTENSION) |
| && newExtension.equals(EMOF_FILE_EXTENSION) |
| || currentExtension.equals(EMOF_FILE_EXTENSION) |
| && newExtension.equals(ECORE_FILE_EXTENSION)) { |
| Resource newResource = resourceSet.createResource(newURI); |
| newResource.getContents().addAll( |
| currentResource.getContents()); |
| resourceSet.getResources().remove(0); |
| resourceSet.getResources().move(0, newResource); |
| } else { |
| currentResource.setURI(newURI); |
| } |
| |
| IFileEditorInput modelFile = new FileEditorInput(file); |
| setInputWithNotify(modelFile); |
| setPartName(file.getName()); |
| doSave(getActionBars().getStatusLineManager() |
| .getProgressMonitor()); |
| } |
| } |
| } |
| |
| protected void doSaveAs(URI uri, IEditorInput editorInput) { |
| (editingDomain.getResourceSet().getResources().get(0)).setURI(uri); |
| setInputWithNotify(editorInput); |
| setPartName(editorInput.getName()); |
| IProgressMonitor progressMonitor = getActionBars() |
| .getStatusLineManager() != null ? getActionBars() |
| .getStatusLineManager().getProgressMonitor() |
| : new NullProgressMonitor(); |
| doSave(progressMonitor); |
| } |
| |
| public IActionBars getActionBars() { |
| return getActionBarContributor().getActionBars(); |
| } |
| |
| @Override |
| public OCLInEcoreParseController getParseController() { |
| return (OCLInEcoreParseController) super.getParseController(); |
| } |
| |
| public ResourceSet getResourceSet() { |
| return getEditingDomain().getResourceSet(); |
| } |
| |
| /** |
| * This returns the viewer as required by the {@link IViewerProvider} |
| * interface. |
| */ |
| public Viewer getViewer() { |
| return currentViewer; |
| } |
| |
| @Override |
| public void gotoMarker(IMarker marker) { |
| try { |
| if (marker.getType().equals(EValidator.MARKER)) { |
| String uriAttribute = marker.getAttribute( |
| EValidator.URI_ATTRIBUTE, null); |
| if (uriAttribute != null) { |
| URI uri = URI.createURI(uriAttribute); |
| EObject eObject = editingDomain.getResourceSet() |
| .getEObject(uri, true); |
| if (eObject != null) { |
| setSelectionToViewer(Collections |
| .singleton(editingDomain.getWrapper(eObject))); |
| } |
| } |
| } |
| } catch (CoreException exception) { |
| OCLInEcorePlugin.INSTANCE.log(exception); |
| } |
| } |
| |
| /** |
| * Shows a dialog that asks if conflicting changes should be discarded. |
| */ |
| protected boolean handleDirtyConflict() { |
| return MessageDialog.openQuestion(getSite().getShell(), |
| getString("_UI_FileConflict_label"), |
| getString("_WARN_FileConflict")); |
| } |
| |
| /** |
| * This is called during startup. |
| */ |
| @Override |
| public void init(IEditorSite site, IEditorInput editorInput) { |
| setSite(site); |
| setInputWithNotify(editorInput); |
| setPartName(editorInput.getName()); |
| site.setSelectionProvider(selectionProvider); |
| site.getPage().addPartListener(partListener); |
| resourceChangeManager.init(); |
| } |
| |
| /** |
| * This implements {@link org.eclipse.jface.action.IMenuListener} to help |
| * fill the context menus with contributions from the Edit menu. |
| */ |
| public void menuAboutToShow(IMenuManager menuManager) { |
| ((IMenuListener) getEditorSite().getActionBarContributor()) |
| .menuAboutToShow(menuManager); |
| } |
| |
| protected void removeReferences(List<CSTNode> cstNodes) { |
| for (int i = cstNodes.size(); --i >= 0; ) { |
| CSTNode cstNode = cstNodes.get(i); |
| if (cstNode instanceof SimpleNameCS) { |
| cstNodes.remove(i); |
| } |
| } |
| } |
| |
| /** |
| * This makes sure that one content viewer, either for the current page or |
| * the outline view, if it has focus, is the current one. |
| */ |
| public void setCurrentViewer(Viewer viewer) { |
| // If it is changing... |
| // |
| if (currentViewer != viewer) { |
| if (selectionChangedListener == null) { |
| // Create the listener on demand. |
| // |
| selectionChangedListener = new ISelectionChangedListener() { |
| // This just notifies those things that are affected by the |
| // section. |
| // |
| public void selectionChanged(SelectionChangedEvent selectionChangedEvent) { |
| selectionProvider.setSelection(selectionChangedEvent.getSelection()); |
| } |
| }; |
| } |
| |
| // Stop listening to the old one. |
| // |
| if (currentViewer != null) { |
| currentViewer |
| .removeSelectionChangedListener(selectionChangedListener); |
| } |
| |
| // Start listening to the new one. |
| // |
| if (viewer != null) { |
| viewer.addSelectionChangedListener(selectionChangedListener); |
| } |
| |
| // Remember it. |
| // |
| currentViewer = viewer; |
| |
| // Set the editors selection based on the current viewer's |
| // selection. |
| // |
| selectionProvider |
| .setSelection(currentViewer == null ? StructuredSelection.EMPTY |
| : currentViewer.getSelection()); |
| } |
| } |
| |
| /** |
| * This sets the selection into whichever viewer is active. |
| */ |
| public void setSelectionToViewer(Collection<?> collection) { |
| final Collection<?> theSelection = collection; |
| // Make sure it's okay. |
| // |
| if (theSelection != null && !theSelection.isEmpty()) { |
| Runnable runnable = new Runnable() { |
| public void run() { |
| // Try to select the items in the current content viewer of |
| // the editor. |
| // |
| if (currentViewer != null) { |
| currentViewer.setSelection(new StructuredSelection( |
| theSelection.toArray()), true); |
| } |
| } |
| }; |
| getSite().getShell().getDisplay().asyncExec(runnable); |
| } |
| } |
| |
| public void setStatusLineManager(ISelection selection) { |
| IStatusLineManager statusLineManager = /*currentViewer != null |
| && currentViewer == contentOutlinePage.getContentOutlineViewer() |
| ? contentOutlinePage.getContentOutlineStatusLineManager() |
| :*/ getActionBars().getStatusLineManager(); |
| |
| if (statusLineManager != null) { |
| if (selection instanceof IStructuredSelection) { |
| Collection<?> collection = ((IStructuredSelection) selection) |
| .toList(); |
| switch (collection.size()) { |
| case 0: { |
| statusLineManager |
| .setMessage(getString("_UI_NoObjectSelected")); |
| break; |
| } |
| case 1: { |
| String text = new AdapterFactoryItemDelegator( |
| getAdapterFactory()).getText(collection.iterator() |
| .next()); |
| statusLineManager.setMessage(getString( |
| "_UI_SingleObjectSelected", text)); |
| break; |
| } |
| default: { |
| statusLineManager.setMessage(getString( |
| "_UI_MultiObjectSelected", Integer |
| .toString(collection.size()))); |
| break; |
| } |
| } |
| } else { |
| statusLineManager.setMessage(""); |
| } |
| } |
| } |
| } |
