| //------------------------------------------------------------------------------ |
| // 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.views; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.lang.reflect.InvocationTargetException; |
| import java.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.EventObject; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.emf.common.CommonPlugin; |
| 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.ui.viewer.IViewerProvider; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.common.util.WrappedException; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.emf.edit.domain.EditingDomain; |
| import org.eclipse.emf.edit.provider.ITreeItemContentProvider; |
| import org.eclipse.emf.edit.provider.ItemProviderAdapter; |
| import org.eclipse.emf.edit.ui.action.CopyAction; |
| import org.eclipse.emf.edit.ui.action.CutAction; |
| import org.eclipse.emf.edit.ui.action.DeleteAction; |
| import org.eclipse.emf.edit.ui.action.PasteAction; |
| import org.eclipse.emf.edit.ui.dnd.LocalTransfer; |
| import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider; |
| import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider; |
| import org.eclipse.epf.authoring.ui.AuthoringUIHelpContexts; |
| import org.eclipse.epf.authoring.ui.AuthoringUIPlugin; |
| import org.eclipse.epf.authoring.ui.AuthoringUIResources; |
| import org.eclipse.epf.authoring.ui.UIActionDispatcher; |
| import org.eclipse.epf.authoring.ui.actions.ILibraryActionBarContributor; |
| import org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor; |
| import org.eclipse.epf.authoring.ui.actions.LibraryViewCopyAction; |
| import org.eclipse.epf.authoring.ui.actions.LibraryViewCutAction; |
| import org.eclipse.epf.authoring.ui.actions.LibraryViewDeleteAction; |
| import org.eclipse.epf.authoring.ui.actions.LibraryViewPasteAction; |
| import org.eclipse.epf.authoring.ui.actions.NewPluginAction; |
| import org.eclipse.epf.authoring.ui.dialogs.MoveDialog; |
| import org.eclipse.epf.authoring.ui.dialogs.VariabilitySelection; |
| import org.eclipse.epf.authoring.ui.dnd.LibraryViewerDragAdapter; |
| import org.eclipse.epf.authoring.ui.editors.AbstractDiagramEditor; |
| import org.eclipse.epf.authoring.ui.editors.BreakdownElementEditorInput; |
| import org.eclipse.epf.authoring.ui.editors.EditorChooser; |
| import org.eclipse.epf.authoring.ui.editors.MethodElementEditor; |
| import org.eclipse.epf.authoring.ui.editors.MethodElementEditorInput; |
| import org.eclipse.epf.authoring.ui.providers.MethodElementLabelDecorator; |
| import org.eclipse.epf.common.serviceability.MsgBox; |
| import org.eclipse.epf.library.ILibraryManager; |
| import org.eclipse.epf.library.LibraryService; |
| import org.eclipse.epf.library.LibraryServiceUtil; |
| import org.eclipse.epf.library.edit.TngAdapterFactory; |
| import org.eclipse.epf.library.edit.ui.UserInteractionHelper; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.library.edit.validation.IValidator; |
| import org.eclipse.epf.library.edit.validation.IValidatorFactory; |
| import org.eclipse.epf.library.services.LibraryProcessor; |
| import org.eclipse.epf.library.ui.LibraryUIManager; |
| import org.eclipse.epf.library.ui.LibraryUIUtil; |
| import org.eclipse.epf.library.ui.actions.ConfigurationContributionItem; |
| import org.eclipse.epf.library.ui.dialogs.SwitchConfigDialog; |
| import org.eclipse.epf.library.ui.preferences.LibraryUIPreferences; |
| import org.eclipse.epf.library.util.ImportExportUtil; |
| import org.eclipse.epf.persistence.FileManager; |
| import org.eclipse.epf.persistence.MultiFileResourceSetImpl; |
| import org.eclipse.epf.persistence.MultiFileXMIResourceImpl; |
| import org.eclipse.epf.persistence.refresh.IRefreshHandler; |
| import org.eclipse.epf.persistence.refresh.RefreshJob; |
| import org.eclipse.epf.persistence.util.PersistenceUtil; |
| import org.eclipse.epf.uma.CapabilityPattern; |
| import org.eclipse.epf.uma.ContentCategory; |
| import org.eclipse.epf.uma.ContentDescription; |
| import org.eclipse.epf.uma.ContentElement; |
| import org.eclipse.epf.uma.ContentPackage; |
| import org.eclipse.epf.uma.CustomCategory; |
| import org.eclipse.epf.uma.DeliveryProcess; |
| 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.NamedElement; |
| import org.eclipse.epf.uma.Process; |
| import org.eclipse.epf.uma.ProcessComponent; |
| import org.eclipse.epf.uma.ProcessPackage; |
| import org.eclipse.epf.uma.VariabilityElement; |
| import org.eclipse.epf.uma.edit.domain.TraceableAdapterFactoryEditingDomain; |
| import org.eclipse.epf.uma.util.ContentDescriptionFactory; |
| import org.eclipse.epf.uma.util.IMethodLibraryPersister; |
| import org.eclipse.epf.uma.util.MessageException; |
| import org.eclipse.epf.uma.util.UmaUtil; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.ActionContributionItem; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.IStatusLineManager; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.dialogs.IInputValidator; |
| import org.eclipse.jface.dialogs.InputDialog; |
| import org.eclipse.jface.dialogs.ProgressMonitorDialog; |
| import org.eclipse.jface.operation.IRunnableContext; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.viewers.DecoratingLabelProvider; |
| import org.eclipse.jface.viewers.DoubleClickEvent; |
| import org.eclipse.jface.viewers.IDoubleClickListener; |
| import org.eclipse.jface.viewers.ILabelDecorator; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.IStructuredContentProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.viewers.LabelProviderChangedEvent; |
| 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.jface.window.Window; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.dnd.DND; |
| import org.eclipse.swt.dnd.HTMLTransfer; |
| import org.eclipse.swt.dnd.Transfer; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.DirectoryDialog; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IPartListener; |
| import org.eclipse.ui.IPropertyListener; |
| import org.eclipse.ui.IViewSite; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.actions.WorkspaceModifyOperation; |
| import org.eclipse.ui.dialogs.ListSelectionDialog; |
| import org.eclipse.ui.views.navigator.ResourceNavigator; |
| |
| /** |
| * The Library view. |
| * <p> |
| * Displays the physical representation of a Method Library. |
| * |
| * @author Phong Nguyen Le |
| * @author Shilpa Toraskar |
| * @author Kelvin Low |
| * @since 1.0 |
| */ |
| public class LibraryView extends AbstractBaseView implements IRefreshHandler { |
| |
| /** |
| * The view ID. |
| */ |
| public static final String VIEW_ID = LibraryView.class.getName(); |
| |
| protected TreeViewer treeViewer; |
| |
| protected IDoubleClickListener doubleClickListener = null; |
| |
| private ISelection selection; |
| |
| // Listen to process editor activation and prompt the user to load the |
| // the process's default Configuration into the Configuration view. |
| private IPartListener editorPartListener = new IPartListener() { |
| |
| public void partOpened(IWorkbenchPart part) { |
| } |
| |
| public void partDeactivated(IWorkbenchPart part) { |
| } |
| |
| public void partClosed(IWorkbenchPart part) { |
| } |
| |
| public void partBroughtToTop(IWorkbenchPart part) { |
| } |
| |
| public void partActivated(IWorkbenchPart part) { |
| if (part instanceof IEditorPart) { |
| Object obj = null; |
| if (part instanceof AbstractDiagramEditor) { |
| BreakdownElementEditorInput input = (BreakdownElementEditorInput) ((IEditorPart) part) |
| .getEditorInput(); |
| if (input.getSuppression().getProcess() != null) { |
| obj = input.getSuppression().getProcess().eContainer(); |
| } |
| } else { |
| obj = EditorChooser.getInstance().getSelectedEditorInput(); |
| } |
| if (obj != null && obj instanceof ProcessComponent) { |
| SwitchConfigDialog dialog = new SwitchConfigDialog(Display |
| .getCurrent().getActiveShell(), |
| ((ProcessComponent) obj).getProcess() |
| .getDefaultContext()); |
| dialog.execute(); |
| } |
| } |
| } |
| |
| }; |
| |
| private long lastRefreshTimeStamp; |
| |
| /** |
| * Creates a new instance. |
| */ |
| public LibraryView() { |
| } |
| |
| /** |
| * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(Composite) |
| */ |
| public void createPartControl(Composite parent) { |
| super.createPartControl(parent); |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(parent, |
| AuthoringUIHelpContexts.LIBRARY_NAVIGATOR_VIEW_CONTEXT); |
| |
| RefreshJob.getInstance().setRefreshHandler(this); |
| } |
| |
| /** |
| * @see org.eclipse.ui.part.WorkbenchPart#setFocus() |
| */ |
| public void setFocus() { |
| // This is required to make the global edit action work the first time. |
| actionBarContributor.setActiveView(this); |
| |
| IStructuredSelection selected = (IStructuredSelection) getSelection(); |
| if (selected.isEmpty()) |
| actionBarContributor.disableGlobalEditMenu(); |
| else |
| actionBarContributor.enableGlobalEditMenu(); |
| |
| if (treeViewer != null) { |
| treeViewer.getControl().setFocus(); |
| } |
| } |
| |
| /** |
| * Returns the underlying tree viewer. |
| */ |
| public Viewer getViewer() { |
| return treeViewer; |
| } |
| |
| /** |
| * Creates the underlying tree viewer. |
| */ |
| public void createViewer(Composite parent) { |
| treeViewer = new TreeViewer(parent) { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.StructuredViewer#handleLabelProviderChanged(org.eclipse.jface.viewers.LabelProviderChangedEvent) |
| */ |
| protected void handleLabelProviderChanged( |
| LabelProviderChangedEvent event) { |
| if (event.getElement() instanceof IResource |
| && event.getSource() instanceof ILabelDecorator) { |
| this.refresh(); |
| return; |
| } |
| super.handleLabelProviderChanged(event); |
| } |
| }; |
| |
| adapterFactory = TngAdapterFactory.INSTANCE |
| .getNavigatorView_ComposedAdapterFactory(); |
| |
| // 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) { |
| Runnable runnable = 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() != null |
| && !propertySheetPage.getControl().isDisposed() |
| && propertySheetPage.getControl().isVisible()) { |
| propertySheetPage.refresh(); |
| } |
| } |
| }; |
| if (Display.getCurrent() != null) { |
| Display.getCurrent().asyncExec(runnable); |
| } else { |
| runnable.run(); |
| } |
| } |
| }); |
| |
| // Create the editing domain with a special command stack. |
| ResourceSet resourceSet = new MultiFileResourceSetImpl(); |
| editingDomain = new TraceableAdapterFactoryEditingDomain( |
| adapterFactory, commandStack, resourceSet); |
| |
| // Register the editing domain with the library processor to enable |
| // monitor edit changes in the tree. |
| LibraryProcessor.getInstance().registerEditingDomain(editingDomain); |
| |
| LibraryProcessor.getInstance().addPropertyListener( |
| new IPropertyListener() { |
| public void propertyChanged(Object source, int propId) { |
| if (propId == LibraryProcessor.PROP_DIRTY) { |
| firePropertyChange(PROP_DIRTY); |
| } |
| } |
| }); |
| |
| treeViewer.setContentProvider(new AdapterFactoryContentProvider( |
| adapterFactory)); |
| |
| // treeViewer.setLabelProvider(new |
| // AdapterFactoryLabelProvider(adapterFactory)); |
| treeViewer.setLabelProvider(new DecoratingLabelProvider( |
| new AdapterFactoryLabelProvider(adapterFactory), |
| new MethodElementLabelDecorator())); |
| |
| // Add a double click listener for launching the Method editors. |
| doubleClickListener = new IDoubleClickListener() { |
| public void doubleClick(DoubleClickEvent event) { |
| UIActionDispatcher.getInstance().handleDoubleClickEvent(event); |
| } |
| }; |
| treeViewer.addDoubleClickListener(doubleClickListener); |
| |
| getSite().getPage().addPartListener(editorPartListener); |
| |
| createContextMenuFor(treeViewer); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.views.AbstractBaseView#setInputForViewer(Object) |
| */ |
| public void setInputForViewer(Object model) { |
| Control ctrl = this.getViewer().getControl(); |
| if (ctrl.isDisposed()) { |
| return; |
| } |
| if (model == null || model instanceof MethodLibrary) { |
| // Prevent memory leak. |
| StructuredSelection emptySelection = new StructuredSelection(); |
| actionDispatcher.setSelection(emptySelection); |
| UIActionDispatcher.getInstance().setSelection(emptySelection); |
| |
| getViewer().setInput(model); |
| updateLastRefreshTimestamp(); |
| } else { |
| AuthoringUIPlugin |
| .getDefault() |
| .getLogger() |
| .logError( |
| "Library viewer input is not a MethodLibrary object: " + model); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * |
| */ |
| private void updateLastRefreshTimestamp() { |
| lastRefreshTimeStamp = System.currentTimeMillis(); |
| } |
| |
| /** |
| * Returns this view. |
| */ |
| public static LibraryView getView() { |
| return (LibraryView) ViewHelper.openView(VIEW_ID); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.views.AbstractBaseView#setSelection(ISelection) |
| */ |
| public void setSelection(ISelection selection) { |
| ((LibraryViewActionBarContributor) actionBarContributor) |
| .updateSelection(selection); |
| |
| super.setSelection(selection); |
| this.selection = selection; |
| |
| // if only one element is selected, show path to its file in status line |
| // |
| IStatusLineManager statusLineManager = getViewSite().getActionBars() |
| .getStatusLineManager(); |
| if (statusLineManager != null) { |
| String path = ""; //$NON-NLS-1$ |
| if (selection instanceof IStructuredSelection) { |
| IStructuredSelection structuredSelection = (IStructuredSelection) selection; |
| if (structuredSelection.size() == 1) { |
| Object o = TngUtil.unwrap(structuredSelection |
| .getFirstElement()); |
| if (o instanceof EObject) { |
| Resource resource = ((EObject) o).eResource(); |
| if (resource != null) { |
| URI uri = resource.getURI(); |
| if (uri != null) { |
| path = uri.toFileString(); |
| if (o instanceof ContentElement) { |
| ContentDescription content = ((ContentElement) o) |
| .getPresentation(); |
| if (content != null) { |
| resource = content.eResource(); |
| if (resource != null) { |
| URI contentURI = resource.getURI(); |
| if (contentURI != null) { |
| path = path |
| + ",." + File.separatorChar + contentURI.deresolve(uri).toFileString(); //$NON-NLS-1$ |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| statusLineManager.setMessage(path); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.epf.library.ILibraryServiceListener#libraryReopened(MethodLibrary) |
| */ |
| public void libraryReopened(MethodLibrary library) { |
| refreshViews(); |
| } |
| |
| class LibraryViewActionBarContributor extends LibraryActionBarContributor { |
| |
| private IAction newPluginAction = new NewPluginAction( |
| AuthoringUIResources.getString("AuthoringUI.0")); //$NON-NLS-1$ |
| |
| private IAction moveAction = new Action(AuthoringUIResources |
| .getString("AuthoringUI.1")) { //$NON-NLS-1$ |
| |
| public void run() { |
| Collection elementsToMove = new ArrayList(); |
| IStructuredSelection selection = (IStructuredSelection) LibraryView.this.selection; |
| for (Iterator iter = selection.iterator(); iter.hasNext();) { |
| Object element = iter.next(); |
| if (element instanceof MethodElement |
| || (element = TngUtil.unwrap(element)) instanceof CustomCategory) { |
| // Handle CustomCategory specially. |
| EObject container = ((EObject) element).eContainer(); |
| IStatus status = UserInteractionHelper.checkModify( |
| container, getSite().getShell()); |
| if (container != null && !status.isOK()) { |
| AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayError( |
| AuthoringUIResources |
| .getString("AuthoringUI.errorDialog.title"), //$NON-NLS-1$ |
| AuthoringUIResources |
| .getString("AuthoringUI.errorDialog.moveError"), //$NON-NLS-1$ |
| status); |
| return; |
| } |
| elementsToMove.add(element); |
| } |
| } |
| |
| // TODO: Prompt the user the save editing changes for |
| // elements that will be moved. |
| |
| // Remove elements from the move list if their containers are |
| // already in the move list. |
| for (Iterator iterator = elementsToMove.iterator(); iterator |
| .hasNext();) { |
| EObject element = (EObject) iterator.next(); |
| boolean isContained = false; |
| check_contained: for (Iterator iter = elementsToMove |
| .iterator(); iter.hasNext();) { |
| Object e = (Object) iter.next(); |
| if (UmaUtil.isContainedBy(element, e)) { |
| isContained = true; |
| break check_contained; |
| } |
| } |
| if (isContained) { |
| iterator.remove(); |
| } |
| } |
| |
| MoveDialog dlg = new MoveDialog(getSite().getShell(), |
| elementsToMove, editingDomain); |
| dlg.open(); |
| } |
| }; |
| |
| private IAction renameAction = new Action(AuthoringUIResources |
| .getString("AuthoringUI.renameAction.text")) { //$NON-NLS-1$ |
| |
| public void run() { |
| final NamedElement e = (NamedElement) TngUtil |
| .unwrap(((IStructuredSelection) selection) |
| .getFirstElement()); |
| |
| IStatus status = UserInteractionHelper.checkModify(e, getSite() |
| .getShell()); |
| if (!status.isOK()) { |
| AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayError( |
| AuthoringUIResources |
| .getString("AuthoringUI.renameDialog.title"), //$NON-NLS-1$ |
| AuthoringUIResources |
| .getString("AuthoringUI.renameDialog.renameError"), //$NON-NLS-1$ |
| status); |
| return; |
| } |
| |
| if (e.eContainer() != null |
| && e.eContainer().eResource() != e.eResource()) { |
| status = UserInteractionHelper.checkModify(e.eContainer(), |
| getSite().getShell()); |
| if (!status.isOK()) { |
| AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayError( |
| AuthoringUIResources |
| .getString("AuthoringUI.renameDialog.title"), //$NON-NLS-1$ |
| AuthoringUIResources |
| .getString("AuthoringUI.renameDialog.renameError"), //$NON-NLS-1$ |
| status); |
| return; |
| } |
| } |
| |
| final IValidator validator = IValidatorFactory.INSTANCE |
| .createNameValidator(e, adapterFactory); |
| IInputValidator inputValidator = new IInputValidator() { |
| public String isValid(String newText) { |
| if (validator != null) { |
| return UserInteractionHelper |
| .getSimpleErrorMessage(validator |
| .isValid(newText)); |
| } |
| return null; |
| } |
| }; |
| |
| boolean getInput = true; |
| InputDialog inputDlg = new InputDialog( |
| Display.getCurrent().getActiveShell(), |
| AuthoringUIResources |
| .getString("AuthoringUI.rename.text"), //$NON-NLS-1$ |
| AuthoringUIResources |
| .getString("AuthoringUI.newname.text"), e.getName(), inputValidator); //$NON-NLS-1$ //$NON-NLS-2$ |
| while (getInput) { |
| getInput = false; |
| if (inputDlg.open() == Window.OK) { |
| final String newName = inputDlg.getValue(); |
| if (!newName.equals(e.getName())) { |
| if (e instanceof MethodConfiguration) { |
| String[] configNames = LibraryServiceUtil |
| .getMethodConfigurationNames(LibraryService |
| .getInstance() |
| .getCurrentMethodLibrary()); |
| for (int i = 0; i < configNames.length; i++) { |
| if (newName.equals(configNames[i])) { |
| AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayError( |
| AuthoringUIResources |
| .getString("AuthoringUI.renameDialog.title"), //$NON-NLS-1$ |
| AuthoringUIResources |
| .formatString( |
| "AuthoringUI.duplicateElementNameError.msg", newName)); //$NON-NLS-1$ |
| getInput = true; |
| break; |
| } |
| } |
| } |
| if (getInput == true) { |
| inputDlg = new InputDialog( |
| Display.getCurrent().getActiveShell(), |
| AuthoringUIResources |
| .getString("AuthoringUI.rename.text"), AuthoringUIResources.getString("AuthoringUI.newname.text"), e.getName(), inputValidator); //$NON-NLS-1$ //$NON-NLS-2$ |
| continue; |
| } |
| String oldName = e.getName(); |
| e.setName(newName); |
| |
| // Special handling for ProcessComponent to keep its |
| // name and the name of its process in sync. |
| if (e instanceof ProcessComponent) { |
| Process proc = ((ProcessComponent) e) |
| .getProcess(); |
| proc.setName(newName); |
| } |
| |
| Runnable runnable = new Runnable() { |
| |
| public void run() { |
| // Save the modified file(s). |
| IMethodLibraryPersister.FailSafeMethodLibraryPersister persister = ContentDescriptionFactory |
| .getMethodLibraryPersister() |
| .getFailSafePersister(); |
| try { |
| persister.save(e.eResource()); |
| persister.commit(); |
| |
| Collection renamedResources = new ArrayList(); |
| if (e instanceof ContentElement |
| && ContentDescriptionFactory |
| .hasPresentation((MethodElement) e)) { |
| renamedResources |
| .add(((ContentElement) e) |
| .getPresentation() |
| .eResource()); |
| } |
| renamedResources.add(e.eResource()); |
| |
| persister |
| .adjustLocation(renamedResources); |
| } catch (Exception e1) { |
| AuthoringUIPlugin.getDefault() |
| .getLogger().logError(e1); |
| |
| persister.rollback(); |
| |
| String details = e1.getMessage() != null ? MessageFormat |
| .format( |
| ": {0}", new Object[] { e1.getMessage() }) : ""; //$NON-NLS-1$ //$NON-NLS-2$ |
| String msg = MessageFormat |
| .format( |
| AuthoringUIResources |
| .getString("AuthoringUI.ElementsView.err_saving"), new Object[] { e.eResource().getURI().toFileString(), details }); //$NON-NLS-1$ |
| throw new MessageException(msg); |
| } |
| } |
| |
| }; |
| |
| if (!UserInteractionHelper |
| .runWithProgress( |
| runnable, |
| AuthoringUIResources |
| .getString("AuthoringUI.ElementsView.renaming.text"))) { //$NON-NLS-1$ |
| // restore old name |
| e.setName(oldName); |
| } |
| } |
| } |
| } |
| } |
| }; |
| |
| private IAction replaceAction = new Action(AuthoringUIResources |
| .getString("AuthoringUI.ElementsView.replaceAction.text")) { //$NON-NLS-1$ |
| |
| public void run() { |
| if (!getPage().closeAllEditors(true)) { |
| return; |
| } |
| |
| final ProcessComponent procComp = (ProcessComponent) ((IStructuredSelection) selection) |
| .getFirstElement(); |
| Process proc = procComp.getProcess(); |
| final String typeStr; |
| if (proc instanceof CapabilityPattern) { |
| typeStr = AuthoringUIResources |
| .getString("AuthoringUI.ElementsView.20"); //$NON-NLS-1$ |
| } else if (proc instanceof DeliveryProcess) { |
| typeStr = AuthoringUIResources |
| .getString("AuthoringUI.ElementsView.21"); //$NON-NLS-1$ |
| } else { |
| typeStr = AuthoringUIResources |
| .getString("AuthoringUI.ElementsView.22"); //$NON-NLS-1$ |
| } |
| DirectoryDialog dirDlg = new DirectoryDialog(getSite() |
| .getShell()); |
| dirDlg.setText(AuthoringUIResources |
| .getString("AuthoringUI.ElementsView.replace.text")); //$NON-NLS-1$ |
| dirDlg |
| .setMessage(MessageFormat |
| .format( |
| AuthoringUIResources |
| .getString("AuthoringUI.ElementsView.migration_dir_dlg_description.text"), new Object[] { typeStr })); //$NON-NLS-1$ |
| final String dir = dirDlg.open(); |
| if (dir == null) { |
| return; |
| } |
| |
| boolean ret = UserInteractionHelper |
| .runWithProgress( |
| new IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, |
| InterruptedException { |
| try { |
| ImportExportUtil.replace(procComp, |
| dir); |
| } catch (Exception e) { |
| throw new WrappedException(e); |
| } |
| } |
| }, |
| MessageFormat |
| .format( |
| AuthoringUIResources |
| .getString("AuthoringUI.ElementsView.replaceingwithformat.text"), new Object[] { typeStr }) //$NON-NLS-1$ |
| ); |
| |
| if (ret) { |
| // Reopen the library. |
| LibraryUIManager.getInstance().openLibrary( |
| LibraryService.getInstance() |
| .getCurrentMethodLibraryPath()); |
| } |
| } |
| }; |
| |
| private IAction openVariabilityDialogAction = new Action( |
| AuthoringUIResources |
| .getString("AuthoringUI.ElementsView.openVariabilityDialogAction.text")) { //$NON-NLS-1$ |
| public void run() { |
| Object obj = TngUtil.unwrap(((IStructuredSelection) selection) |
| .getFirstElement()); |
| if (obj instanceof VariabilityElement) { |
| VariabilityElement element = (VariabilityElement) obj; |
| VariabilitySelection variabilitySelection = new VariabilitySelection(); |
| Object selectedObject = variabilitySelection |
| .getSelectedVariability(element); |
| if (selectedObject != null) { |
| EditorChooser.getInstance().openEditor(selectedObject); |
| } |
| } |
| } |
| }; |
| |
| private boolean locked; |
| |
| private boolean canRename; |
| |
| private boolean canMove; |
| |
| private IAction showInResourceNavigatorAction = new Action( |
| AuthoringUIResources |
| .getString("AuthoringUI.showInResourceNavigatorAction.label")) { //$NON-NLS-1$ |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.action.Action#run() |
| */ |
| public void run() { |
| ResourceNavigator navigator = (ResourceNavigator) ViewHelper |
| .openView("org.eclipse.ui.views.ResourceNavigator"); //$NON-NLS-1$ |
| Object obj = TngUtil.unwrap(((IStructuredSelection) selection) |
| .getFirstElement()); |
| IResource wsRes = PersistenceUtil.getWorkspaceResource(obj); |
| if (wsRes != null) { |
| navigator.getViewer().setSelection( |
| new StructuredSelection(wsRes), true); |
| } |
| } |
| }; |
| |
| /** |
| * Creates a new instance. |
| */ |
| public LibraryViewActionBarContributor(EditingDomain editingDomain) { |
| super(editingDomain); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor#createDeleteAction() |
| */ |
| protected DeleteAction createDeleteAction() { |
| return new LibraryViewDeleteAction() { |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.ElementsViewPasteAction#updateSelection(IStructuredSelection) |
| */ |
| public boolean updateSelection(IStructuredSelection selection) { |
| if (locked) { |
| return false; |
| } |
| return super.updateSelection(selection); |
| } |
| |
| public void run() { |
| String title = AuthoringUIResources |
| .getString("AuthoringUI.actions.LibraryActionBarContributor.deleteErrorTitle"); //$NON-NLS-1$ |
| try { |
| super.run(); |
| } catch (MessageException e) { |
| AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayError(title, e.getMessage()); |
| } catch (Exception e) { |
| String details = TngUtil.toStackTraceString(e); |
| String message = AuthoringUIResources |
| .getString("AuthoringUI.actions.LibraryActionBarContributor.deleteErrorMessage"); //$NON-NLS-1$ |
| String reason = AuthoringUIResources |
| .getString("AuthoringUI.actions.LibraryActionBarContributor.deleteErrorReason"); //$NON-NLS-1$ |
| AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayError(title, message, reason, details, |
| e); |
| } |
| } |
| |
| protected void deleteFailed() { |
| AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayInfo( |
| AuthoringUIResources |
| .getString("AuthoringUI.dlgTitle.reloadLibrary") //$NON-NLS-1$ |
| , |
| AuthoringUIResources |
| .getString("AuthoringUI.msg.reloadLibrary")); //$NON-NLS-1$ |
| |
| // Library need to be reloaded. |
| String libDir = LibraryService.getInstance() |
| .getCurrentMethodLibraryPath(); |
| LibraryUIManager.getInstance().openLibrary(libDir); |
| |
| // User tried to select the old selection. |
| if (activeViewPart instanceof IViewerProvider) { |
| final ArrayList elements = new ArrayList(); |
| for (Iterator iter = selection.iterator(); iter |
| .hasNext();) { |
| Object e = iter.next(); |
| if (e instanceof MethodElement) { |
| String guid = ((MethodElement) e).getGuid(); |
| ILibraryManager manager = LibraryService |
| .getInstance() |
| .getCurrentLibraryManager(); |
| if (manager != null) { |
| MethodElement element = manager |
| .getMethodElement(guid); |
| if (element != null) { |
| elements.add(element); |
| } |
| } |
| } |
| } |
| if (!elements.isEmpty()) { |
| Viewer viewer = ((IViewerProvider) activeViewPart) |
| .getViewer(); |
| viewer.setSelection(new StructuredSelection( |
| elements), true); |
| } |
| } |
| } |
| }; |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor#createCutAction() |
| */ |
| protected CutAction createCutAction() { |
| return new LibraryViewCutAction() { |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.ElementsViewPasteAction#updateSelection(IStructuredSelection) |
| */ |
| public boolean updateSelection(IStructuredSelection selection) { |
| if (locked) { |
| return false; |
| } |
| return super.updateSelection(selection); |
| } |
| }; |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor#createCopyAction() |
| */ |
| protected CopyAction createCopyAction() { |
| return new LibraryViewCopyAction(); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor#createPasteAction() |
| */ |
| protected PasteAction createPasteAction() { |
| return new LibraryViewPasteAction() { |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.ElementsViewPasteAction#updateSelection(IStructuredSelection) |
| */ |
| public boolean updateSelection(IStructuredSelection selection) { |
| if (locked) { |
| return false; |
| } |
| return super.updateSelection(selection); |
| } |
| }; |
| } |
| |
| private void checkLocked() { |
| if (selection instanceof IStructuredSelection) { |
| boolean wasLocked = locked; |
| locked = ViewHelper.isLocked((IStructuredSelection) selection); |
| if (wasLocked != locked) { |
| deleteAction.setEnabled(deleteAction |
| .updateSelection((IStructuredSelection) selection)); |
| cutAction.setEnabled(cutAction |
| .updateSelection((IStructuredSelection) selection)); |
| pasteAction.setEnabled(pasteAction |
| .updateSelection((IStructuredSelection) selection)); |
| boolean enabled = !locked; |
| renameAction.setEnabled(enabled); |
| moveAction.setEnabled(enabled); |
| } |
| } |
| } |
| |
| void updateSelection(ISelection selection) { |
| IStructuredSelection sel = (IStructuredSelection) selection; |
| |
| locked = ViewHelper.isLocked(sel); |
| |
| boolean enabled = !locked; |
| renameAction.setEnabled(enabled); |
| moveAction.setEnabled(enabled); |
| |
| canRename = canRename(sel); |
| canMove = canMove(sel); |
| |
| if (!locked && sel.size() == 1 |
| && sel.getFirstElement() instanceof ProcessComponent) { |
| replaceAction.setEnabled(true); |
| } else { |
| replaceAction.setEnabled(false); |
| } |
| |
| if (sel.size() == 1) { |
| Object obj = TngUtil.unwrap(((IStructuredSelection) selection) |
| .getFirstElement()); |
| openVariabilityDialogAction |
| .setEnabled(obj instanceof VariabilityElement |
| && !TngUtil.isPredefined((MethodElement) obj)); |
| showInResourceNavigatorAction |
| .setEnabled(obj instanceof MethodElement); |
| } |
| } |
| |
| public void enableGlobalEditMenu() { |
| } |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor#addGlobalActions(IMenuManager) |
| */ |
| protected void addGlobalActions(IMenuManager menuManager) { |
| super.addGlobalActions(menuManager); |
| menuManager.insertAfter("fixed-additions", newPluginAction); //$NON-NLS-1$ |
| } |
| |
| private boolean canMove(IStructuredSelection selection) { |
| for (Iterator iter = selection.iterator(); iter.hasNext();) { |
| Object element = iter.next(); |
| if ((element instanceof MethodElement) |
| && !(element instanceof ContentCategory) |
| && !(element instanceof MethodPlugin) |
| && !(element instanceof MethodConfiguration) |
| && !TngUtil.isPredefined((MethodElement) element)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * @see LibraryActionBarContributor#menuAboutToShow(IMenuManager) |
| */ |
| public void menuAboutToShow(IMenuManager menuManager) { |
| checkLocked(); |
| |
| // Add our standard marker. |
| menuManager.add(new Separator("fixed-additions")); //$NON-NLS-1$ |
| menuManager.add(new Separator("fixed-additions-end")); //$NON-NLS-1$ |
| menuManager.add(new Separator("edit")); //$NON-NLS-1$ |
| |
| // Add the edit menu actions. |
| menuManager.add(new ActionContributionItem(libraryViewEditAction)); |
| menuManager.add(new ActionContributionItem(copyAction)); |
| menuManager.add(new ActionContributionItem(pasteAction)); |
| menuManager.add(new Separator()); |
| menuManager.add(new ActionContributionItem(deleteAction)); |
| if (canRename) { |
| menuManager.add(new ActionContributionItem(renameAction)); |
| } |
| if (canMove) { |
| menuManager.add(new ActionContributionItem(moveAction)); |
| } |
| |
| menuManager.add(new Separator("view")); //$NON-NLS-1$ |
| if (openVariabilityDialogAction.isEnabled()) { |
| menuManager.add(new ActionContributionItem( |
| openVariabilityDialogAction)); |
| } |
| if (showInResourceNavigatorAction.isEnabled()) { |
| menuManager.add(new ActionContributionItem( |
| showInResourceNavigatorAction)); |
| } |
| menuManager.add(new Separator()); |
| |
| // Add our other standard marker where other plugins will contribute |
| // menu |
| // |
| menuManager.add(new Separator("additions")); //$NON-NLS-1$ |
| menuManager.add(new Separator("additions-end")); //$NON-NLS-1$ |
| |
| addGlobalActions(menuManager); |
| |
| if (!locked) { |
| MenuManager submenuManager = null; |
| submenuManager = new MenuManager( |
| getString("_UI_CreateChild_menu_item")); //$NON-NLS-1$ |
| populateManager(submenuManager, createChildActions, null); |
| menuManager.insertBefore("fixed-additions", submenuManager); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * Returns <code>true</code> if the selected method elements can be |
| * renamed. |
| */ |
| private boolean canRename(IStructuredSelection selection) { |
| if (selection.size() > 1) |
| return false; |
| Object element = TngUtil.unwrap(selection.getFirstElement()); |
| if (element instanceof NamedElement |
| && !TngUtil.isPredefined((MethodElement) element)) { |
| return true; |
| } |
| return false; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor#refreshViewer(org.eclipse.jface.viewers.Viewer) |
| */ |
| protected void refreshViewer(Viewer viewer) { |
| if (viewer == LibraryView.this.getViewer()) { |
| IRunnableWithProgress runnable = new IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, |
| InterruptedException { |
| monitor.beginTask("", 3); //$NON-NLS-1$ |
| monitor |
| .subTask(getString("_UI_RefreshViewer_menu_item")); //$NON-NLS-1$ |
| monitor.worked(1); |
| try { |
| // refresh all loaded resources |
| // |
| ResourceSet resourceSet = LibraryProcessor |
| .getInstance().getEditingDomain() |
| .getResourceSet(); |
| List removedResources = new ArrayList(); |
| List changedResources = new ArrayList(); |
| for (Iterator iter = new ArrayList(resourceSet |
| .getResources()).iterator(); iter.hasNext();) { |
| Resource resource = (Resource) iter.next(); |
| String loc = resource.getURI().toFileString(); |
| IResource wsRes = FileManager |
| .getResourceForLocation(loc); |
| if (wsRes == null) { |
| removedResources.add(resource); |
| } else if (!wsRes |
| .isSynchronized(IResource.DEPTH_ZERO)) { |
| changedResources.add(resource); |
| } |
| } |
| monitor.worked(2); |
| doRefresh(removedResources, changedResources, false); |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| }; |
| IRunnableContext context = new ProgressMonitorDialog(getSite() |
| .getShell()); |
| try { |
| getSite().getWorkbenchWindow().getWorkbench() |
| .getProgressService().runInUI(context, runnable, |
| null); |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| String title = AuthoringUIResources |
| .getString("AuthoringUI.ProcessEditor.refreshErrorTitle"); //$NON-NLS-1$ |
| AuthoringUIPlugin.getDefault().getMsgDialog().displayError( |
| title, e.toString(), e); |
| } |
| return; |
| } |
| super.refreshViewer(viewer); |
| } |
| } |
| |
| public ILibraryActionBarContributor createActionBarContributor() { |
| ILibraryActionBarContributor actionBar = new LibraryViewActionBarContributor( |
| editingDomain); |
| return actionBar; |
| } |
| |
| public void createContextMenuFor(final StructuredViewer viewer) { |
| super.createContextMenuFor(viewer); |
| int dndOperations = DND.DROP_MOVE; |
| Transfer[] transfers = new Transfer[] { HTMLTransfer.getInstance(), |
| LocalTransfer.getInstance() }; |
| viewer.addDragSupport(dndOperations, transfers, |
| new LibraryViewerDragAdapter(viewer)); |
| } |
| |
| public void menuAboutToShow(IMenuManager menuManager) { |
| super.menuAboutToShow(menuManager); |
| } |
| |
| public void init(IViewSite site) throws PartInitException { |
| super.init(site); |
| } |
| |
| public void dispose() { |
| RefreshJob.getInstance().setRefreshHandler(null); |
| |
| super.dispose(); |
| if (doubleClickListener != null) { |
| treeViewer.removeDoubleClickListener(doubleClickListener); |
| } |
| } |
| |
| public ProcessComponent getProcessComponent(Object obj) { |
| Object parent; |
| for (parent = obj; (parent != null && !(parent instanceof ProcessComponent));) { |
| ItemProviderAdapter adapter = (ItemProviderAdapter) adapterFactory |
| .adapt(parent, ITreeItemContentProvider.class); |
| parent = adapter.getParent(parent); |
| } |
| return (ProcessComponent) parent; |
| } |
| |
| private static abstract class StatusWorkspaceModifyOperation extends |
| WorkspaceModifyOperation { |
| |
| protected String errMsg; |
| |
| public String getErrorMessage() { |
| return errMsg; |
| } |
| } |
| |
| public void openLibrary(final String path) { |
| // Do the work within an operation because this is a long running |
| // activity that modifies the workbench. |
| StatusWorkspaceModifyOperation operation = new StatusWorkspaceModifyOperation() { |
| |
| // This is the method that gets invoked when the operation runs. |
| public void execute(IProgressMonitor monitor) { |
| monitor.beginTask(AuthoringUIResources |
| .getString("AuthoringUI.openingLibraryTask.name"), 2); //$NON-NLS-1$ |
| try { |
| monitor.worked(1); |
| LibraryService.getInstance().closeCurrentMethodLibrary(); |
| MethodLibrary library = LibraryService.getInstance() |
| .openXMIMethodLibrary(path); |
| LibraryService.getInstance().setCurrentMethodLibrary( |
| library); |
| LibraryUIPreferences.setSavedLibraryPath(path); |
| } catch (Exception ex) { |
| if (ex instanceof IOException) { |
| String message = ex.getMessage(); |
| if (message.startsWith("###")) { //$NON-NLS-1$ |
| String projectFileName = message.substring(3); |
| String prompt = AuthoringUIResources |
| .formatString( |
| "AuthoringUI.ElementsView.35", new Object[] { projectFileName }); //$NON-NLS-1$ |
| if (MsgBox.prompt(prompt, SWT.RETRY | SWT.CANCEL) == SWT.RETRY) { |
| openLibrary(path); |
| } |
| } |
| } else { |
| AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayError( |
| AuthoringUIResources |
| .getString("AuthoringUI.errorDialog.title"), //$NON-NLS-1$ |
| AuthoringUIResources |
| .getString("AuthoringUI.openLibraryError.msg"), //$NON-NLS-1$ |
| ex); |
| } |
| } finally { |
| monitor.done(); |
| } |
| } |
| }; |
| |
| try { |
| // This runs the options, and shows progress. |
| new ProgressMonitorDialog(getSite().getShell()).run(true, false, |
| operation); |
| if (operation.getErrorMessage() == null) { |
| getSite().getPage().closeAllEditors(false); |
| } |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| |
| protected void handleActivate(IWorkbenchPart part) { |
| super.handleActivate(part); |
| LibraryProcessor.getInstance().ensureLibraryProjectOpen( |
| getViewSite().getActionBars().getStatusLineManager() |
| .getProgressMonitor()); |
| } |
| |
| public boolean isSaveAsAllowed() { |
| // This view should not participate in all the save commands. |
| return false; |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.views.SaveableLibraryViewPart#doSaveAs() |
| */ |
| public void doSaveAs() { |
| DirectoryDialog dirDlg = new DirectoryDialog(getSite().getShell()); |
| dirDlg.setText(AuthoringUIResources |
| .getString("AuthoringUI.SaveAswithdots.text")); //$NON-NLS-1$ |
| dirDlg.setMessage(AuthoringUIResources |
| .getString("AuthoringUI.specifydirectory.text")); //$NON-NLS-1$ |
| final String saveDir = dirDlg.open(); |
| |
| if (saveDir == null) |
| return; |
| |
| // 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. |
| public void execute(IProgressMonitor monitor) { |
| monitor |
| .beginTask( |
| AuthoringUIResources |
| .getString("AuthoringUI.SaveAs.text"), IProgressMonitor.UNKNOWN); //$NON-NLS-1$ |
| try { |
| LibraryProcessor.getInstance().saveLibraryAs(saveDir, |
| false, monitor); |
| } catch (Exception e) { |
| AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayError( |
| AuthoringUIResources |
| .getString("AuthoringUI.saveLibraryDialog.title"), //$NON-NLS-1$ |
| AuthoringUIResources |
| .formatString( |
| "AuthoringUI.saveLibraryToError.msg", saveDir), //$NON-NLS-1$ |
| AuthoringUIResources |
| .getString("AuthoringUI.error.reason"), //$NON-NLS-1$ |
| e); |
| } finally { |
| monitor.done(); |
| } |
| } |
| }; |
| |
| try { |
| // This runs the options, and shows progress. |
| new ProgressMonitorDialog(getSite().getShell()).run(true, false, |
| operation); |
| firePropertyChange(PROP_DIRTY); |
| LibraryUIUtil.updateShellTitle(); |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| |
| /** |
| * Used by org.eclipse.epf.authoring.ui.actions.LinkWithEditor Given an |
| * object that is a MethodElement, selects that object in the Lib Nav |
| * |
| * @param o |
| */ |
| public void setSelectionToViewer(Object o) { |
| o = TngUtil.unwrap(o); |
| if (!(o instanceof MethodElement)) |
| return; |
| if (o instanceof MethodConfiguration) { |
| super.setSelectionToViewer(Arrays.asList(new Object[] { o })); |
| return; |
| } |
| try { |
| MethodPlugin plugin = UmaUtil.getMethodPlugin((MethodElement) o); |
| treeViewer.setExpandedState(plugin, true); |
| |
| ITreeItemContentProvider pluginAdapter = (ITreeItemContentProvider) TngUtil |
| .getAdapter(plugin, ITreeItemContentProvider.class); |
| |
| if (o instanceof Process) { |
| o = ((Process) o).eContainer(); |
| } |
| if (o instanceof ProcessComponent || o instanceof ProcessPackage) { |
| |
| treeViewer.setExpandedState(pluginAdapter.getChildren(plugin) |
| .toArray()[1], true); |
| // Expand the process packages. |
| expandTreeViewerPackages(((MethodElement) o).eContainer()); |
| |
| } else { |
| ITreeItemContentProvider methodContentPkg = (ITreeItemContentProvider) pluginAdapter |
| .getChildren(plugin).toArray()[0]; |
| treeViewer.setExpandedState(methodContentPkg, true); |
| |
| if (o instanceof CustomCategory) { |
| CustomCategory rootCC = TngUtil |
| .getRootCustomCategory(plugin); |
| treeViewer.setExpandedState(rootCC, true); |
| } else if (o instanceof ContentCategory) { |
| Object stdCats = methodContentPkg.getChildren(o).toArray()[1]; |
| treeViewer.setExpandedState(stdCats, true); |
| |
| } else { |
| Object coreContent = methodContentPkg.getChildren(o) |
| .toArray()[0]; |
| treeViewer.setExpandedState(coreContent, true); |
| |
| // Expand the content packages. |
| expandTreeViewerPackages(((MethodElement) o).eContainer()); |
| } |
| } |
| } catch (Exception ex) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(ex); |
| } |
| super.setSelectionToViewer(Arrays.asList(new Object[] { o })); |
| } |
| |
| private void expandTreeViewerPackages(EObject e) { |
| if (e == null) |
| return; |
| if (e instanceof ContentPackage || e instanceof ProcessPackage) { |
| expandTreeViewerPackages(e.eContainer()); |
| treeViewer.setExpandedState(e, true); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.persistence.util.IRefreshHandler#refresh(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public void refresh(final IProgressMonitor monitor) { |
| Control ctrl = getViewer().getControl(); |
| if (ctrl == null || ctrl.isDisposed()) |
| return; |
| |
| if (ctrl.getDisplay().getThread() == Thread.currentThread()) { |
| doRefresh(monitor); |
| } else { |
| ctrl.getDisplay().asyncExec(new Runnable() { |
| |
| public void run() { |
| doRefresh(monitor); |
| } |
| |
| }); |
| } |
| |
| } |
| |
| private void doRefresh(Collection removedResources, |
| Collection changedResources, boolean refreshViews) { |
| HashSet editorsToRefresh = new HashSet(); |
| if (!removedResources.isEmpty()) { |
| handleRemovedResources(removedResources, editorsToRefresh); |
| refreshViews = true; |
| } |
| if (!changedResources.isEmpty()) { |
| handleChangedResources(changedResources, editorsToRefresh, |
| refreshViews); |
| } else { |
| if (refreshViews) { |
| refreshViews(); |
| } |
| |
| if (!editorsToRefresh.isEmpty()) { |
| // refresh the editors that handleRemovedResources requested |
| // |
| for (Iterator iter = editorsToRefresh.iterator(); iter |
| .hasNext();) { |
| Object editor = iter.next(); |
| if (editor instanceof MethodElementEditor) { |
| ((MethodElementEditor) editor).refresh(); |
| } |
| } |
| } |
| } |
| } |
| |
| private void doRefresh(IProgressMonitor monitor) { |
| boolean refreshViews = !RefreshJob.getInstance() |
| .getReloadedBeforeRefreshResources().isEmpty(); |
| ArrayList removedResources = new ArrayList(RefreshJob.getInstance() |
| .getRemovedResources()); |
| ArrayList changedResources = new ArrayList(RefreshJob.getInstance() |
| .getChangedResources()); |
| doRefresh(removedResources, changedResources, refreshViews); |
| if (!removedResources.isEmpty()) { |
| RefreshJob.getInstance().getRemovedResources().removeAll( |
| removedResources); |
| } |
| if (!changedResources.isEmpty()) { |
| RefreshJob.getInstance().getChangedResources().removeAll( |
| changedResources); |
| } |
| } |
| |
| /** |
| * @param removedResources2 |
| */ |
| private Collection handleRemovedResources(Collection removedResources, |
| Collection editorsToRefresh) { |
| IWorkbenchPage workbenchPage = getSite().getPage(); |
| IEditorReference[] editorReferences = workbenchPage |
| .getEditorReferences(); |
| ArrayList dirtyEditorsWithConflict = new ArrayList(); |
| ArrayList removedResourceList = new ArrayList(removedResources); |
| if (editorsToRefresh == null) { |
| editorsToRefresh = new ArrayList(); |
| } |
| // find all editor with dirty conflict |
| // |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor instanceof MethodElementEditor && editor.isDirty()) { |
| MethodElementEditorInput input = (MethodElementEditorInput) editor |
| .getEditorInput(); |
| Resource resource = input.getMethodElement() != null ? input |
| .getMethodElement().eResource() : null; |
| if (!removedResources.contains(resource)) { |
| Collection usedResources = ((MethodElementEditor) editor) |
| .getUsedResources(); |
| check_resource: for (int j = 0; j < removedResourceList |
| .size(); j++) { |
| resource = (Resource) removedResourceList.get(j); |
| if (usedResources.contains(resource)) { |
| dirtyEditorsWithConflict.add(editor); |
| break check_resource; |
| } |
| } |
| } else { |
| editorsToRefresh.add(editor); |
| } |
| } |
| } |
| |
| if (!dirtyEditorsWithConflict.isEmpty()) { |
| Object[] selected = selectDirtyEditors(dirtyEditorsWithConflict); |
| for (int i = 0; i < selected.length; i++) { |
| editorsToRefresh.add(selected[i]); |
| } |
| } |
| |
| // unload the removed resources |
| // |
| for (Iterator iter = removedResources.iterator(); iter.hasNext();) { |
| MultiFileXMIResourceImpl resource = (MultiFileXMIResourceImpl) iter |
| .next(); |
| try { |
| resource.unloadWithoutRemove(); |
| } catch (Exception e) { |
| CommonPlugin.INSTANCE.log(e); |
| } |
| } |
| ResourceSet resourceSet = LibraryProcessor.getInstance() |
| .getEditingDomain().getResourceSet(); |
| if (resourceSet != null) { |
| resourceSet.getResources().removeAll(removedResources); |
| } |
| |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor instanceof MethodElementEditor && !editor.isDirty()) { |
| Collection usedResources = ((MethodElementEditor) editor) |
| .getUsedResources(); |
| check_resource: for (int j = 0; j < removedResourceList.size(); j++) { |
| Resource resource = (Resource) removedResourceList.get(j); |
| if (usedResources.contains(resource)) { |
| editorsToRefresh.add(editor); |
| break check_resource; |
| } |
| } |
| } |
| } |
| |
| return removedResources; |
| } |
| |
| /** |
| * |
| * @param changedResources |
| * @return resources that have been reloaded |
| */ |
| private Collection handleChangedResources(Collection changedResources, |
| Collection editorsToRefresh, boolean forceRefreshViews) { |
| if (!forceRefreshViews) { |
| for (Iterator iter = changedResources.iterator(); iter.hasNext();) { |
| MultiFileXMIResourceImpl resource = (MultiFileXMIResourceImpl) iter |
| .next(); |
| if (resource.getLastLoadTimeStamp() > lastRefreshTimeStamp) { |
| forceRefreshViews = true; |
| break; |
| } |
| } |
| } |
| return handleChangedResources(changedResources, null, |
| forceRefreshViews, editorsToRefresh); |
| } |
| |
| public Collection handleChangedResources(Collection changedResources, |
| Collection editorsNotToRefresh, boolean forceRefreshViews, |
| Collection editorsToRefresh) { |
| Control ctrl = getViewer().getControl(); |
| if (ctrl == null || ctrl.isDisposed()) |
| return Collections.EMPTY_LIST; |
| |
| IWorkbenchPage workbenchPage = getSite().getPage(); |
| IEditorReference[] editorReferences = workbenchPage |
| .getEditorReferences(); |
| ArrayList dirtyEditorsWithConflict = new ArrayList(); |
| ArrayList changedResourceList = new ArrayList(changedResources); |
| // find all editor with dirty conflict |
| // |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor instanceof MethodElementEditor && editor.isDirty()) { |
| Collection usedResources = ((MethodElementEditor) editor) |
| .getUsedResources(); |
| check_resource: for (int j = 0; j < changedResourceList.size(); j++) { |
| Resource resource = (Resource) changedResourceList.get(j); |
| if (usedResources.contains(resource)) { |
| dirtyEditorsWithConflict.add(editor); |
| break check_resource; |
| } |
| } |
| } |
| } |
| final ArrayList editorListToRefresh = new ArrayList(); |
| if (editorsToRefresh != null) { |
| editorListToRefresh.addAll(editorsToRefresh); |
| } |
| if (!dirtyEditorsWithConflict.isEmpty()) { |
| Object[] result = selectDirtyEditors(dirtyEditorsWithConflict); |
| for (int i = 0; i < result.length; i++) { |
| Object editor = result[i]; |
| if ((editorsNotToRefresh == null || !editorsNotToRefresh |
| .contains(editor)) |
| && (editorsToRefresh == null || !editorsToRefresh |
| .contains(editor))) { |
| editorListToRefresh.add(editor); |
| dirtyEditorsWithConflict.remove(editor); |
| } |
| } |
| // remove all resources used by dirty editors with conflict from the |
| // collection of changed resources |
| // |
| for (int i = 0; i < dirtyEditorsWithConflict.size(); i++) { |
| MethodElementEditor editor = (MethodElementEditor) dirtyEditorsWithConflict |
| .get(i); |
| Collection usedResources = editor.getUsedResources(); |
| changedResourceList.removeAll(usedResources); |
| } |
| } |
| |
| boolean refreshViews = false; |
| if (!changedResourceList.isEmpty()) { |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor instanceof MethodElementEditor && !editor.isDirty()) { |
| Collection usedResources = ((MethodElementEditor) editor) |
| .getUsedResources(); |
| check_resource: for (int j = 0; j < changedResourceList |
| .size(); j++) { |
| Resource resource = (Resource) changedResourceList |
| .get(j); |
| if (usedResources.contains(resource)) { |
| editorListToRefresh.add(editor); |
| break check_resource; |
| } |
| } |
| } |
| } |
| |
| // reload the selected changed resources |
| // |
| Collection reloadedResources = LibraryProcessor.getInstance() |
| .getResourceManager().reloadResources(changedResourceList); |
| |
| refreshViews = !reloadedResources.isEmpty(); |
| } |
| if (forceRefreshViews || refreshViews) { |
| refreshViews(); |
| } |
| if (!editorListToRefresh.isEmpty()) { |
| for (int i = 0; i < editorListToRefresh.size(); i++) { |
| MethodElementEditor editor = (MethodElementEditor) editorListToRefresh |
| .get(i); |
| editor.refresh(); |
| } |
| } |
| return changedResourceList; |
| } |
| |
| private void refreshViews() { |
| EObject input = (EObject) getViewer().getInput(); |
| if (input != null) { |
| if (input.eIsProxy()) { |
| setInputForViewer(RefreshJob.getInstance().resolve(input)); |
| } else { |
| ISelection selection = getViewer().getSelection(); |
| getViewer().refresh(); |
| updateLastRefreshTimestamp(); |
| if (selection instanceof IStructuredSelection) { |
| IStructuredSelection structuredSelection = (IStructuredSelection) selection; |
| Object o = null; |
| if (structuredSelection.size() == 1 |
| && (o = structuredSelection.getFirstElement()) instanceof EObject |
| && ((EObject) o).eIsProxy()) { |
| o = RefreshJob.getInstance().resolve((EObject) o); |
| try { |
| setSelectionToViewer(o); |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger() |
| .logError(e); |
| } |
| } else { |
| restoreSelection(getViewer(), selection); |
| } |
| } |
| } |
| } |
| |
| ConfigurationView configView = ConfigurationView.getView(); |
| if (configView != null) { |
| Control ctrl = configView.getViewer().getControl(); |
| if (ctrl != null && !ctrl.isDisposed()) { |
| input = (EObject) configView.getViewer().getInput(); |
| if (input != null) { |
| if (input.eIsProxy()) { |
| configView.setInputForViewer(RefreshJob.getInstance() |
| .resolve(input)); |
| } else { |
| ISelection selection = configView.getViewer() |
| .getSelection(); |
| configView.getViewer().refresh(); |
| restoreSelection(configView.getViewer(), selection); |
| } |
| } |
| } |
| } |
| |
| ConfigurationContributionItem.refresh(); |
| } |
| |
| private Object[] selectDirtyEditors(List dirtyEditors) { |
| String title = AuthoringUIResources.getString("_UI_FileConflict_label"); //$NON-NLS-1$ |
| String msg = AuthoringUIResources |
| .getString("AuthoringUI.selectEditorsToDiscardConflictChanges"); //$NON-NLS-1$ |
| return selectEditors(dirtyEditors, title, msg); |
| } |
| |
| private Object[] selectEditors(List editors, String title, String msg) { |
| // prompt user to discard changes in editors that conflict with outside |
| // change |
| // |
| IStructuredContentProvider contentProvider = new IStructuredContentProvider() { |
| List fContents; |
| |
| public Object[] getElements(Object inputElement) { |
| if (fContents != null && fContents == inputElement) |
| return fContents.toArray(); |
| return new Object[0]; |
| } |
| |
| public void dispose() { |
| } |
| |
| public void inputChanged(Viewer viewer, Object oldInput, |
| Object newInput) { |
| if (newInput instanceof List) |
| fContents = (List) newInput; |
| else |
| fContents = null; |
| |
| } |
| |
| }; |
| ILabelProvider labelProvider = new LabelProvider() { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object) |
| */ |
| public String getText(Object element) { |
| if (element instanceof IEditorPart) { |
| return ((IEditorPart) element).getTitle(); |
| } |
| return super.getText(element); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.LabelProvider#getImage(java.lang.Object) |
| */ |
| public Image getImage(Object element) { |
| if (element instanceof IEditorPart) { |
| return ((IEditorPart) element).getTitleImage(); |
| } |
| return super.getImage(element); |
| } |
| }; |
| ListSelectionDialog dlg = new ListSelectionDialog(getSite().getShell(), |
| editors, contentProvider, labelProvider, msg); |
| dlg.setTitle(title); |
| dlg.setBlockOnOpen(true); |
| dlg.open(); |
| return dlg.getResult(); |
| } |
| |
| private static void restoreSelection(Viewer viewer, ISelection selection) { |
| if (selection instanceof IStructuredSelection && !selection.isEmpty()) { |
| IStructuredSelection structuredSelection = (IStructuredSelection) selection; |
| boolean restore = false; |
| ArrayList resolvedList = new ArrayList(); |
| for (Iterator iter = structuredSelection.iterator(); iter.hasNext();) { |
| Object object = iter.next(); |
| if (object instanceof EObject) { |
| EObject eObj = (EObject) object; |
| if (eObj.eIsProxy()) { |
| eObj = RefreshJob.getInstance().resolve(eObj); |
| restore = true; |
| } |
| if (!eObj.eIsProxy()) { |
| resolvedList.add(eObj); |
| } |
| } |
| } |
| if (restore) { |
| viewer |
| .setSelection(new StructuredSelection(resolvedList), |
| true); |
| } |
| } |
| } |
| } |
