DatatypesEditor.java

Go to the documentation of this file.

package org.best_of_robotics.model.datatypes.presentation;


import java.io.IOException;
import java.io.InputStream;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.EventObject;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
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.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
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.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;

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.swt.SWT;

import org.eclipse.swt.custom.CTabFolder;

import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Tree;

import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorSite;
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;
import org.eclipse.ui.part.MultiPageEditorPart;

import org.eclipse.ui.views.contentoutline.ContentOutline;
import org.eclipse.ui.views.contentoutline.ContentOutlinePage;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;

import org.eclipse.ui.views.properties.IPropertySheetPage;
import org.eclipse.ui.views.properties.PropertySheet;
import org.eclipse.ui.views.properties.PropertySheetPage;

import org.eclipse.emf.common.command.BasicCommandStack;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CommandStack;
import org.eclipse.emf.common.command.CommandStackListener;

import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.notify.Notification;

import org.eclipse.emf.common.ui.MarkerHelper;

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.Diagnostic;
import org.eclipse.emf.common.util.URI;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EValidator;

import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;

import org.eclipse.emf.ecore.util.EContentAdapter;
import org.eclipse.emf.ecore.util.EcoreUtil;

import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.domain.IEditingDomainProvider;

import org.eclipse.emf.edit.provider.AdapterFactoryItemDelegator;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory;

import org.eclipse.emf.edit.provider.resource.ResourceItemProviderAdapterFactory;

import org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor;

import org.eclipse.emf.edit.ui.celleditor.AdapterFactoryTreeEditor;

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.AdapterFactoryContentProvider;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
import org.eclipse.emf.edit.ui.provider.UnwrappingSelectionProvider;

import org.eclipse.emf.edit.ui.util.EditUIMarkerHelper;
import org.eclipse.emf.edit.ui.util.EditUIUtil;

import org.eclipse.emf.edit.ui.view.ExtendedPropertySheetPage;

import org.best_of_robotics.model.datatypes.provider.DatatypesItemProviderAdapterFactory;

import org.eclipse.ui.actions.WorkspaceModifyOperation;


public class DatatypesEditor
        extends MultiPageEditorPart
        implements IEditingDomainProvider, ISelectionProvider, IMenuListener, IViewerProvider, IGotoMarker {
        protected AdapterFactoryEditingDomain editingDomain;

        protected ComposedAdapterFactory adapterFactory;

        protected IContentOutlinePage contentOutlinePage;

        protected IStatusLineManager contentOutlineStatusLineManager;

        protected TreeViewer contentOutlineViewer;

        protected PropertySheetPage propertySheetPage;

        protected TreeViewer selectionViewer;

        protected Viewer currentViewer;

        protected ISelectionChangedListener selectionChangedListener;

        protected Collection<ISelectionChangedListener> selectionChangedListeners = new ArrayList<ISelectionChangedListener>();

        protected ISelection editorSelection = StructuredSelection.EMPTY;

        protected MarkerHelper markerHelper = new EditUIMarkerHelper();

        protected IPartListener partListener =
                new IPartListener() {
                        public void partActivated(IWorkbenchPart p) {
                                if (p instanceof ContentOutline) {
                                        if (((ContentOutline)p).getCurrentPage() == contentOutlinePage) {
                                                getActionBarContributor().setActiveEditor(DatatypesEditor.this);

                                                setCurrentViewer(contentOutlineViewer);
                                        }
                                }
                                else if (p instanceof PropertySheet) {
                                        if (((PropertySheet)p).getCurrentPage() == propertySheetPage) {
                                                getActionBarContributor().setActiveEditor(DatatypesEditor.this);
                                                handleActivate();
                                        }
                                }
                                else if (p == DatatypesEditor.this) {
                                        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 Collection<Resource> removedResources = new ArrayList<Resource>();

        protected Collection<Resource> changedResources = new ArrayList<Resource>();

        protected Collection<Resource> savedResources = new ArrayList<Resource>();

        protected Map<Resource, Diagnostic> resourceToDiagnosticMap = new LinkedHashMap<Resource, Diagnostic>();

        protected boolean updateProblemIndication = true;

        protected EContentAdapter problemIndicationAdapter = 
                new EContentAdapter() {
                        @Override
                        public void notifyChanged(Notification notification) {
                                if (notification.getNotifier() instanceof Resource) {
                                        switch (notification.getFeatureID(Resource.class)) {
                                                case Resource.RESOURCE__IS_LOADED:
                                                case Resource.RESOURCE__ERRORS:
                                                case Resource.RESOURCE__WARNINGS: {
                                                        Resource resource = (Resource)notification.getNotifier();
                                                        Diagnostic diagnostic = analyzeResourceProblems(resource, null);
                                                        if (diagnostic.getSeverity() != Diagnostic.OK) {
                                                                resourceToDiagnosticMap.put(resource, diagnostic);
                                                        }
                                                        else {
                                                                resourceToDiagnosticMap.remove(resource);
                                                        }

                                                        if (updateProblemIndication) {
                                                                getSite().getShell().getDisplay().asyncExec
                                                                        (new Runnable() {
                                                                                 public void run() {
                                                                                         updateProblemIndication();
                                                                                 }
                                                                         });
                                                        }
                                                        break;
                                                }
                                        }
                                }
                                else {
                                        super.notifyChanged(notification);
                                }
                        }

                        @Override
                        protected void setTarget(Resource target) {
                                basicSetTarget(target);
                        }

                        @Override
                        protected void unsetTarget(Resource target) {
                                basicUnsetTarget(target);
                        }
                };

        protected IResourceChangeListener resourceChangeListener =
                new IResourceChangeListener() {
                        public void resourceChanged(IResourceChangeEvent event) {
                                IResourceDelta delta = event.getDelta();
                                try {
                                        class ResourceDeltaVisitor implements IResourceDeltaVisitor {
                                                protected ResourceSet resourceSet = editingDomain.getResourceSet();
                                                protected Collection<Resource> changedResources = new ArrayList<Resource>();
                                                protected Collection<Resource> removedResources = new ArrayList<Resource>();

                                                public boolean visit(IResourceDelta delta) {
                                                        if (delta.getResource().getType() == IResource.FILE) {
                                                                if (delta.getKind() == IResourceDelta.REMOVED ||
                                                                    delta.getKind() == IResourceDelta.CHANGED && delta.getFlags() != IResourceDelta.MARKERS) {
                                                                        Resource resource = resourceSet.getResource(URI.createPlatformResourceURI(delta.getFullPath().toString(), true), false);
                                                                        if (resource != null) {
                                                                                if (delta.getKind() == IResourceDelta.REMOVED) {
                                                                                        removedResources.add(resource);
                                                                                }
                                                                                else if (!savedResources.remove(resource)) {
                                                                                        changedResources.add(resource);
                                                                                }
                                                                        }
                                                                }
                                                        }

                                                        return true;
                                                }

                                                public Collection<Resource> getChangedResources() {
                                                        return changedResources;
                                                }

                                                public Collection<Resource> getRemovedResources() {
                                                        return removedResources;
                                                }
                                        }

                                        final ResourceDeltaVisitor visitor = new ResourceDeltaVisitor();
                                        delta.accept(visitor);

                                        if (!visitor.getRemovedResources().isEmpty()) {
                                                getSite().getShell().getDisplay().asyncExec
                                                        (new Runnable() {
                                                                 public void run() {
                                                                         removedResources.addAll(visitor.getRemovedResources());
                                                                         if (!isDirty()) {
                                                                                 getSite().getPage().closeEditor(DatatypesEditor.this, false);
                                                                         }
                                                                 }
                                                         });
                                        }

                                        if (!visitor.getChangedResources().isEmpty()) {
                                                getSite().getShell().getDisplay().asyncExec
                                                        (new Runnable() {
                                                                 public void run() {
                                                                         changedResources.addAll(visitor.getChangedResources());
                                                                         if (getSite().getPage().getActiveEditor() == DatatypesEditor.this) {
                                                                                 handleActivate();
                                                                         }
                                                                 }
                                                         });
                                        }
                                }
                                catch (CoreException exception) {
                                        DataTypesEditorPlugin.INSTANCE.log(exception);
                                }
                        }
                };

        protected void handleActivate() {
                // Recompute the read only state.
                //
                if (editingDomain.getResourceToReadOnlyMap() != null) {
                  editingDomain.getResourceToReadOnlyMap().clear();

                  // Refresh any actions that may become enabled or disabled.
                  //
                  setSelection(getSelection());
                }

                if (!removedResources.isEmpty()) {
                        if (handleDirtyConflict()) {
                                getSite().getPage().closeEditor(DatatypesEditor.this, false);
                        }
                        else {
                                removedResources.clear();
                                changedResources.clear();
                                savedResources.clear();
                        }
                }
                else if (!changedResources.isEmpty()) {
                        changedResources.removeAll(savedResources);
                        handleChangedResources();
                        changedResources.clear();
                        savedResources.clear();
                }
        }

        protected void handleChangedResources() {
                if (!changedResources.isEmpty() && (!isDirty() || handleDirtyConflict())) {
                        if (isDirty()) {
                                changedResources.addAll(editingDomain.getResourceSet().getResources());
                        }
                        editingDomain.getCommandStack().flush();

                        updateProblemIndication = false;
                        for (Resource resource : changedResources) {
                                if (resource.isLoaded()) {
                                        resource.unload();
                                        try {
                                                resource.load(Collections.EMPTY_MAP);
                                        }
                                        catch (IOException exception) {
                                                if (!resourceToDiagnosticMap.containsKey(resource)) {
                                                        resourceToDiagnosticMap.put(resource, analyzeResourceProblems(resource, exception));
                                                }
                                        }
                                }
                        }

                        if (AdapterFactoryEditingDomain.isStale(editorSelection)) {
                                setSelection(StructuredSelection.EMPTY);
                        }

                        updateProblemIndication = true;
                        updateProblemIndication();
                }
        }
  
        protected void updateProblemIndication() {
                if (updateProblemIndication) {
                        BasicDiagnostic diagnostic =
                                new BasicDiagnostic
                                        (Diagnostic.OK,
                                         "org.best_of_robotics.model.datatypes.editor",
                                         0,
                                         null,
                                         new Object [] { editingDomain.getResourceSet() });
                        for (Diagnostic childDiagnostic : resourceToDiagnosticMap.values()) {
                                if (childDiagnostic.getSeverity() != Diagnostic.OK) {
                                        diagnostic.add(childDiagnostic);
                                }
                        }

                        int lastEditorPage = getPageCount() - 1;
                        if (lastEditorPage >= 0 && getEditor(lastEditorPage) instanceof ProblemEditorPart) {
                                ((ProblemEditorPart)getEditor(lastEditorPage)).setDiagnostic(diagnostic);
                                if (diagnostic.getSeverity() != Diagnostic.OK) {
                                        setActivePage(lastEditorPage);
                                }
                        }
                        else if (diagnostic.getSeverity() != Diagnostic.OK) {
                                ProblemEditorPart problemEditorPart = new ProblemEditorPart();
                                problemEditorPart.setDiagnostic(diagnostic);
                                problemEditorPart.setMarkerHelper(markerHelper);
                                try {
                                        addPage(++lastEditorPage, problemEditorPart, getEditorInput());
                                        setPageText(lastEditorPage, problemEditorPart.getPartName());
                                        setActivePage(lastEditorPage);
                                        showTabs();
                                }
                                catch (PartInitException exception) {
                                        DataTypesEditorPlugin.INSTANCE.log(exception);
                                }
                        }

                        if (markerHelper.hasMarkers(editingDomain.getResourceSet())) {
                                markerHelper.deleteMarkers(editingDomain.getResourceSet());
                                if (diagnostic.getSeverity() != Diagnostic.OK) {
                                        try {
                                                markerHelper.createMarkers(diagnostic);
                                        }
                                        catch (CoreException exception) {
                                                DataTypesEditorPlugin.INSTANCE.log(exception);
                                        }
                                }
                        }
                }
        }

        protected boolean handleDirtyConflict() {
                return
                        MessageDialog.openQuestion
                                (getSite().getShell(),
                                 getString("_UI_FileConflict_label"),
                                 getString("_WARN_FileConflict"));
        }

        public DatatypesEditor() {
                super();
                initializeEditingDomain();
        }

        protected void initializeEditingDomain() {
                // Create an adapter factory that yields item providers.
                //
                adapterFactory = new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE);

                adapterFactory.addAdapterFactory(new ResourceItemProviderAdapterFactory());
                adapterFactory.addAdapterFactory(new DatatypesItemProviderAdapterFactory());
                adapterFactory.addAdapterFactory(new ReflectiveItemProviderAdapterFactory());

                // Create the command stack that will notify this editor as commands are executed.
                //
                BasicCommandStack commandStack = new BasicCommandStack();

                // Add a listener to set the most recent command's affected objects to be the selection of the viewer with focus.
                //
                commandStack.addCommandStackListener
                        (new CommandStackListener() {
                                 public void commandStackChanged(final EventObject event) {
                                         getContainer().getDisplay().asyncExec
                                                 (new Runnable() {
                                                          public void run() {
                                                                  firePropertyChange(IEditorPart.PROP_DIRTY);

                                                                  // Try to select the affected objects.
                                                                  //
                                                                  Command mostRecentCommand = ((CommandStack)event.getSource()).getMostRecentCommand();
                                                                  if (mostRecentCommand != null) {
                                                                          setSelectionToViewer(mostRecentCommand.getAffectedObjects());
                                                                  }
                                                                  if (propertySheetPage != null && !propertySheetPage.getControl().isDisposed()) {
                                                                          propertySheetPage.refresh();
                                                                  }
                                                          }
                                                  });
                                 }
                         });

                // Create the editing domain with a special command stack.
                //
                editingDomain = new AdapterFactoryEditingDomain(adapterFactory, commandStack, new HashMap<Resource, Boolean>());
        }

                        @Override
        protected void firePropertyChange(int action) {
                super.firePropertyChange(action);
        }

        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 EditingDomain getEditingDomain() {
                return editingDomain;
        }

        public class ReverseAdapterFactoryContentProvider extends AdapterFactoryContentProvider {
                public ReverseAdapterFactoryContentProvider(AdapterFactory adapterFactory) {
                        super(adapterFactory);
                }

                @Override
                public Object [] getElements(Object object) {
                        Object parent = super.getParent(object);
                        return (parent == null ? Collections.EMPTY_SET : Collections.singleton(parent)).toArray();
                }

                @Override
                public Object [] getChildren(Object object) {
                        Object parent = super.getParent(object);
                        return (parent == null ? Collections.EMPTY_SET : Collections.singleton(parent)).toArray();
                }

                @Override
                public boolean hasChildren(Object object) {
                        Object parent = super.getParent(object);
                        return parent != null;
                }

                @Override
                public Object getParent(Object object) {
                        return null;
                }
        }

        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) {
                                                        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.
                        //
                        setSelection(currentViewer == null ? StructuredSelection.EMPTY : currentViewer.getSelection());
                }
        }

        public Viewer getViewer() {
                return currentViewer;
        }

        protected void createContextMenuFor(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 createModel() {
                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);
                }

                Diagnostic diagnostic = analyzeResourceProblems(resource, exception);
                if (diagnostic.getSeverity() != Diagnostic.OK) {
                        resourceToDiagnosticMap.put(resource,  analyzeResourceProblems(resource, exception));
                }
                editingDomain.getResourceSet().eAdapters().add(problemIndicationAdapter);
        }

        public Diagnostic analyzeResourceProblems(Resource resource, Exception exception) {
                if (!resource.getErrors().isEmpty() || !resource.getWarnings().isEmpty()) {
                        BasicDiagnostic basicDiagnostic =
                                new BasicDiagnostic
                                        (Diagnostic.ERROR,
                                         "org.best_of_robotics.model.datatypes.editor",
                                         0,
                                         getString("_UI_CreateModelError_message", resource.getURI()),
                                         new Object [] { exception == null ? (Object)resource : exception });
                        basicDiagnostic.merge(EcoreUtil.computeDiagnostic(resource, true));
                        return basicDiagnostic;
                }
                else if (exception != null) {
                        return
                                new BasicDiagnostic
                                        (Diagnostic.ERROR,
                                         "org.best_of_robotics.model.datatypes.editor",
                                         0,
                                         getString("_UI_CreateModelError_message", resource.getURI()),
                                         new Object[] { exception });
                }
                else {
                        return Diagnostic.OK_INSTANCE;
                }
        }

        @Override
        public void createPages() {
                // Creates the model from the editor input
                //
                createModel();

                // Only creates the other pages if there is something that can be edited
                //
                if (!getEditingDomain().getResourceSet().getResources().isEmpty()) {
                        // Create a page for the selection tree view.
                        //
                        Tree tree = new Tree(getContainer(), SWT.MULTI);
                        selectionViewer = new TreeViewer(tree);
                        setCurrentViewer(selectionViewer);

                        selectionViewer.setContentProvider(new AdapterFactoryContentProvider(adapterFactory));
                        selectionViewer.setLabelProvider(new AdapterFactoryLabelProvider(adapterFactory));
                        selectionViewer.setInput(editingDomain.getResourceSet());
                        selectionViewer.setSelection(new StructuredSelection(editingDomain.getResourceSet().getResources().get(0)), true);

                        new AdapterFactoryTreeEditor(selectionViewer.getTree(), adapterFactory);

                        createContextMenuFor(selectionViewer);
                        int pageIndex = addPage(tree);
                        setPageText(pageIndex, getString("_UI_SelectionPage_label"));

                        getSite().getShell().getDisplay().asyncExec
                                (new Runnable() {
                                         public void run() {
                                                 setActivePage(0);
                                         }
                                 });
                }

                // Ensures that this editor will only display the page's tab
                // area if there are more than one page
                //
                getContainer().addControlListener
                        (new ControlAdapter() {
                                boolean guard = false;
                                @Override
                                public void controlResized(ControlEvent event) {
                                        if (!guard) {
                                                guard = true;
                                                hideTabs();
                                                guard = false;
                                        }
                                }
                         });

                getSite().getShell().getDisplay().asyncExec
                        (new Runnable() {
                                 public void run() {
                                         updateProblemIndication();
                                 }
                         });
        }

        protected void hideTabs() {
                if (getPageCount() <= 1) {
                        setPageText(0, "");
                        if (getContainer() instanceof CTabFolder) {
                                ((CTabFolder)getContainer()).setTabHeight(1);
                                Point point = getContainer().getSize();
                                getContainer().setSize(point.x, point.y + 6);
                        }
                }
        }

        protected void showTabs() {
                if (getPageCount() > 1) {
                        setPageText(0, getString("_UI_SelectionPage_label"));
                        if (getContainer() instanceof CTabFolder) {
                                ((CTabFolder)getContainer()).setTabHeight(SWT.DEFAULT);
                                Point point = getContainer().getSize();
                                getContainer().setSize(point.x, point.y - 6);
                        }
                }
        }

        @Override
        protected void pageChange(int pageIndex) {
                super.pageChange(pageIndex);

                if (contentOutlinePage != null) {
                        handleContentOutlineSelection(contentOutlinePage.getSelection());
                }
        }

        @SuppressWarnings("rawtypes")
        @Override
        public Object getAdapter(Class key) {
                if (key.equals(IContentOutlinePage.class)) {
                        return showOutlineView() ? getContentOutlinePage() : null;
                }
                else if (key.equals(IPropertySheetPage.class)) {
                        return getPropertySheetPage();
                }
                else if (key.equals(IGotoMarker.class)) {
                        return this;
                }
                else {
                        return super.getAdapter(key);
                }
        }

        public IContentOutlinePage getContentOutlinePage() {
                if (contentOutlinePage == null) {
                        // The content outline is just a tree.
                        //
                        class MyContentOutlinePage extends ContentOutlinePage {
                                @Override
                                public void createControl(Composite parent) {
                                        super.createControl(parent);
                                        contentOutlineViewer = getTreeViewer();
                                        contentOutlineViewer.addSelectionChangedListener(this);

                                        // Set up the tree viewer.
                                        //
                                        contentOutlineViewer.setContentProvider(new AdapterFactoryContentProvider(adapterFactory));
                                        contentOutlineViewer.setLabelProvider(new AdapterFactoryLabelProvider(adapterFactory));
                                        contentOutlineViewer.setInput(editingDomain.getResourceSet());

                                        // Make sure our popups work.
                                        //
                                        createContextMenuFor(contentOutlineViewer);

                                        if (!editingDomain.getResourceSet().getResources().isEmpty()) {
                                          // Select the root object in the view.
                                          //
                                          contentOutlineViewer.setSelection(new StructuredSelection(editingDomain.getResourceSet().getResources().get(0)), true);
                                        }
                                }

                                @Override
                                public void makeContributions(IMenuManager menuManager, IToolBarManager toolBarManager, IStatusLineManager statusLineManager) {
                                        super.makeContributions(menuManager, toolBarManager, statusLineManager);
                                        contentOutlineStatusLineManager = statusLineManager;
                                }

                                @Override
                                public void setActionBars(IActionBars actionBars) {
                                        super.setActionBars(actionBars);
                                        getActionBarContributor().shareGlobalActions(this, actionBars);
                                }
                        }

                        contentOutlinePage = new MyContentOutlinePage();

                        // 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;
        }

        public IPropertySheetPage getPropertySheetPage() {
                if (propertySheetPage == null) {
                        propertySheetPage =
                                new ExtendedPropertySheetPage(editingDomain) {
                                        @Override
                                        public void setSelectionToViewer(List<?> selection) {
                                                DatatypesEditor.this.setSelectionToViewer(selection);
                                                DatatypesEditor.this.setFocus();
                                        }

                                        @Override
                                        public void setActionBars(IActionBars actionBars) {
                                                super.setActionBars(actionBars);
                                                getActionBarContributor().shareGlobalActions(this, actionBars);
                                        }
                                };
                        propertySheetPage.setPropertySourceProvider(new AdapterFactoryContentProvider(adapterFactory));
                }

                return propertySheetPage;
        }

        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));
                        }
                }
        }

        @Override
        public boolean isDirty() {
                return ((BasicCommandStack)editingDomain.getCommandStack()).isSaveNeeded();
        }

        @Override
        public void doSave(IProgressMonitor progressMonitor) {
                // Save only resources that have actually changed.
                //
                final Map<Object, Object> saveOptions = new HashMap<Object, Object>();
                saveOptions.put(Resource.OPTION_SAVE_ONLY_IF_CHANGED, Resource.OPTION_SAVE_ONLY_IF_CHANGED_MEMORY_BUFFER);

                // Do the work within an operation because this is a long running activity that modifies the workbench.
                //
                WorkspaceModifyOperation operation =
                        new WorkspaceModifyOperation() {
                                // This is the method that gets invoked when the operation runs.
                                //
                                @Override
                                public void execute(IProgressMonitor monitor) {
                                        // Save the resources to the file system.
                                        //
                                        boolean first = true;
                                        for (Resource resource : editingDomain.getResourceSet().getResources()) {
                                                if ((first || !resource.getContents().isEmpty() || isPersisted(resource)) && !editingDomain.isReadOnly(resource)) {
                                                        try {
                                                                long timeStamp = resource.getTimeStamp();
                                                                resource.save(saveOptions);
                                                                if (resource.getTimeStamp() != timeStamp) {
                                                                        savedResources.add(resource);
                                                                }
                                                        }
                                                        catch (Exception exception) {
                                                                resourceToDiagnosticMap.put(resource, analyzeResourceProblems(resource, exception));
                                                        }
                                                        first = false;
                                                }
                                        }
                                }
                        };

                updateProblemIndication = false;
                try {
                        // This runs the options, and shows progress.
                        //
                        new ProgressMonitorDialog(getSite().getShell()).run(true, false, operation);

                        // Refresh the necessary state.
                        //
                        ((BasicCommandStack)editingDomain.getCommandStack()).saveIsDone();
                        firePropertyChange(IEditorPart.PROP_DIRTY);
                }
                catch (Exception exception) {
                        // Something went wrong that shouldn't.
                        //
                        DataTypesEditorPlugin.INSTANCE.log(exception);
                }
                updateProblemIndication = true;
                updateProblemIndication();
        }

        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;
        }

        @Override
        public boolean isSaveAsAllowed() {
                return true;
        }

        @Override
        public void doSaveAs() {
                SaveAsDialog saveAsDialog = new SaveAsDialog(getSite().getShell());
                saveAsDialog.open();
                IPath path = saveAsDialog.getResult();
                if (path != null) {
                        IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(path);
                        if (file != null) {
                                doSaveAs(URI.createPlatformResourceURI(file.getFullPath().toString(), true), new FileEditorInput(file));
                        }
                }
        }

        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 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) {
                        DataTypesEditorPlugin.INSTANCE.log(exception);
                }
        }

        @Override
        public void init(IEditorSite site, IEditorInput editorInput) {
                setSite(site);
                setInputWithNotify(editorInput);
                setPartName(editorInput.getName());
                site.setSelectionProvider(this);
                site.getPage().addPartListener(partListener);
                ResourcesPlugin.getWorkspace().addResourceChangeListener(resourceChangeListener, IResourceChangeEvent.POST_CHANGE);
        }

        @Override
        public void setFocus() {
                getControl(getActivePage()).setFocus();
        }

        public void addSelectionChangedListener(ISelectionChangedListener listener) {
                selectionChangedListeners.add(listener);
        }

        public void removeSelectionChangedListener(ISelectionChangedListener listener) {
                selectionChangedListeners.remove(listener);
        }

        public ISelection getSelection() {
                return editorSelection;
        }

        public void setSelection(ISelection selection) {
                editorSelection = selection;

                for (ISelectionChangedListener listener : selectionChangedListeners) {
                        listener.selectionChanged(new SelectionChangedEvent(this, selection));
                }
                setStatusLineManager(selection);
        }

        public void setStatusLineManager(ISelection selection) {
                IStatusLineManager statusLineManager = currentViewer != null && currentViewer == contentOutlineViewer ?
                        contentOutlineStatusLineManager : 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(adapterFactory).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("");
                        }
                }
        }

        private static String getString(String key) {
                return DataTypesEditorPlugin.INSTANCE.getString(key);
        }

        private static String getString(String key, Object s1) {
                return DataTypesEditorPlugin.INSTANCE.getString(key, new Object [] { s1 });
        }

        public void menuAboutToShow(IMenuManager menuManager) {
                ((IMenuListener)getEditorSite().getActionBarContributor()).menuAboutToShow(menuManager);
        }

        public EditingDomainActionBarContributor getActionBarContributor() {
                return (EditingDomainActionBarContributor)getEditorSite().getActionBarContributor();
        }

        public IActionBars getActionBars() {
                return getActionBarContributor().getActionBars();
        }

        public AdapterFactory getAdapterFactory() {
                return adapterFactory;
        }

        @Override
        public void dispose() {
                updateProblemIndication = false;

                ResourcesPlugin.getWorkspace().removeResourceChangeListener(resourceChangeListener);

                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();
        }

        protected boolean showOutlineView() {
                return false;
        }
}