| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2006 IBM Corporation and others. |
| // All rights reserved. This program and the accompanying materials |
| // are made available under the terms of the Eclipse Public License v1.0 |
| // which accompanies this distribution, and is available at |
| // http://www.eclipse.org/legal/epl-v10.html |
| // |
| // Contributors: |
| // IBM Corporation - initial implementation |
| //------------------------------------------------------------------------------ |
| package org.eclipse.epf.authoring.ui.editors; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.MultiStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.Resource.Diagnostic; |
| import org.eclipse.epf.authoring.ui.AuthoringUIPlugin; |
| import org.eclipse.epf.authoring.ui.AuthoringUIResources; |
| import org.eclipse.epf.authoring.ui.views.ViewHelper; |
| import org.eclipse.epf.common.ui.util.MsgDialog; |
| import org.eclipse.epf.diagram.core.part.DiagramEditorInput; |
| import org.eclipse.epf.diagram.core.part.DiagramEditorInputProxy; |
| import org.eclipse.epf.library.LibraryPlugin; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.library.util.LibraryUtil; |
| import org.eclipse.epf.ui.editors.IMethodEditor; |
| import org.eclipse.epf.uma.BreakdownElement; |
| import org.eclipse.epf.uma.ContentPackage; |
| import org.eclipse.epf.uma.CustomCategory; |
| import org.eclipse.epf.uma.DescribableElement; |
| import org.eclipse.epf.uma.Discipline; |
| import org.eclipse.epf.uma.DisciplineGrouping; |
| import org.eclipse.epf.uma.Domain; |
| import org.eclipse.epf.uma.Guidance; |
| import org.eclipse.epf.uma.MethodConfiguration; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.MethodLibrary; |
| import org.eclipse.epf.uma.MethodPlugin; |
| import org.eclipse.epf.uma.Process; |
| import org.eclipse.epf.uma.ProcessComponent; |
| import org.eclipse.epf.uma.Role; |
| import org.eclipse.epf.uma.RoleSet; |
| import org.eclipse.epf.uma.RoleSetGrouping; |
| import org.eclipse.epf.uma.Task; |
| import org.eclipse.epf.uma.Tool; |
| import org.eclipse.epf.uma.WorkProduct; |
| import org.eclipse.epf.uma.WorkProductType; |
| import org.eclipse.epf.uma.util.UmaUtil; |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| |
| /** |
| * Launches a Method editor that is appropriate for a given method element. |
| * |
| * @author Shilpa Toraskar |
| * @author Kelvin Low |
| * @since 1.0 |
| */ |
| public class EditorChooser implements IEditorKeeper { |
| |
| private static EditorChooser singleton = null; |
| |
| /** |
| * Returns a singleton instance |
| * |
| */ |
| public static EditorChooser getInstance() { |
| if (singleton == null) { |
| synchronized (EditorChooser.class) { |
| if (singleton == null) { |
| singleton = new EditorChooser(); |
| IEditorKeeper.REFERENCE.setEditorKeeper(singleton); |
| } |
| } |
| } |
| return singleton; |
| } |
| |
| public EditorChooser() { |
| |
| } |
| |
| |
| /** |
| * Opens the respective editor depending on the given Method element object. |
| * |
| * @param obj |
| * A Method element. |
| */ |
| public void openEditor(Object obj) { |
| try { |
| obj = ViewHelper.handleDangling(obj); |
| if (obj == null) |
| return; |
| |
| obj = LibraryUtil.unwrap(obj); |
| |
| ArrayList errors = new ArrayList(); |
| if (obj instanceof EObject) { |
| Resource res = ((EObject) obj).eResource(); |
| if (res != null && !res.getErrors().isEmpty()) { |
| errors.addAll(res.getErrors()); |
| } |
| if (obj instanceof DescribableElement) { |
| Resource presRes = ((DescribableElement) obj) |
| .getPresentation().eResource(); |
| if (presRes != null && !presRes.getErrors().isEmpty()) { |
| errors.addAll(presRes.getErrors()); |
| } |
| } |
| if (!errors.isEmpty()) { |
| final MultiStatus multiStatus = new MultiStatus( |
| AuthoringUIPlugin.getDefault().getId(), |
| 0, |
| AuthoringUIResources.EditorChooser_ResourcesError, null); |
| for (Iterator iter = errors.iterator(); iter.hasNext();) { |
| Diagnostic e = (Diagnostic) iter.next(); |
| IStatus status = new Status(IStatus.WARNING, |
| LibraryPlugin.getDefault().getId(), 0, e |
| .getMessage(), null); |
| multiStatus.add(status); |
| } |
| try { |
| if (AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayConfirmation( |
| AuthoringUIResources.EditorChooser_loaddErrorDlgTitle, |
| AuthoringUIResources.EditorChooser_ResourcesError, |
| multiStatus) == Dialog.CANCEL) { |
| return; |
| } |
| |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| } |
| |
| EditorOpener opener = EditorOpenerFactory.getInstance().getOpener(obj); |
| if ( opener != null && opener.canOpen(obj) ) { |
| opener.openEditor(obj); |
| } else if ((obj instanceof MethodPlugin) |
| || (obj instanceof ContentPackage) || (obj instanceof Role) |
| || (obj instanceof Task) || (obj instanceof WorkProduct) |
| || (obj instanceof Guidance) || (obj instanceof Discipline) |
| || (obj instanceof DisciplineGrouping) |
| || (obj instanceof Domain) |
| || (obj instanceof WorkProductType) |
| || (obj instanceof RoleSet) || (obj instanceof Tool) |
| || (obj instanceof RoleSetGrouping) |
| || (obj instanceof MethodLibrary)) { |
| openEditor((MethodElement) obj, MethodElementEditor.EDITOR_ID); |
| } else if (obj instanceof CustomCategory) { |
| CustomCategory custCat = (CustomCategory) obj; |
| if(TngUtil.isRootCustomCategory(custCat)) { |
| return; |
| } |
| openEditor((MethodElement) obj, MethodElementEditor.EDITOR_ID); |
| } else if (obj instanceof ProcessComponent) { |
| openEditor((MethodElement) obj, ProcessEditor.EDITOR_ID); |
| |
| // open properties view by default when we open Process Editor |
| try { |
| PlatformUI.getWorkbench().getActiveWorkbenchWindow() |
| .getActivePage().showView( |
| "org.eclipse.ui.views.PropertySheet", null, IWorkbenchPage.VIEW_VISIBLE); //$NON-NLS-1$ |
| } catch (PartInitException exception) { |
| AuthoringUIPlugin.getDefault().getLogger().logError( |
| exception); |
| } |
| } else if (obj instanceof Process) { |
| Object container = ((Process) obj).eContainer(); |
| if (container instanceof ProcessComponent) { |
| openEditor((MethodElement) container, |
| ProcessEditor.EDITOR_ID); |
| } |
| }else if (obj instanceof MethodConfiguration) { |
| openEditor((MethodConfiguration) obj, |
| ConfigurationEditor.EDITOR_ID); |
| }else if(obj instanceof BreakdownElement){ |
| Process process = TngUtil.getOwningProcess((BreakdownElement)obj); |
| Object container = process.eContainer(); |
| if (container instanceof ProcessComponent) { |
| openEditor((MethodElement) container, |
| ProcessEditor.EDITOR_ID); |
| } |
| } |
| } catch (Throwable t) { |
| t.printStackTrace(); |
| String title = AuthoringUIResources.editors_EditorChooser_systemErrorDialog_title; |
| String message = AuthoringUIResources.editors_EditorChooser_systemErrorDialog_message; |
| String reason = AuthoringUIResources.editors_EditorChooser_systemErrorDialog_reason; |
| MsgDialog dialog = AuthoringUIPlugin.getDefault().getMsgDialog(); |
| dialog.displayError(title, message, reason, t); |
| } |
| } |
| |
| /** |
| * Opens the Configuration editor. |
| * |
| * @param config |
| * @param editorId |
| */ |
| private void openEditor(MethodConfiguration config, String editorId) |
| throws PartInitException { |
| ConfigurationEditorInput editorInput = new ConfigurationEditorInput( |
| config); |
| AuthoringUIPlugin.getDefault().getWorkbench() |
| .getActiveWorkbenchWindow().getActivePage().openEditor( |
| editorInput, editorId); |
| } |
| |
| /** |
| * Opens the Method editor for the given method element. |
| * |
| * @param element |
| * A Method element. |
| * @param editorId |
| * The editor ID. |
| */ |
| private void openEditor(MethodElement element, String editorId) |
| throws PartInitException { |
| MethodElementEditorInput editorInput = new MethodElementEditorInput( |
| element); |
| AuthoringUIPlugin.getDefault().getWorkbench() |
| .getActiveWorkbenchWindow().getActivePage().openEditor( |
| editorInput, editorId); |
| } |
| |
| /** |
| * Selects (brings to front, but does not give focus) the Method editor for |
| * the given object. If there is no open editor for the object, does |
| * nothing. |
| * |
| * @param obj |
| */ |
| public void selectEditor(Object obj) { |
| try { |
| obj = ViewHelper.handleDangling(obj); |
| if (obj == null) |
| return; |
| obj = LibraryUtil.unwrap(obj); |
| } catch (Throwable t) { |
| t.printStackTrace(); |
| } |
| IEditorInput editorInput = null; |
| if (obj instanceof MethodConfiguration) |
| editorInput = new ConfigurationEditorInput( |
| (MethodConfiguration) obj); |
| else if (obj instanceof MethodElement) |
| editorInput = new MethodElementEditorInput((MethodElement) obj); |
| if (editorInput != null) { |
| IWorkbenchPage page = AuthoringUIPlugin.getDefault().getWorkbench() |
| .getActiveWorkbenchWindow().getActivePage(); |
| IEditorPart editorPart = page.findEditor(editorInput); |
| if (editorPart != null) |
| page.bringToTop(editorPart); |
| } |
| } |
| |
| /** |
| * |
| * Returns selected editor input |
| * @return The object which the currently selected Method editor is editing (or |
| * null if there is no editor or if the editor is not a Method editor). |
| */ |
| public Object getActiveMethodEditorInput() { |
| IEditorPart editorPart = AuthoringUIPlugin.getDefault().getWorkbench() |
| .getActiveWorkbenchWindow().getActivePage().getActiveEditor(); |
| return getMethodEditorInput(editorPart); |
| } |
| |
| public Object getMethodEditorInput(IEditorPart editorPart) { |
| if (editorPart != null) { |
| IEditorInput editorInput = editorPart.getEditorInput(); |
| if (editorInput instanceof ConfigurationEditorInput) |
| return ((ConfigurationEditorInput) editorInput) |
| .getConfiguration(); |
| if (editorInput instanceof MethodElementEditorInput) |
| return ((MethodElementEditorInput) editorInput) |
| .getMethodElement(); |
| } |
| return null; |
| } |
| |
| /** |
| * Closes the Method editor for the given Method element. |
| * |
| * @param obj |
| * A Method element. |
| */ |
| public void closeEditor(Object obj) { |
| try { |
| IEditorPart editor = findEditor(obj); |
| if (editor != null) { |
| AuthoringUIPlugin.getDefault().getWorkbench() |
| .getActiveWorkbenchWindow().getActivePage() |
| .closeEditor(editor, false); |
| } |
| } catch (NullPointerException e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| |
| public IEditorPart findEditor(Object obj) { |
| try { |
| MethodElementEditorInput editorInput = new MethodElementEditorInput( |
| (MethodElement) obj); |
| IEditorPart editor = AuthoringUIPlugin.getDefault().getWorkbench() |
| .getActiveWorkbenchWindow().getActivePage().findEditor( |
| editorInput); |
| return editor; |
| } catch (NullPointerException e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns list of dirty editors for the given elements |
| * @param elements |
| * @return List of dirty editor |
| */ |
| public Collection getElementsWithDirtyEditor(Collection elements) { |
| ArrayList result = new ArrayList(); |
| |
| IWorkbenchPage workbenchPage = AuthoringUIPlugin.getDefault() |
| .getWorkbench().getActiveWorkbenchWindow().getActivePage(); |
| IEditorReference[] editorReferences = workbenchPage |
| .getEditorReferences(); |
| // ArrayList closeEditorRefs = new ArrayList(); |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor != null && editor.isDirty()) { |
| IEditorInput input = editor.getEditorInput(); |
| MethodElement element = null; |
| if (input instanceof MethodElementEditorInput) { |
| element = ((MethodElementEditorInput) input) |
| .getMethodElement(); |
| } else if (input instanceof ConfigurationEditorInput) { |
| element = ((ConfigurationEditorInput) input) |
| .getConfiguration(); |
| } |
| if (element != null) { |
| for (Iterator iter = elements.iterator(); iter.hasNext();) { |
| Object e = iter.next(); |
| if (e == element || UmaUtil.isContainedBy(element, e)) { |
| result.add(element); |
| iter.remove(); |
| } |
| } |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Closes the all open Method editors ofor the given (deleted) element and |
| * all of its children and grand children. |
| * |
| * @param e |
| * the deleted MethodElement |
| */ |
| public void closeEditorsOnDeletion(Object e) { |
| IWorkbenchPage workbenchPage = AuthoringUIPlugin.getDefault() |
| .getWorkbench().getActiveWorkbenchWindow().getActivePage(); |
| IEditorReference[] editorReferences = workbenchPage |
| .getEditorReferences(); |
| ArrayList closeEditorRefs = new ArrayList(); |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor != null) { |
| IEditorInput input = editor.getEditorInput(); |
| MethodElement element = null; |
| if (input instanceof MethodElementEditorInput) { |
| element = ((MethodElementEditorInput) input) |
| .getMethodElement(); |
| } else if (input instanceof ConfigurationEditorInput) { |
| element = ((ConfigurationEditorInput) input) |
| .getConfiguration(); |
| } |
| if (element != null |
| && (element.eContainer() == null || UmaUtil |
| .isContainedBy(element, e))) { |
| closeEditorRefs.add(reference); |
| } |
| } |
| } |
| int size = closeEditorRefs.size(); |
| IEditorReference[] references = new IEditorReference[size]; |
| for (int i = 0; i < size; i++) { |
| references[i] = (IEditorReference) closeEditorRefs.get(i); |
| } |
| workbenchPage.closeEditors(references, false); |
| } |
| |
| /** |
| * Closes all Method Editors without saving. |
| * |
| */ |
| public void closeAllMethodEditors() { |
| closeAllMethodEditors(false); |
| } |
| |
| public void closeAllMethodEditors(boolean saveFlag) { |
| final IWorkbench workbench = PlatformUI.getWorkbench(); |
| final boolean save = saveFlag; |
| workbench.getDisplay().asyncExec(new Runnable() { |
| public void run() { |
| IWorkbenchWindow window = workbench.getActiveWorkbenchWindow(); |
| if (window != null) { |
| IWorkbenchPage workbenchPage = window.getActivePage(); |
| List<IEditorReference> closeEditorRefs = getOpenMethodEditors(); |
| workbenchPage.closeEditors(closeEditorRefs.toArray(new IEditorReference[closeEditorRefs.size()]), save); |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Closes all Method Editors with saving. |
| * |
| */ |
| public void closeAllMethodEditorsWithSaving() { |
| closeAllMethodEditors(true); |
| } |
| |
| /** |
| * @return a list of all open Method Editors |
| */ |
| public List<IEditorReference> getOpenMethodEditors() { |
| final IWorkbench workbench = PlatformUI.getWorkbench(); |
| final List<IEditorReference> methodEditorRefs = new ArrayList<IEditorReference>(); |
| workbench.getDisplay().syncExec(new Runnable() { |
| public void run() { |
| IWorkbenchWindow window = workbench.getActiveWorkbenchWindow(); |
| if (window != null) { |
| IWorkbenchPage workbenchPage = window.getActivePage(); |
| IEditorReference[] editorReferences = workbenchPage.getEditorReferences(); |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editorPart = reference.getEditor(false); |
| String editorId = reference.getId(); |
| if (editorId.startsWith("org.eclipse.epf") || //$NON-NLS-1$ |
| editorPart instanceof IMethodEditor) { |
| methodEditorRefs.add(reference); |
| } |
| } |
| } |
| } |
| }); |
| return methodEditorRefs; |
| } |
| |
| |
| /** |
| * Close all MethodEditors associated with the given Plugin. |
| * Will cause a user-prompt for each dirty editor |
| * |
| */ |
| public void closeMethodEditorsForPluginElements(MethodPlugin methodplugin) { |
| if (AuthoringUIPlugin.getDefault().getWorkbench() |
| .getActiveWorkbenchWindow() != null |
| && AuthoringUIPlugin.getDefault().getWorkbench() |
| .getActiveWorkbenchWindow().getActivePage() != null) { |
| IWorkbenchPage workbenchPage = AuthoringUIPlugin.getDefault() |
| .getWorkbench().getActiveWorkbenchWindow().getActivePage(); |
| List<IEditorReference> list = getOpenMethodEditors(); |
| List<IEditorReference> editorRefsToClose = new ArrayList<IEditorReference>(); |
| for (IEditorReference editorReference : list) { |
| IEditorPart editor = editorReference.getEditor(true); |
| if (editor != null) { |
| IEditorInput input = editor.getEditorInput(); |
| MethodElement element = null; |
| if (input instanceof MethodElementEditorInput) { |
| element = ((MethodElementEditorInput) input) |
| .getMethodElement(); |
| } else if (input instanceof ConfigurationEditorInput) { |
| element = ((ConfigurationEditorInput) input) |
| .getConfiguration(); |
| } else if(input instanceof DiagramEditorInputProxy){ |
| DiagramEditorInput eInput = ((DiagramEditorInputProxy)input).getDiagramEditorInput(); |
| element = eInput.getMethodElement(); |
| if(element == null){ |
| if(eInput.getWrapper() != null){ |
| element = (MethodElement)TngUtil.unwrap(eInput.getWrapper()); |
| } |
| } |
| } |
| if (element != null |
| && (element.eContainer() == null || UmaUtil |
| .isContainedBy(element, methodplugin))) { |
| if (!element.equals(methodplugin)) |
| editorRefsToClose.add(editorReference); |
| } |
| } |
| } |
| workbenchPage.closeEditors(editorRefsToClose.toArray(new IEditorReference[editorRefsToClose.size()]), true); |
| } |
| } |
| |
| public void closeEditors(Object e, boolean promptSave) { |
| IWorkbenchPage workbenchPage = AuthoringUIPlugin.getDefault() |
| .getWorkbench().getActiveWorkbenchWindow().getActivePage(); |
| IEditorReference[] editorReferences = workbenchPage |
| .getEditorReferences(); |
| ArrayList<IEditorReference> closeEditorRefs = new ArrayList<IEditorReference>(); |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor != null) { |
| IEditorInput input = editor.getEditorInput(); |
| MethodElement element = null; |
| if (input instanceof MethodElementEditorInput) { |
| element = ((MethodElementEditorInput) input) |
| .getMethodElement(); |
| } else if (input instanceof ConfigurationEditorInput) { |
| element = ((ConfigurationEditorInput) input) |
| .getConfiguration(); |
| } |
| if (element != null && (element == e || UmaUtil.isContainedBy(element, e))) { |
| closeEditorRefs.add(reference); |
| } |
| } |
| } |
| int size = closeEditorRefs.size(); |
| IEditorReference[] references = new IEditorReference[size]; |
| for (int i = 0; i < size; i++) { |
| references[i] = (IEditorReference) closeEditorRefs.get(i); |
| } |
| workbenchPage.closeEditors(references, promptSave); |
| } |
| |
| } |