diff options
14 files changed, 2485 insertions, 2 deletions
diff --git a/plugins/org.eclipse.emf.cdo.ui/.classpath b/plugins/org.eclipse.emf.cdo.ui/.classpath index 751c8f2e50..c275bcccff 100644 --- a/plugins/org.eclipse.emf.cdo.ui/.classpath +++ b/plugins/org.eclipse.emf.cdo.ui/.classpath @@ -1,6 +1,6 @@ <?xml version="1.0" encoding="UTF-8"?> <classpath> - <classpathentry kind="src" path="src"/> + <classpathentry excluding="org/eclipse/emf/cdo/internal/ui/editor/CDOModelWizard.java|org/eclipse/emf/cdo/internal/ui/editor/EditorEditorPlugin.java" kind="src" path="src"/> <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/> <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/> <classpathentry kind="output" path="bin"/> diff --git a/plugins/org.eclipse.emf.cdo.ui/META-INF/MANIFEST.MF b/plugins/org.eclipse.emf.cdo.ui/META-INF/MANIFEST.MF index 28d8d2b9bb..96ab136269 100644 --- a/plugins/org.eclipse.emf.cdo.ui/META-INF/MANIFEST.MF +++ b/plugins/org.eclipse.emf.cdo.ui/META-INF/MANIFEST.MF @@ -7,5 +7,8 @@ Bundle-Activator: org.eclipse.emf.cdo.internal.ui.bundle.CDOUI$Activator Bundle-Vendor: %providerName Require-Bundle: org.eclipse.core.runtime, org.eclipse.ui, - org.eclipse.emf.cdo.container + org.eclipse.emf.cdo.container, + org.eclipse.emf.edit.ui;visibility:=reexport, + org.eclipse.ui.ide;visibility:=reexport, + org.eclipse.core.resources Eclipse-LazyStart: true diff --git a/plugins/org.eclipse.emf.cdo.ui/icons/full/obj16/CDOModelFile.gif b/plugins/org.eclipse.emf.cdo.ui/icons/full/obj16/CDOModelFile.gif Binary files differnew file mode 100644 index 0000000000..d5cfa16f12 --- /dev/null +++ b/plugins/org.eclipse.emf.cdo.ui/icons/full/obj16/CDOModelFile.gif diff --git a/plugins/org.eclipse.emf.cdo.ui/icons/full/obj16/EditorModelFile.gif b/plugins/org.eclipse.emf.cdo.ui/icons/full/obj16/EditorModelFile.gif Binary files differnew file mode 100644 index 0000000000..d5cfa16f12 --- /dev/null +++ b/plugins/org.eclipse.emf.cdo.ui/icons/full/obj16/EditorModelFile.gif diff --git a/plugins/org.eclipse.emf.cdo.ui/icons/full/wizban/NewCDO.gif b/plugins/org.eclipse.emf.cdo.ui/icons/full/wizban/NewCDO.gif Binary files differnew file mode 100644 index 0000000000..2054126392 --- /dev/null +++ b/plugins/org.eclipse.emf.cdo.ui/icons/full/wizban/NewCDO.gif diff --git a/plugins/org.eclipse.emf.cdo.ui/icons/full/wizban/NewEditor.gif b/plugins/org.eclipse.emf.cdo.ui/icons/full/wizban/NewEditor.gif Binary files differnew file mode 100644 index 0000000000..2054126392 --- /dev/null +++ b/plugins/org.eclipse.emf.cdo.ui/icons/full/wizban/NewEditor.gif diff --git a/plugins/org.eclipse.emf.cdo.ui/model/DONT_GENERATE_MODEL.txt b/plugins/org.eclipse.emf.cdo.ui/model/DONT_GENERATE_MODEL.txt new file mode 100644 index 0000000000..964c62f4fd --- /dev/null +++ b/plugins/org.eclipse.emf.cdo.ui/model/DONT_GENERATE_MODEL.txt @@ -0,0 +1,4 @@ +Don't generate the model! + +Only generate the editor! + diff --git a/plugins/org.eclipse.emf.cdo.ui/model/editor.ecore b/plugins/org.eclipse.emf.cdo.ui/model/editor.ecore new file mode 100644 index 0000000000..8fbdda4f33 --- /dev/null +++ b/plugins/org.eclipse.emf.cdo.ui/model/editor.ecore @@ -0,0 +1,7 @@ +<?xml version="1.0" encoding="UTF-8"?> +<ecore:EPackage xmi:version="2.0" + xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="editor" + nsURI="http://www.eclipse.org/emf/CDO/editor/1.0.0" nsPrefix="editor"> + <eClassifiers xsi:type="ecore:EClass" name="Dummy"/> +</ecore:EPackage> diff --git a/plugins/org.eclipse.emf.cdo.ui/model/editor.genmodel b/plugins/org.eclipse.emf.cdo.ui/model/editor.genmodel new file mode 100644 index 0000000000..b65b260a36 --- /dev/null +++ b/plugins/org.eclipse.emf.cdo.ui/model/editor.genmodel @@ -0,0 +1,14 @@ +<?xml version="1.0" encoding="UTF-8"?> +<genmodel:GenModel xmi:version="2.0" + xmlns:xmi="http://www.omg.org/XMI" xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" modelDirectory="/org.eclipse.emf.cdo.ui/src" + editDirectory="" editorDirectory="/org.eclipse.emf.cdo.ui/src" modelPluginID="org.eclipse.emf.cdo.ui" + modelName="Editor" editorPluginClass="org.eclipse.emf.cdo.internal.ui.editor.PluginDelegator" + codeFormatting="true" testsDirectory="" importerID="org.eclipse.emf.importer.ecore" + complianceLevel="5.0"> + <foreignModel>editor.ecore</foreignModel> + <genPackages prefix="CDO" basePackage="org.eclipse.emf.cdo.internal.ui" disposableProviderFactory="true" + presentationPackageSuffix="" multipleEditorPages="false" generateModelWizard="false" + ecorePackage="editor.ecore#/"> + <genClasses ecoreClass="editor.ecore#//Dummy"/> + </genPackages> +</genmodel:GenModel> diff --git a/plugins/org.eclipse.emf.cdo.ui/plugin.properties b/plugins/org.eclipse.emf.cdo.ui/plugin.properties index fbb03e3f9d..41ee2686b2 100644 --- a/plugins/org.eclipse.emf.cdo.ui/plugin.properties +++ b/plugins/org.eclipse.emf.cdo.ui/plugin.properties @@ -31,3 +31,44 @@ providerName=Eclipse.org # %%% END OF TRANSLATED PROPERTIES %%% # The above properties have been shipped for translation. # ============================================================================== +_UI_CreateChild_menu_item = &New Child +_UI_CreateSibling_menu_item = N&ew Sibling +
_UI_ShowPropertiesView_menu_item = Show &Properties View +_UI_RefreshViewer_menu_item = &Refresh +
_UI_SelectionPage_label = Selection +
_UI_NoObjectSelected = Selected Nothing +_UI_SingleObjectSelected = Selected Object: {0} +_UI_MultiObjectSelected = Selected {0} Objects +
_UI_OpenEditorError_label = Open Editor +
_UI_Wizard_category = Example EMF Model Creation Wizards +
_UI_CreateModelError_message = Problems encountered in file "{0}" +
_UI_Wizard_label = New +
_WARN_FilenameExtension = The file name must end in ".{0}" +
_UI_ModelObject = Model Object +_UI_XMLEncoding = XML Encoding +_UI_XMLEncodingChoices = UTF-8 ASCII UTF-16 UTF-16BE UTF-16LE ISO-8859-1 +_UI_Wizard_initial_object_description = Select a model object to create +
_UI_FileConflict_label = File Conflict +_WARN_FileConflict = There are unsaved changes that conflict with changes made outside the editor. Do you wish to discard this editor's changes? +
+_UI_EditorEditor_menu = &Editor Editor +
_UI_ParentPage_label = Parent +_UI_ListPage_label = List +_UI_TreePage_label = Tree +_UI_TablePage_label = Table +_UI_TreeWithColumnsPage_label = Tree with Columns +_UI_ObjectColumn_label = Object +_UI_SelfColumn_label = Self +
_UI_EditorModelWizard_label = Editor Model +_UI_EditorModelWizard_description = Create a new Editor model +
_UI_EditorEditor_label = Editor Model Editor +
_UI_EditorEditorFilenameDefaultBase = My +_UI_EditorEditorFilenameExtension = editor +
+_UI_CDOEditor_menu = &CDO Editor +
_UI_CDOModelWizard_label = CDO Model +_UI_CDOModelWizard_description = Create a new CDO model +
_UI_CDOEditor_label = CDO Model Editor +
_UI_CDOEditorFilenameDefaultBase = My +_UI_CDOEditorFilenameExtension = cdo +
diff --git a/plugins/org.eclipse.emf.cdo.ui/src/org/eclipse/emf/cdo/internal/ui/editor/CDOActionBarContributor.java b/plugins/org.eclipse.emf.cdo.ui/src/org/eclipse/emf/cdo/internal/ui/editor/CDOActionBarContributor.java new file mode 100644 index 0000000000..41c2efbe58 --- /dev/null +++ b/plugins/org.eclipse.emf.cdo.ui/src/org/eclipse/emf/cdo/internal/ui/editor/CDOActionBarContributor.java @@ -0,0 +1,478 @@ +/** + * <copyright> + * </copyright> + * + * $Id$ + */ +package org.eclipse.emf.cdo.internal.ui.editor; + +import org.eclipse.emf.common.ui.viewer.IViewerProvider; +import org.eclipse.emf.edit.command.CommandParameter; +import org.eclipse.emf.edit.domain.EditingDomain; +import org.eclipse.emf.edit.domain.IEditingDomainProvider; +import org.eclipse.emf.edit.ui.action.ControlAction; +import org.eclipse.emf.edit.ui.action.CreateChildAction; +import org.eclipse.emf.edit.ui.action.CreateSiblingAction; +import org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor; +import org.eclipse.emf.edit.ui.action.LoadResourceAction; +import org.eclipse.emf.edit.ui.action.ValidateAction; + +import org.eclipse.jface.action.Action; +import org.eclipse.jface.action.ActionContributionItem; +import org.eclipse.jface.action.IAction; +import org.eclipse.jface.action.IContributionItem; +import org.eclipse.jface.action.IContributionManager; +import org.eclipse.jface.action.IMenuListener; +import org.eclipse.jface.action.IMenuManager; +import org.eclipse.jface.action.IToolBarManager; +import org.eclipse.jface.action.MenuManager; +import org.eclipse.jface.action.Separator; +import org.eclipse.jface.action.SubContributionItem; +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.Viewer; +import org.eclipse.ui.IEditorPart; +import org.eclipse.ui.PartInitException; + +import java.util.ArrayList; +import java.util.Collection; + +/** + * This is the action bar contributor for the CDO model editor. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ +public class CDOActionBarContributor extends EditingDomainActionBarContributor implements ISelectionChangedListener +{ + /** + * This keeps track of the active editor. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + protected IEditorPart activeEditorPart; + + /** + * This keeps track of the current selection provider. <!-- begin-user-doc --> + * <!-- end-user-doc --> + * + * @generated + */ + protected ISelectionProvider selectionProvider; + + /** + * This action opens the Properties view. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + protected IAction showPropertiesViewAction = new Action(PluginDelegator.INSTANCE + .getString("_UI_ShowPropertiesView_menu_item")) + { + @Override + public void run() + { + try + { + getPage().showView("org.eclipse.ui.views.PropertySheet"); + } + catch (PartInitException exception) + { + PluginDelegator.INSTANCE.log(exception); + } + } + }; + + /** + * This action refreshes the viewer of the current editor if the editor + * implements {@link org.eclipse.emf.common.ui.viewer.IViewerProvider}. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected IAction refreshViewerAction = new Action(PluginDelegator.INSTANCE.getString("_UI_RefreshViewer_menu_item")) + { + @Override + public boolean isEnabled() + { + return activeEditorPart instanceof IViewerProvider; + } + + @Override + public void run() + { + if (activeEditorPart instanceof IViewerProvider) + { + Viewer viewer = ((IViewerProvider)activeEditorPart).getViewer(); + if (viewer != null) + { + viewer.refresh(); + } + } + } + }; + + /** + * This will contain one + * {@link org.eclipse.emf.edit.ui.action.CreateChildAction} corresponding to + * each descriptor generated for the current selection by the item provider. + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected Collection<IAction> createChildActions; + + /** + * This is the menu manager into which menu contribution items should be added + * for CreateChild actions. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected IMenuManager createChildMenuManager; + + /** + * This will contain one + * {@link org.eclipse.emf.edit.ui.action.CreateSiblingAction} corresponding to + * each descriptor generated for the current selection by the item provider. + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected Collection<IAction> createSiblingActions; + + /** + * This is the menu manager into which menu contribution items should be added + * for CreateSibling actions. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected IMenuManager createSiblingMenuManager; + + /** + * This creates an instance of the contributor. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + public CDOActionBarContributor() + { + super(ADDITIONS_LAST_STYLE); + loadResourceAction = new LoadResourceAction(); + validateAction = new ValidateAction(); + controlAction = new ControlAction(); + } + + /** + * This adds Separators for editor additions to the tool bar. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @Override + public void contributeToToolBar(IToolBarManager toolBarManager) + { + toolBarManager.add(new Separator("cdo-settings")); + toolBarManager.add(new Separator("cdo-additions")); + } + + /** + * This adds to the menu bar a menu and some separators for editor additions, + * as well as the sub-menus for object creation items. <!-- begin-user-doc --> + * <!-- end-user-doc --> + * + * @generated + */ + @Override + public void contributeToMenu(IMenuManager menuManager) + { + super.contributeToMenu(menuManager); + + IMenuManager submenuManager = new MenuManager(PluginDelegator.INSTANCE.getString("_UI_CDOEditor_menu"), + "org.eclipse.emf.cdo.internal.ui.editorMenuID"); + menuManager.insertAfter("additions", submenuManager); + submenuManager.add(new Separator("settings")); + submenuManager.add(new Separator("actions")); + submenuManager.add(new Separator("additions")); + submenuManager.add(new Separator("additions-end")); + + // Prepare for CreateChild item addition or removal. + // + createChildMenuManager = new MenuManager(PluginDelegator.INSTANCE.getString("_UI_CreateChild_menu_item")); + submenuManager.insertBefore("additions", createChildMenuManager); + + // Prepare for CreateSibling item addition or removal. + // + createSiblingMenuManager = new MenuManager(PluginDelegator.INSTANCE.getString("_UI_CreateSibling_menu_item")); + submenuManager.insertBefore("additions", createSiblingMenuManager); + + // Force an update because Eclipse hides empty menus now. + // + submenuManager.addMenuListener(new IMenuListener() + { + public void menuAboutToShow(IMenuManager menuManager) + { + menuManager.updateAll(true); + } + }); + + addGlobalActions(submenuManager); + } + + /** + * When the active editor changes, this remembers the change and registers + * with it as a selection provider. <!-- begin-user-doc --> <!-- end-user-doc + * --> + * + * @generated + */ + @Override + public void setActiveEditor(IEditorPart part) + { + super.setActiveEditor(part); + activeEditorPart = part; + + // Switch to the new selection provider. + // + if (selectionProvider != null) + { + selectionProvider.removeSelectionChangedListener(this); + } + if (part == null) + { + selectionProvider = null; + } + else + { + selectionProvider = part.getSite().getSelectionProvider(); + selectionProvider.addSelectionChangedListener(this); + + // Fake a selection changed event to update the menus. + // + if (selectionProvider.getSelection() != null) + { + selectionChanged(new SelectionChangedEvent(selectionProvider, selectionProvider.getSelection())); + } + } + } + + /** + * This implements {@link org.eclipse.jface.viewers.ISelectionChangedListener}, + * handling {@link org.eclipse.jface.viewers.SelectionChangedEvent}s by + * querying for the children and siblings that can be added to the selected + * object and updating the menus accordingly. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + public void selectionChanged(SelectionChangedEvent event) + { + // Remove any menu items for old selection. + // + if (createChildMenuManager != null) + { + depopulateManager(createChildMenuManager, createChildActions); + } + if (createSiblingMenuManager != null) + { + depopulateManager(createSiblingMenuManager, createSiblingActions); + } + + // Query the new selection for appropriate new child/sibling descriptors + // + Collection<CommandParameter> newChildDescriptors = null; + Collection<CommandParameter> newSiblingDescriptors = null; + + ISelection selection = event.getSelection(); + if (selection instanceof IStructuredSelection && ((IStructuredSelection)selection).size() == 1) + { + Object object = ((IStructuredSelection)selection).getFirstElement(); + + EditingDomain domain = ((IEditingDomainProvider)activeEditorPart).getEditingDomain(); + + newChildDescriptors = domain.getNewChildDescriptors(object, null); + newSiblingDescriptors = domain.getNewChildDescriptors(null, object); + } + + // Generate actions for selection; populate and redraw the menus. + // + createChildActions = generateCreateChildActions(newChildDescriptors, selection); + createSiblingActions = generateCreateSiblingActions(newSiblingDescriptors, selection); + + if (createChildMenuManager != null) + { + populateManager(createChildMenuManager, createChildActions, null); + createChildMenuManager.update(true); + } + if (createSiblingMenuManager != null) + { + populateManager(createSiblingMenuManager, createSiblingActions, null); + createSiblingMenuManager.update(true); + } + } + + /** + * This generates a {@link org.eclipse.emf.edit.ui.action.CreateChildAction} + * for each object in <code>descriptors</code>, and returns the collection + * of these actions. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected Collection<IAction> generateCreateChildActions(Collection<? extends CommandParameter> descriptors, + ISelection selection) + { + Collection<IAction> actions = new ArrayList<IAction>(); + if (descriptors != null) + { + for (CommandParameter descriptor : descriptors) + { + actions.add(new CreateChildAction(activeEditorPart, selection, descriptor)); + } + } + return actions; + } + + /** + * This generates a {@link org.eclipse.emf.edit.ui.action.CreateSiblingAction} + * for each object in <code>descriptors</code>, and returns the collection + * of these actions. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected Collection<IAction> generateCreateSiblingActions(Collection<? extends CommandParameter> descriptors, + ISelection selection) + { + Collection<IAction> actions = new ArrayList<IAction>(); + if (descriptors != null) + { + for (CommandParameter descriptor : descriptors) + { + actions.add(new CreateSiblingAction(activeEditorPart, selection, descriptor)); + } + } + return actions; + } + + /** + * This populates the specified <code>manager</code> with + * {@link org.eclipse.jface.action.ActionContributionItem}s based on the + * {@link org.eclipse.jface.action.IAction}s contained in the + * <code>actions</code> collection, by inserting them before the specified + * contribution item <code>contributionID</code>. If <code>ID</code> is + * <code>null</code>, they are simply added. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + protected void populateManager(IContributionManager manager, Collection<? extends IAction> actions, + String contributionID) + { + if (actions != null) + { + for (IAction action : actions) + { + if (contributionID != null) + { + manager.insertBefore(contributionID, action); + } + else + { + manager.add(action); + } + } + } + } + + /** + * This removes from the specified <code>manager</code> all + * {@link org.eclipse.jface.action.ActionContributionItem}s based on the + * {@link org.eclipse.jface.action.IAction}s contained in the + * <code>actions</code> collection. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + protected void depopulateManager(IContributionManager manager, Collection<? extends IAction> actions) + { + if (actions != null) + { + IContributionItem[] items = manager.getItems(); + for (int i = 0; i < items.length; i++) + { + // Look into SubContributionItems + // + IContributionItem contributionItem = items[i]; + while (contributionItem instanceof SubContributionItem) + { + contributionItem = ((SubContributionItem)contributionItem).getInnerItem(); + } + + // Delete the ActionContributionItems with matching action. + // + if (contributionItem instanceof ActionContributionItem) + { + IAction action = ((ActionContributionItem)contributionItem).getAction(); + if (actions.contains(action)) + { + manager.remove(contributionItem); + } + } + } + } + } + + /** + * This populates the pop-up menu before it appears. <!-- begin-user-doc --> + * <!-- end-user-doc --> + * + * @generated + */ + @Override + public void menuAboutToShow(IMenuManager menuManager) + { + super.menuAboutToShow(menuManager); + MenuManager submenuManager = null; + + submenuManager = new MenuManager(PluginDelegator.INSTANCE.getString("_UI_CreateChild_menu_item")); + populateManager(submenuManager, createChildActions, null); + menuManager.insertBefore("edit", submenuManager); + + submenuManager = new MenuManager(PluginDelegator.INSTANCE.getString("_UI_CreateSibling_menu_item")); + populateManager(submenuManager, createSiblingActions, null); + menuManager.insertBefore("edit", submenuManager); + } + + /** + * This inserts global actions before the "additions-end" separator. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @Override + protected void addGlobalActions(IMenuManager menuManager) + { + menuManager.insertAfter("additions-end", new Separator("ui-actions")); + menuManager.insertAfter("ui-actions", showPropertiesViewAction); + + refreshViewerAction.setEnabled(refreshViewerAction.isEnabled()); + menuManager.insertAfter("ui-actions", refreshViewerAction); + + super.addGlobalActions(menuManager); + } + + /** + * This ensures that a delete action will clean up all references to deleted + * objects. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @Override + protected boolean removeAllReferencesOnDelete() + { + return true; + } + +}
\ No newline at end of file diff --git a/plugins/org.eclipse.emf.cdo.ui/src/org/eclipse/emf/cdo/internal/ui/editor/CDOEditor.java b/plugins/org.eclipse.emf.cdo.ui/src/org/eclipse/emf/cdo/internal/ui/editor/CDOEditor.java new file mode 100644 index 0000000000..7d81bf2e10 --- /dev/null +++ b/plugins/org.eclipse.emf.cdo.ui/src/org/eclipse/emf/cdo/internal/ui/editor/CDOEditor.java @@ -0,0 +1,1693 @@ +/** + * <copyright> + * </copyright> + * + * $Id$ + */ +package org.eclipse.emf.cdo.internal.ui.editor; + +import org.eclipse.emf.cdo.CDOAdapter; +import org.eclipse.emf.cdo.CDOSession; +import org.eclipse.emf.cdo.util.CDOUtil; + +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.EMFEditPlugin; +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.ComposedAdapterFactory.Descriptor.Registry; +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.util.EditUIMarkerHelper; +import org.eclipse.emf.edit.ui.view.ExtendedPropertySheetPage; + +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.actions.WorkspaceModifyOperation; +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 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; + +/** + * This is an example of a CDO model editor. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ +public class CDOEditor extends MultiPageEditorPart implements IEditingDomainProvider, ISelectionProvider, + IMenuListener, IViewerProvider, IGotoMarker +{ + /** + * @ADDED + */ + private CDOAdapter adapter; + + /** + * This keeps track of the editing domain that is used to track all changes to + * the model. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected AdapterFactoryEditingDomain editingDomain; + + /** + * This is the one adapter factory used for providing views of the model. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected ComposedAdapterFactory adapterFactory; + + /** + * This is the content outline page. <!-- begin-user-doc --> <!-- end-user-doc + * --> + * + * @generated + */ + protected IContentOutlinePage contentOutlinePage; + + /** + * This is a kludge... <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected IStatusLineManager contentOutlineStatusLineManager; + + /** + * This is the content outline page's viewer. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + protected TreeViewer contentOutlineViewer; + + /** + * This is the property sheet page. <!-- begin-user-doc --> <!-- end-user-doc + * --> + * + * @generated + */ + protected PropertySheetPage propertySheetPage; + + /** + * This is the viewer that shadows the selection in the content outline. The + * parent relation must be correctly defined for this to work. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + 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. <!-- begin-user-doc + * --> <!-- end-user-doc --> + * + * @generated + */ + protected Viewer currentViewer; + + /** + * This listens to which ever viewer is active. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + protected ISelectionChangedListener selectionChangedListener; + + /** + * This keeps track of all the + * {@link org.eclipse.jface.viewers.ISelectionChangedListener}s that are + * listening to this editor. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected Collection<ISelectionChangedListener> selectionChangedListeners = new ArrayList<ISelectionChangedListener>(); + + /** + * This keeps track of the selection of the editor as a whole. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected ISelection editorSelection = StructuredSelection.EMPTY; + + /** + * The MarkerHelper is responsible for creating workspace resource markers + * presented in Eclipse's Problems View. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + protected MarkerHelper markerHelper = new EditUIMarkerHelper(); + + /** + * This listens for when the outline becomes active <!-- begin-user-doc --> + * <!-- end-user-doc --> + * + * @generated + */ + protected IPartListener partListener = new IPartListener() + { + public void partActivated(IWorkbenchPart p) + { + if (p instanceof ContentOutline) + { + if (((ContentOutline)p).getCurrentPage() == contentOutlinePage) + { + getActionBarContributor().setActiveEditor(CDOEditor.this); + + setCurrentViewer(contentOutlineViewer); + } + } + else if (p instanceof PropertySheet) + { + if (((PropertySheet)p).getCurrentPage() == propertySheetPage) + { + getActionBarContributor().setActiveEditor(CDOEditor.this); + handleActivate(); + } + } + else if (p == CDOEditor.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. + } + }; + + /** + * Resources that have been removed since last activation. <!-- begin-user-doc + * --> <!-- end-user-doc --> + * + * @generated + */ + protected Collection<Resource> removedResources = new ArrayList<Resource>(); + + /** + * Resources that have been changed since last activation. <!-- begin-user-doc + * --> <!-- end-user-doc --> + * + * @generated + */ + protected Collection<Resource> changedResources = new ArrayList<Resource>(); + + /** + * Resources that have been saved. <!-- begin-user-doc --> <!-- end-user-doc + * --> + * + * @generated + */ + protected Collection<Resource> savedResources = new ArrayList<Resource>(); + + /** + * Map to store the diagnostic associated with a resource. <!-- begin-user-doc + * --> <!-- end-user-doc --> + * + * @generated + */ + protected Map<Resource, Diagnostic> resourceToDiagnosticMap = new LinkedHashMap<Resource, Diagnostic>(); + + /** + * Controls whether the problem indication should be updated. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected boolean updateProblemIndication = true; + + /** + * Adapter used to update the problem indication when resources are demanded + * loaded. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + 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)notification.getNotifier(), 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); + } + }; + + /** + * This listens for workspace changes. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + protected IResourceChangeListener resourceChangeListener = new IResourceChangeListener() + { + public void resourceChanged(IResourceChangeEvent event) + { + // Only listening to these. + // if (event.getType() == IResourceDelta.POST_CHANGE) + { + 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.getFlags() != IResourceDelta.MARKERS && delta.getResource().getType() == IResource.FILE) + { + if ((delta.getKind() & (IResourceDelta.CHANGED | IResourceDelta.REMOVED)) != 0) + { + Resource resource = resourceSet.getResource(URI.createURI(delta.getFullPath().toString()), false); + if (resource != null) + { + if ((delta.getKind() & IResourceDelta.REMOVED) != 0) + { + 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; + } + } + + ResourceDeltaVisitor visitor = new ResourceDeltaVisitor(); + delta.accept(visitor); + + if (!visitor.getRemovedResources().isEmpty()) + { + removedResources.addAll(visitor.getRemovedResources()); + if (!isDirty()) + { + getSite().getShell().getDisplay().asyncExec(new Runnable() + { + public void run() + { + getSite().getPage().closeEditor(CDOEditor.this, false); + CDOEditor.this.dispose(); + } + }); + } + } + + if (!visitor.getChangedResources().isEmpty()) + { + changedResources.addAll(visitor.getChangedResources()); + if (getSite().getPage().getActiveEditor() == CDOEditor.this) + { + getSite().getShell().getDisplay().asyncExec(new Runnable() + { + public void run() + { + handleActivate(); + } + }); + } + } + } + catch (CoreException exception) + { + PluginDelegator.INSTANCE.log(exception); + } + } + } + }; + + /** + * Handles activation of the editor or it's associated views. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + 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(CDOEditor.this, false); + CDOEditor.this.dispose(); + } + else + { + removedResources.clear(); + changedResources.clear(); + savedResources.clear(); + } + } + else if (!changedResources.isEmpty()) + { + changedResources.removeAll(savedResources); + handleChangedResources(); + changedResources.clear(); + savedResources.clear(); + } + } + + /** + * Handles what to do with changed resources on activation. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected void handleChangedResources() + { + if (!changedResources.isEmpty() && (!isDirty() || handleDirtyConflict())) + { + 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)); + } + } + } + } + updateProblemIndication = true; + updateProblemIndication(); + } + } + + /** + * Updates the problems indication with the information described in the + * specified diagnostic. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected void updateProblemIndication() + { + if (updateProblemIndication) + { + BasicDiagnostic diagnostic = new BasicDiagnostic(Diagnostic.OK, "org.eclipse.emf.cdo.ui.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) + { + PluginDelegator.INSTANCE.log(exception); + } + } + + if (markerHelper.hasMarkers(editingDomain.getResourceSet())) + { + markerHelper.deleteMarkers(editingDomain.getResourceSet()); + if (diagnostic.getSeverity() != Diagnostic.OK) + { + try + { + markerHelper.createMarkers(diagnostic); + } + catch (CoreException exception) + { + PluginDelegator.INSTANCE.log(exception); + } + } + } + } + } + + /** + * Shows a dialog that asks if conflicting changes should be discarded. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected boolean handleDirtyConflict() + { + return MessageDialog.openQuestion(getSite().getShell(), getString("_UI_FileConflict_label"), + getString("_WARN_FileConflict")); + } + + /** + * This creates a model editor. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated NOT + */ + public CDOEditor() + { + super(); + + // Create an adapter factory that yields item providers. + // + Registry regsitry = EMFEditPlugin.getComposedAdapterFactoryDescriptorRegistry(); + adapterFactory = new ComposedAdapterFactory(regsitry); + + // 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>()); + } + + /** + * This is here for the listener to be able to call it. <!-- begin-user-doc + * --> <!-- end-user-doc --> + * + * @generated + */ + @Override + protected void firePropertyChange(int action) + { + super.firePropertyChange(action); + } + + /** + * This sets the selection into whichever viewer is active. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public void setSelectionToViewer(Collection<?> collection) + { + final Collection<?> theSelection = collection; + // Make sure it's okay. + // + if (theSelection != null && !theSelection.isEmpty()) + { + // I don't know if this should be run this deferred + // because we might have to give the editor a chance to process the viewer + // update events + // and hence to update the views first. + // + // + 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); + } + } + }; + runnable.run(); + } + } + + /** + * This returns the editing domain as required by the + * {@link IEditingDomainProvider} interface. This is important for + * implementing the static methods of {@link AdapterFactoryEditingDomain} and + * for supporting {@link org.eclipse.emf.edit.ui.action.CommandAction}. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public EditingDomain getEditingDomain() + { + return editingDomain; + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public class ReverseAdapterFactoryContentProvider extends AdapterFactoryContentProvider + { + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public ReverseAdapterFactoryContentProvider(AdapterFactory adapterFactory) + { + super(adapterFactory); + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @Override + public Object[] getElements(Object object) + { + Object parent = super.getParent(object); + return (parent == null ? Collections.EMPTY_SET : Collections.singleton(parent)).toArray(); + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @Override + public Object[] getChildren(Object object) + { + Object parent = super.getParent(object); + return (parent == null ? Collections.EMPTY_SET : Collections.singleton(parent)).toArray(); + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @Override + public boolean hasChildren(Object object) + { + Object parent = super.getParent(object); + return parent != null; + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @Override + public Object getParent(Object object) + { + return null; + } + } + + /** + * This makes sure that one content viewer, either for the current page or the + * outline view, if it has focus, is the current one. <!-- begin-user-doc --> + * <!-- end-user-doc --> + * + * @generated + */ + 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()); + } + } + + /** + * This returns the viewer as required by the {@link IViewerProvider} + * interface. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public Viewer getViewer() + { + return currentViewer; + } + + /** + * This creates a context menu for the viewer and adds a listener as well + * registering the menu for extension. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + 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, 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)); + } + + /** + * @ADDED + */ + public CDOAdapter getAdapter() + { + return adapter; + } + + /** + * This is the method called to load a resource into the editing domain's + * resource set based on the editor's input. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated NOT + */ + public void createModel() + { + // Assumes that the input is a file object. + // + CDOEditorInput input = (CDOEditorInput)getEditorInput(); + URI resourceURI = CDOUtil.createURI(input.getResourcePath()); + Exception exception = null; + + ResourceSet resourceSet = editingDomain.getResourceSet(); + Resource resource = null; + + CDOSession session = input.getSession(); + if (input.isHistorical()) + { + adapter = session.attach(resourceSet, input.getTimeStamp()); + } + else if (input.isReadOnly()) + { + adapter = session.attach(resourceSet, true); + } + else + { + adapter = session.attach(resourceSet); + } + + try + { + // Load the resource through the editing domain. + // + resource = resourceSet.getResource(resourceURI, true); + } + catch (Exception e) + { + exception = e; + resource = resourceSet.getResource(resourceURI, false); + } + + Diagnostic diagnostic = analyzeResourceProblems(resource, exception); + if (diagnostic.getSeverity() != Diagnostic.OK) + { + resourceToDiagnosticMap.put(resource, analyzeResourceProblems(resource, exception)); + } + + resourceSet.eAdapters().add(problemIndicationAdapter); + } + + /** + * Returns a dignostic describing the errors and warnings listed in the + * resource and the specified exception (if any). <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + public Diagnostic analyzeResourceProblems(Resource resource, Exception exception) + { + if (!resource.getErrors().isEmpty() || !resource.getWarnings().isEmpty()) + { + BasicDiagnostic basicDiagnostic = new BasicDiagnostic(Diagnostic.ERROR, "org.eclipse.emf.cdo.ui.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.eclipse.emf.cdo.ui.editor", 0, getString( + "_UI_CreateModelError_message", resource.getURI()), new Object[] { exception }); + } + else + { + return Diagnostic.OK_INSTANCE; + } + } + + /** + * This is the method used by the framework to install your own controls. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @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() + && !(getEditingDomain().getResourceSet().getResources().get(0)).getContents().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")); + + 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; + } + } + }); + + updateProblemIndication(); + } + + /** + * If there is just one page in the multi-page editor part, this hides the + * single tab at the bottom. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + 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); + } + } + } + + /** + * If there is more than one page in the multi-page editor part, this shows + * the tabs at the bottom. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + 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); + } + } + } + + /** + * 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 how the framework determines which interfaces we implement. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @SuppressWarnings("unchecked") + @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); + } + } + + /** + * This accesses a cached version of the content outliner. <!-- begin-user-doc + * --> <!-- end-user-doc --> + * + * @generated + */ + 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; + } + + /** + * This accesses a cached version of the property sheet. <!-- begin-user-doc + * --> <!-- end-user-doc --> + * + * @generated + */ + public IPropertySheetPage getPropertySheetPage() + { + if (propertySheetPage == null) + { + propertySheetPage = new ExtendedPropertySheetPage(editingDomain) + { + @Override + public void setSelectionToViewer(List<?> selection) + { + CDOEditor.this.setSelectionToViewer(selection); + CDOEditor.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. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + 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. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @Override + public boolean isDirty() + { + return ((BasicCommandStack)editingDomain.getCommandStack()).isSaveNeeded(); + } + + /** + * This is for implementing {@link IEditorPart} and simply saves the model + * file. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @Override + public void doSave(IProgressMonitor progressMonitor) + { + // 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 + { + savedResources.add(resource); + resource.save(Collections.EMPTY_MAP); + } + 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. + // + PluginDelegator.INSTANCE.log(exception); + } + updateProblemIndication = true; + updateProblemIndication(); + } + + /** + * This returns wether 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. <!-- begin-user-doc + * --> <!-- end-user-doc --> + * + * @generated + */ + 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. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @Override + public boolean isSaveAsAllowed() + { + return true; + } + + /** + * This also changes the editor's input. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + @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)); + } + } + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + 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); + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + 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) + { + PluginDelegator.INSTANCE.log(exception); + } + } + + /** + * This is called during startup. <!-- begin-user-doc --> <!-- end-user-doc + * --> + * + * @generated NOT + */ + @Override + public void init(IEditorSite site, IEditorInput editorInput) + { + setSite(site); + setPartName(editorInput.getName()); + site.setSelectionProvider(this); + site.getPage().addPartListener(partListener); + // ResourcesPlugin.getWorkspace().addResourceChangeListener(resourceChangeListener, + // IResourceChangeEvent.POST_CHANGE); + setInputWithNotify(editorInput); + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + @Override + public void setFocus() + { + getControl(getActivePage()).setFocus(); + } + + /** + * This implements {@link org.eclipse.jface.viewers.ISelectionProvider}. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public void addSelectionChangedListener(ISelectionChangedListener listener) + { + selectionChangedListeners.add(listener); + } + + /** + * This implements {@link org.eclipse.jface.viewers.ISelectionProvider}. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public void removeSelectionChangedListener(ISelectionChangedListener listener) + { + selectionChangedListeners.remove(listener); + } + + /** + * This implements {@link org.eclipse.jface.viewers.ISelectionProvider} to + * return this editor's overall selection. <!-- begin-user-doc --> <!-- + * end-user-doc --> + * + * @generated + */ + public ISelection getSelection() + { + return editorSelection; + } + + /** + * This implements {@link org.eclipse.jface.viewers.ISelectionProvider} to set + * this editor's overall selection. Calling this result will notify the + * listeners. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public void setSelection(ISelection selection) + { + editorSelection = selection; + + for (ISelectionChangedListener listener : selectionChangedListeners) + { + listener.selectionChanged(new SelectionChangedEvent(this, selection)); + } + setStatusLineManager(selection); + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + 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(""); + } + } + } + + /** + * This looks up a string in the plugin's plugin.properties file. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + private static String getString(String key) + { + return PluginDelegator.INSTANCE.getString(key); + } + + /** + * This looks up a string in plugin.properties, making a substitution. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + private static String getString(String key, Object s1) + { + return PluginDelegator.INSTANCE.getString(key, new Object[] { s1 }); + } + + /** + * This implements {@link org.eclipse.jface.action.IMenuListener} to help fill + * the context menus with contributions from the Edit menu. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public void menuAboutToShow(IMenuManager menuManager) + { + ((IMenuListener)getEditorSite().getActionBarContributor()).menuAboutToShow(menuManager); + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public EditingDomainActionBarContributor getActionBarContributor() + { + return (EditingDomainActionBarContributor)getEditorSite().getActionBarContributor(); + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public IActionBars getActionBars() + { + return getActionBarContributor().getActionBars(); + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public AdapterFactory getAdapterFactory() + { + return adapterFactory; + } + + /** + * <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated NOT + */ + @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(); + } + + /** + * Returns whether the outline view should be presented to the user. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + protected boolean showOutlineView() + { + return false; + } +} diff --git a/plugins/org.eclipse.emf.cdo.ui/src/org/eclipse/emf/cdo/internal/ui/editor/CDOEditorInput.java b/plugins/org.eclipse.emf.cdo.ui/src/org/eclipse/emf/cdo/internal/ui/editor/CDOEditorInput.java new file mode 100644 index 0000000000..607d0fc562 --- /dev/null +++ b/plugins/org.eclipse.emf.cdo.ui/src/org/eclipse/emf/cdo/internal/ui/editor/CDOEditorInput.java @@ -0,0 +1,132 @@ +/*************************************************************************** + * Copyright (c) 2004-2007 Eike Stepper, Germany. + * 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: + * Eike Stepper - initial API and implementation + **************************************************************************/ +package org.eclipse.emf.cdo.internal.ui.editor; + +import org.eclipse.emf.cdo.CDOSession; +import org.eclipse.emf.cdo.internal.ui.bundle.SharedIcons; + +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.ui.IEditorInput; +import org.eclipse.ui.IPersistableElement; + +import java.text.MessageFormat; + +/** + * @author Eike Stepper + */ +public class CDOEditorInput implements IEditorInput +{ + private CDOSession session; + + private String resourcePath; + + private boolean readOnly; + + private long timeStamp; + + public CDOEditorInput(CDOSession session, String resourcePath) + { + this.session = session; + this.resourcePath = resourcePath; + } + + public CDOEditorInput(CDOSession session, String resourcePath, boolean readOnly) + { + this(session, resourcePath); + this.readOnly = readOnly; + } + + public CDOEditorInput(CDOSession session, String resourcePath, long timeStamp) + { + this(session, resourcePath); + this.timeStamp = timeStamp; + } + + public CDOSession getSession() + { + return session; + } + + public String getResourcePath() + { + return resourcePath; + } + + public boolean isActual() + { + return !isHistorical() && !isReadOnly(); + } + + public boolean isHistorical() + { + return timeStamp != 0; + } + + public boolean isReadOnly() + { + return readOnly; + } + + public long getTimeStamp() + { + return timeStamp; + } + + public boolean exists() + { + return true; + } + + public ImageDescriptor getImageDescriptor() + { + if (isHistorical()) + { + return SharedIcons.getDescriptor(SharedIcons.OBJ_EDITOR_HISTORICAL); + } + + if (isReadOnly()) + { + return SharedIcons.getDescriptor(SharedIcons.OBJ_EDITOR_READONLY); + } + + return SharedIcons.getDescriptor(SharedIcons.OBJ_EDITOR); + } + + public String getName() + { + return resourcePath; + } + + public IPersistableElement getPersistable() + { + return null; + } + + public String getToolTipText() + { + if (isHistorical()) + { + return MessageFormat.format("{0} ({1,D})", resourcePath, timeStamp); + } + + if (isReadOnly()) + { + return MessageFormat.format("{0} (read only)", resourcePath); + } + + return resourcePath; + } + + public Object getAdapter(Class adapter) + { + return null; + } +} diff --git a/plugins/org.eclipse.emf.cdo.ui/src/org/eclipse/emf/cdo/internal/ui/editor/PluginDelegator.java b/plugins/org.eclipse.emf.cdo.ui/src/org/eclipse/emf/cdo/internal/ui/editor/PluginDelegator.java new file mode 100644 index 0000000000..a19965dc20 --- /dev/null +++ b/plugins/org.eclipse.emf.cdo.ui/src/org/eclipse/emf/cdo/internal/ui/editor/PluginDelegator.java @@ -0,0 +1,111 @@ +/** + * <copyright> + * </copyright> + * + * $Id$ + */ +package org.eclipse.emf.cdo.internal.ui.editor; + +import org.eclipse.emf.cdo.internal.ui.bundle.CDOUI; + +import org.eclipse.emf.common.EMFPlugin; +import org.eclipse.emf.common.ui.EclipseUIPlugin; +import org.eclipse.emf.common.util.ResourceLocator; + +/** + * This is the central singleton for the Editor editor plugin. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ +public final class PluginDelegator extends EMFPlugin +{ + /** + * Keep track of the singleton. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public static final PluginDelegator INSTANCE = new PluginDelegator(); + + /** + * Keep track of the singleton. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + private static Implementation plugin; + + /** + * Create the instance. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public PluginDelegator() + { + super(new ResourceLocator[] {}); + } + + /** + * @ADDED + */ + @Override + public void log(Object logEntry) + { + if (logEntry instanceof Throwable) + { + CDOUI.LOG.error((Throwable)logEntry); + } + else + { + CDOUI.LOG.info(logEntry.toString()); + } + } + + /** + * Returns the singleton instance of the Eclipse plugin. <!-- begin-user-doc + * --> <!-- end-user-doc --> + * + * @return the singleton instance. + * @generated + */ + @Override + public ResourceLocator getPluginResourceLocator() + { + return plugin; + } + + /** + * Returns the singleton instance of the Eclipse plugin. <!-- begin-user-doc + * --> <!-- end-user-doc --> + * + * @return the singleton instance. + * @generated + */ + public static Implementation getPlugin() + { + return plugin; + } + + /** + * The actual implementation of the Eclipse <b>Plugin</b>. <!-- + * begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public static class Implementation extends EclipseUIPlugin + { + /** + * Creates an instance. <!-- begin-user-doc --> <!-- end-user-doc --> + * + * @generated + */ + public Implementation() + { + super(); + + // Remember the static instance. + // + plugin = this; + } + } + +} |
