| //------------------------------------------------------------------------------ |
| // 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.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IProject; |
| 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.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| 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.provider.WrapperItemProvider; |
| 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.AuthoringUIExtensionManager; |
| 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.AssignAction; |
| import org.eclipse.epf.authoring.ui.actions.CreateMethodElementCommand; |
| import org.eclipse.epf.authoring.ui.actions.CustomCategoryDeepCopyAction; |
| import org.eclipse.epf.authoring.ui.actions.ILibraryActionBarContributor; |
| import org.eclipse.epf.authoring.ui.actions.LayoutActionGroup; |
| import org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor; |
| import org.eclipse.epf.authoring.ui.actions.LibraryValidateAction; |
| 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.LibraryViewSimpleAction; |
| import org.eclipse.epf.authoring.ui.actions.NewPluginAction; |
| import org.eclipse.epf.authoring.ui.actions.ReassignAction; |
| import org.eclipse.epf.authoring.ui.actions.RenameAction; |
| import org.eclipse.epf.authoring.ui.actions.UnassignAction; |
| import org.eclipse.epf.authoring.ui.dialogs.MoveDialog; |
| import org.eclipse.epf.authoring.ui.dialogs.SwitchConfigDialog; |
| import org.eclipse.epf.authoring.ui.dialogs.VariabilitySelection; |
| import org.eclipse.epf.authoring.ui.dialogs.MoveDialog.MoveDialogExt; |
| import org.eclipse.epf.authoring.ui.dnd.LibraryViewerDragAdapter; |
| import org.eclipse.epf.authoring.ui.editors.EditorChooser; |
| import org.eclipse.epf.authoring.ui.editors.IEditorKeeper; |
| import org.eclipse.epf.authoring.ui.editors.MethodElementEditorInput; |
| import org.eclipse.epf.authoring.ui.editors.ProcessEditor; |
| import org.eclipse.epf.authoring.ui.preferences.ApplicationPreferenceConstants; |
| import org.eclipse.epf.authoring.ui.preferences.AuthoringUIPreferences; |
| import org.eclipse.epf.authoring.ui.providers.MethodElementLabelDecorator; |
| import org.eclipse.epf.authoring.ui.util.LibraryValidationMarkerHelper; |
| import org.eclipse.epf.authoring.ui.util.RefreshHandler; |
| import org.eclipse.epf.authoring.ui.util.UIHelper; |
| import org.eclipse.epf.common.ui.util.MsgBox; |
| import org.eclipse.epf.library.ILibraryManager; |
| import org.eclipse.epf.library.LibraryPlugin; |
| import org.eclipse.epf.library.LibraryService; |
| import org.eclipse.epf.library.LibraryServiceException; |
| import org.eclipse.epf.library.edit.FeatureValueWrapperItemProvider; |
| import org.eclipse.epf.library.edit.IFilter; |
| import org.eclipse.epf.library.edit.INamedFilter; |
| import org.eclipse.epf.library.edit.PluginUIPackageContext; |
| import org.eclipse.epf.library.edit.TngAdapterFactory; |
| import org.eclipse.epf.library.edit.navigator.MethodLibraryItemProvider; |
| import org.eclipse.epf.library.edit.navigator.PluginUIPackagesItemProvider; |
| import org.eclipse.epf.library.edit.ui.UserInteractionHelper; |
| import org.eclipse.epf.library.edit.util.ConfigurableComposedAdapterFactory; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.library.persistence.ILibraryResource; |
| import org.eclipse.epf.library.persistence.ILibraryResourceSet; |
| import org.eclipse.epf.library.persistence.PersistenceService; |
| import org.eclipse.epf.library.project.MethodLibraryProject; |
| import org.eclipse.epf.library.project.MethodLibraryProjectNature; |
| import org.eclipse.epf.library.ui.LibraryUIManager; |
| import org.eclipse.epf.library.ui.actions.LibraryLockingOperationRunner; |
| import org.eclipse.epf.library.ui.preferences.LibraryUIPreferences; |
| import org.eclipse.epf.library.util.ImportExportUtil; |
| import org.eclipse.epf.library.xmi.XMILibraryManager; |
| import org.eclipse.epf.library.xmi.XMILibraryUtil; |
| import org.eclipse.epf.persistence.FileManager; |
| 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.services.Services; |
| import org.eclipse.epf.uma.BreakdownElement; |
| 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.Discipline; |
| import org.eclipse.epf.uma.DisciplineGrouping; |
| 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.RoleDescriptor; |
| import org.eclipse.epf.uma.RoleSet; |
| import org.eclipse.epf.uma.RoleSetGrouping; |
| import org.eclipse.epf.uma.TeamProfile; |
| import org.eclipse.epf.uma.VariabilityElement; |
| import org.eclipse.epf.uma.WorkProductDescriptor; |
| import org.eclipse.epf.uma.ecore.impl.MultiResourceEObject; |
| import org.eclipse.epf.uma.edit.domain.TraceableAdapterFactoryEditingDomain; |
| import org.eclipse.epf.uma.provider.MethodPluginItemProvider; |
| import org.eclipse.epf.uma.util.AssociationHelper; |
| import org.eclipse.epf.uma.util.MessageException; |
| import org.eclipse.epf.uma.util.UmaUtil; |
| import org.eclipse.epf.validation.LibraryEValidator; |
| 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.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.ProgressMonitorDialog; |
| import org.eclipse.jface.operation.IRunnableContext; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.util.IPropertyChangeListener; |
| import org.eclipse.jface.util.PropertyChangeEvent; |
| 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.ISelection; |
| import org.eclipse.jface.viewers.ISelectionProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.LabelProviderChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.StructuredViewer; |
| import org.eclipse.jface.viewers.TreeSelection; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.dnd.DND; |
| import org.eclipse.swt.dnd.DragSourceListener; |
| import org.eclipse.swt.dnd.HTMLTransfer; |
| import org.eclipse.swt.dnd.TextTransfer; |
| import org.eclipse.swt.dnd.Transfer; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.FontData; |
| 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.IActionBars; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IPartListener; |
| import org.eclipse.ui.IPropertyListener; |
| import org.eclipse.ui.IViewPart; |
| import org.eclipse.ui.IViewSite; |
| 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.part.IShowInTarget; |
| import org.eclipse.ui.part.ShowInContext; |
| import org.eclipse.ui.views.markers.internal.MarkerAdapter; |
| 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 |
| * @author Jinhua Xi |
| * @author Weiping Lu |
| * @since 1.0 |
| */ |
| public class LibraryView extends AbstractBaseView implements IShowInTarget, IRefreshHandler { |
| |
| /** |
| * The view ID. |
| */ |
| public static final String VIEW_ID = LibraryView.class.getName(); |
| |
| private static LibraryView INSTANCE = null; |
| |
| private static boolean needRegisterChangeListenersInCreate = false; |
| |
| public static void setNeedRegisterChangeListenersInCreate( |
| boolean needRegisterChangeListenersInCreate) { |
| LibraryView.needRegisterChangeListenersInCreate = needRegisterChangeListenersInCreate; |
| } |
| |
| private static boolean DEBUG = AuthoringUIPlugin.getDefault().isDebugging(); |
| |
| protected TreeViewer treeViewer; |
| |
| protected IDoubleClickListener doubleClickListener = null; |
| |
| private ISelection selection; |
| |
| private LayoutActionGroup fLayoutActionSet; |
| |
| private String PERFORM_ID = "org.eclipse.epf.authoring.view.LibraryView.performValidatorAction"; //$NON-NLS-1$ |
| |
| private Font italicFont = null; |
| |
| private IAction performLibraryValidationAction = new Action( |
| AuthoringUIResources.Validate_method_library, AuthoringUIPlugin.getDefault().getImageDescriptor( |
| "full/etool16/validate_method_lib.gif")) { //$NON-NLS-1$ |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.action.Action#run() |
| */ |
| public void run() { |
| try { |
| // ViewHelper.checkLibraryHealth(); |
| |
| LibraryValidateAction validateAction = new LibraryValidateAction(LibraryService.getInstance().getCurrentMethodLibrary()); |
| ((LibraryValidateAction)validateAction).putContextData(LibraryEValidator.CTX_ADAPTER_FACTORY_PROVIDER, |
| ProcessEditor.adapterFactoryProvider); |
| |
| validateAction.run(); |
| |
| |
| |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| }; |
| |
| // 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) { |
| SwitchConfigDialog.run(Display |
| .getCurrent().getActiveShell(), (IEditorPart)part); |
| } |
| } |
| |
| }; |
| |
| private long lastRefreshTimeStamp; |
| |
| private IResourceChangeListener resourceListener = new IResourceChangeListener() { |
| public void resourceChanged(IResourceChangeEvent event) { |
| if (event.getType() == IResourceChangeEvent.PRE_CLOSE || |
| event.getType() == IResourceChangeEvent.PRE_DELETE) { |
| // project about to be closed or deleted |
| IProject project = (IProject)event.getResource(); |
| try { |
| if (project.exists() && project.isOpen() && project.hasNature(MethodLibraryProjectNature.NATURE_ID)) { |
| EditorChooser.getInstance().closeAllMethodEditors(); |
| IProject currProject = MethodLibraryProject.findProject(LibraryService.getInstance().getCurrentMethodLibraryLocation()); |
| if (project == currProject) { |
| LibraryService.getInstance().closeCurrentMethodLibrary(); |
| } |
| } |
| } catch (CoreException cex) { |
| LibraryPlugin.getDefault().getLogger().logError(cex); |
| } catch (LibraryServiceException lex) { |
| LibraryPlugin.getDefault().getLogger().logError(lex); |
| } |
| return; |
| |
| } |
| IResourceDelta delta = event.getDelta(); |
| if (delta == null) |
| return; |
| |
| try { |
| class ResourceDeltaVisitor implements IResourceDeltaVisitor { |
| public boolean visit(IResourceDelta delta) |
| throws CoreException { |
| if ((delta.getFlags() & IResourceDelta.MARKERS) == IResourceDelta.MARKERS) { |
| switch (delta.getKind()) { |
| case IResourceDelta.ADDED: |
| case IResourceDelta.CHANGED: |
| // show Problems View |
| UIHelper.showProblemsView(); |
| return false; |
| } |
| } |
| // watch for project move |
| else if (delta.getResource().getType() == IResource.PROJECT) { |
| if (delta.getKind() == IResourceDelta.CHANGED) { |
| if (((delta.getFlags() & IResourceDelta.REPLACED) == 0) && |
| ((delta.getFlags() & IResourceDelta.DESCRIPTION) != 0)) { |
| // tested using the Move.. command in the Resource Navigator view |
| // the REPLACED flag only seemed to occur when the library was moved |
| // outside of EPF and EPF was re-started, so make sure it's clear, otherwise |
| // we reload the library right after loading it when starting EPF |
| IProject project = (IProject) delta.getResource(); |
| ILibraryManager libMgr = LibraryService.getInstance().getCurrentLibraryManager(); |
| if(libMgr instanceof XMILibraryManager) { |
| XMILibraryManager xmiLibMgr = ((XMILibraryManager)libMgr); |
| if(project.equals(xmiLibMgr.getMethodLibraryProject())) { |
| xmiLibMgr.handleLibraryMoved(); |
| return false; |
| } |
| } |
| //} else if ((delta.getFlags() & IResourceDelta.OPEN) != 0) { |
| } else if ((delta.getFlags() & IResourceDelta.OPEN) != 0 && !ResourcesPlugin.getWorkspace().isTreeLocked()) { |
| // project's open state was changed |
| IProject project = (IProject) delta.getResource(); |
| if (project.isOpen() && project.hasNature(MethodLibraryProjectNature.NATURE_ID) && |
| LibraryService.getInstance().getCurrentMethodLibrary() == null) { |
| // project is now open, open the library |
| java.net.URI projectLocation = project.getLocationURI(); |
| try { |
| LibraryService.getInstance().openMethodLibrary("xmi", projectLocation); //$NON-NLS-1$ |
| } catch (Exception e) { |
| LibraryPlugin.getDefault().getLogger().logError(e); |
| } |
| return false; |
| } |
| } |
| } |
| } |
| return true; |
| } |
| }; |
| |
| ResourceDeltaVisitor visitor = new ResourceDeltaVisitor(); |
| delta.accept(visitor); |
| |
| } catch (CoreException e) { |
| CommonPlugin.INSTANCE.log(e); |
| } |
| |
| } |
| |
| }; |
| |
| private RefreshHandler refreshHandler = new RefreshHandler(this) { |
| |
| @Override |
| public synchronized void doRefresh( |
| Collection<Resource> removedResources, |
| Collection<Resource> changedResources, |
| Collection<IResource> addedWorkspaceResources, |
| boolean refreshViews, IProgressMonitor monitor) { |
| if (!refreshViews) { |
| for (Iterator<Resource> iter = changedResources.iterator(); iter.hasNext();) { |
| Resource resource = (Resource) iter.next(); |
| if (resource instanceof ILibraryResource |
| && ((ILibraryResource) resource).getLoadStamp() > lastRefreshTimeStamp) { |
| refreshViews = true; |
| break; |
| } |
| } |
| } |
| |
| super.doRefresh(removedResources, changedResources, addedWorkspaceResources, |
| refreshViews, monitor); |
| } |
| |
| @Override |
| protected void refreshViews() { |
| LibraryView.this.refreshViews(); |
| } |
| }; |
| |
| private IPropertyListener propertyListener = new IPropertyListener() { |
| public void propertyChanged(Object source, int propId) { |
| // TODO: Replace hardcoded constant with variable. |
| if (propId == 1) { |
| firePropertyChange(PROP_DIRTY); |
| } |
| } |
| }; |
| |
| |
| private LibraryViewExtender extender; |
| protected LibraryViewExtender getExtender() { |
| return extender; |
| } |
| |
| /** |
| * Creates a new instance. |
| */ |
| public LibraryView() { |
| // read layout pref |
| if (PluginUIPackageContext.FLAT_LAYOUT.equals(ApplicationPreferenceConstants.getLayout())) { |
| PluginUIPackageContext.INSTANCE.setLayoutFlat(); |
| } else if (PluginUIPackageContext.HIERARCHICAL_LAYOUT.equals(ApplicationPreferenceConstants.getLayout())) { |
| PluginUIPackageContext.INSTANCE.setLayoutHierarchical(); |
| } |
| |
| INSTANCE = this; |
| |
| extender = AuthoringUIExtensionManager.getInstance().createLibraryViewExtender(this); |
| } |
| |
| /** |
| * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(Composite) |
| */ |
| public void createPartControl(Composite parent) { |
| super.createPartControl(parent); |
| |
| makeActions(); |
| |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(parent, |
| AuthoringUIHelpContexts.LIBRARY_NAVIGATOR_VIEW_CONTEXT); |
| |
| RefreshJob.getInstance().setRefreshHandler(refreshHandler); |
| |
| if (needRegisterChangeListenersInCreate) { |
| needRegisterChangeListenersInCreate = false; |
| registerChangeListeners(); |
| } |
| } |
| |
| private void makeActions() { |
| fLayoutActionSet= new LayoutActionGroup(this); |
| IActionBars actionBars= getViewSite().getActionBars(); |
| fLayoutActionSet.fillActionBars(actionBars); |
| } |
| |
| /** |
| * @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(mostRecentCommand instanceof CreateMethodElementCommand) { |
| // Work-around to refresh icons of newly created elements, whose decoration |
| // sometimes got out of sync. |
| // |
| Viewer viewer = getViewer(); |
| if(viewer instanceof StructuredViewer) { |
| Object[] elements = mostRecentCommand |
| .getAffectedObjects().toArray(); |
| ((StructuredViewer)viewer).update(elements, null); |
| } |
| } |
| } |
| 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 = PersistenceService.INSTANCE |
| .createResourceSet(Services.getDefaultLibraryPersistenceType()); |
| |
| editingDomain = new TraceableAdapterFactoryEditingDomain( |
| adapterFactory, commandStack, resourceSet); |
| |
| |
| treeViewer.setContentProvider(new AdapterFactoryContentProvider( |
| adapterFactory)); |
| |
| // treeViewer.setLabelProvider(new |
| // AdapterFactoryLabelProvider(adapterFactory)); |
| treeViewer.setLabelProvider(new DecoratingLabelProvider( |
| new AdapterFactoryLabelProvider(adapterFactory), |
| new MethodElementLabelDecorator()) { |
| |
| public Font getFont(Object element) { |
| if (customCategoryOwnedByOtherPlugin(element)) { |
| return getItalicFont(); |
| } |
| return super.getFont(element); |
| } |
| |
| private Font getItalicFont() { |
| if (italicFont == null) { |
| italicFont = createFont(SWT.ITALIC); |
| } |
| |
| return italicFont; |
| } |
| |
| private Font createFont(int style) { |
| FontData[] fontdata = Display.getCurrent().getSystemFont().getFontData(); |
| for (FontData data : fontdata) { |
| data.setStyle(style); |
| } |
| |
| return new Font(Display.getCurrent(), fontdata); |
| } |
| }); |
| |
| // 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); |
| |
| ResourcesPlugin.getWorkspace() |
| .addResourceChangeListener(resourceListener); |
| |
| 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); |
| |
| if(adapterFactory instanceof ConfigurableComposedAdapterFactory) { |
| IFilter filter = ((ConfigurableComposedAdapterFactory) adapterFactory).getFilter(); |
| if(filter instanceof INamedFilter) { |
| String name = ((INamedFilter) filter).getName(); |
| if(name != null) { |
| setContentDescription(name); |
| } |
| } |
| } |
| 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); |
| boolean show = ViewHelper.isViewInCurrentPerspective(VIEW_ID); |
| return (LibraryView)ViewHelper.findView(VIEW_ID, show); |
| |
| } |
| |
| /** |
| * Returns this view. |
| */ |
| public static LibraryView getViewInstance() { |
| return INSTANCE; |
| } |
| |
| /** |
| * @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; |
| |
| // ((LibraryViewActionBarContributor) actionBarContributor).checkLocked(); |
| |
| // 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 && uri.isFile()) { |
| 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); |
| } |
| } |
| |
| public void registerChangeListeners() { |
| ILibraryManager manager = (ILibraryManager) LibraryService |
| .getInstance().getCurrentLibraryManager(); |
| if (manager != null) { |
| manager.registerEditingDomain(editingDomain); |
| manager.addPropertyListener(propertyListener); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.epf.library.ILibraryServiceListener#libraryReopened(MethodLibrary) |
| */ |
| public void libraryReopened(MethodLibrary library) { |
| refreshViews(); |
| } |
| |
| @Override |
| public void librarySet(MethodLibrary library) { |
| super.librarySet(library); |
| registerChangeListeners(); |
| } |
| |
| @Override |
| public void libraryClosed(MethodLibrary library) { |
| ILibraryManager manager = (ILibraryManager) LibraryService |
| .getInstance().getCurrentLibraryManager(); |
| if (manager != null) { |
| manager.unregisterEditingDomain(editingDomain); |
| manager.removePropertyListener(propertyListener); |
| } |
| super.libraryClosed(library); |
| } |
| |
| /** |
| * The action bar for the library view |
| */ |
| protected class LibraryViewActionBarContributor extends LibraryActionBarContributor { |
| |
| protected IAction newPluginAction = new NewPluginAction( |
| AuthoringUIResources.new_plugin); |
| |
| private IAction moveAction = new Action(AuthoringUIResources.move) { |
| |
| private void doMove() { |
| 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.errorDialog_title, |
| AuthoringUIResources.errorDialog_moveError, |
| 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); |
| |
| boolean movingCCerror = false; |
| List<CustomCategory> movingCCsrcParents = new ArrayList<CustomCategory>(); |
| int sz = elementsToMove == null ? 0 : elementsToMove.size(); |
| if (sz == 0) { |
| return; |
| } |
| if (elementsToMove.iterator().next() instanceof CustomCategory) { |
| List uiList = ((IStructuredSelection) getSelection()).toList(); |
| if (uiList.size() == sz) { |
| int i = -1; |
| for (Object element : elementsToMove) { |
| i++; |
| Object ui = uiList.get(i); |
| if (ui instanceof WrapperItemProvider) { |
| if (TngUtil.unwrap(ui) != element) { |
| movingCCerror = true; |
| break; |
| } |
| Object parent = ((WrapperItemProvider) ui).getParent(null); |
| if (TngUtil.unwrap(parent) instanceof CustomCategory) { |
| movingCCsrcParents.add((CustomCategory) TngUtil.unwrap(parent)); |
| } else { |
| movingCCerror = true; |
| break; |
| } |
| } else { |
| movingCCerror = true; |
| break; |
| } |
| } |
| } else { |
| movingCCerror = true; |
| } |
| } |
| |
| if (movingCCerror) { |
| AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayError( |
| AuthoringUIResources.errorDialog_title, |
| AuthoringUIResources.errorDialog_moveError); |
| return; |
| } |
| |
| MoveDialog dlg = ! movingCCsrcParents.isEmpty() ? new MoveDialogExt(getSite() |
| .getShell(), elementsToMove, editingDomain, movingCCsrcParents) |
| : new MoveDialog(getSite().getShell(), elementsToMove, |
| editingDomain); |
| dlg.open(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.action.Action#run() |
| */ |
| public void run() { |
| LibraryLockingOperationRunner runner = new LibraryLockingOperationRunner(); |
| runner.setProgressMonitor(getActionBars() |
| .getStatusLineManager().getProgressMonitor()); |
| runner.run(new IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, |
| InterruptedException { |
| doMove(); |
| } |
| |
| }); |
| } |
| }; |
| |
| private LibraryViewSimpleAction assignAction = new AssignAction(LibraryView.this); |
| |
| private LibraryViewSimpleAction unassignAction = new UnassignAction(LibraryView.this); |
| |
| private LibraryViewSimpleAction reassignAction = new ReassignAction(LibraryView.this); |
| |
| private LibraryViewSimpleAction customCategoryDeepCopyAction = new CustomCategoryDeepCopyAction(LibraryView.this); |
| |
| private RenameAction renameAction = new RenameAction(); |
| |
| private IAction replaceAction = new Action( |
| AuthoringUIResources.ElementsView_replaceAction_text) { |
| |
| 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.ElementsView_20; |
| } else if (proc instanceof DeliveryProcess) { |
| typeStr = AuthoringUIResources.ElementsView_21; |
| } else { |
| typeStr = AuthoringUIResources.ElementsView_22; |
| } |
| DirectoryDialog dirDlg = new DirectoryDialog(getSite() |
| .getShell()); |
| dirDlg.setText(AuthoringUIResources.ElementsView_replace_text); |
| dirDlg |
| .setMessage(MessageFormat |
| .format( |
| AuthoringUIResources.ElementsView_migration_dir_dlg_description_text, |
| new Object[] { typeStr })); |
| final String dir = dirDlg.open(); |
| if (dir == null) { |
| return; |
| } |
| |
| boolean ret = UserInteractionHelper |
| .runWithProgress( |
| new org.eclipse.epf.library.edit.util.IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, |
| InterruptedException { |
| try { |
| ImportExportUtil.replace(procComp, |
| dir); |
| } catch (Exception e) { |
| throw new WrappedException(e); |
| } |
| } |
| }, |
| MessageFormat |
| .format( |
| AuthoringUIResources.ElementsView_replaceingwithformat_text, |
| new Object[] { typeStr })); |
| |
| if (ret) { |
| // Reopen the library. |
| LibraryUIManager.getInstance().openLibrary( |
| LibraryService.getInstance() |
| .getCurrentMethodLibraryLocation()); |
| } |
| } |
| }; |
| |
| private IAction openVariabilityDialogAction = new Action( |
| AuthoringUIResources.ElementsView_openVariabilityDialogAction_text) { |
| 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 canMove; |
| |
| private boolean canAssign; |
| |
| private IAction showInResourceNavigatorAction = new Action( |
| AuthoringUIResources.showInResourceNavigatorAction_label) { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.action.Action#run() |
| */ |
| public void run() { |
| ResourceNavigator navigator; |
| try { |
| navigator = (ResourceNavigator) getPage().showView( |
| "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); |
| } |
| } catch (PartInitException e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| }; |
| |
| private boolean canRename; |
| |
| /** |
| * Creates a new instance. |
| */ |
| public LibraryViewActionBarContributor(EditingDomain editingDomain) { |
| super(editingDomain); |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor#createDeleteAction() |
| */ |
| protected DeleteAction createDeleteAction() { |
| LibraryViewDeleteAction action = 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.actions_LibraryActionBarContributor_deleteErrorTitle; |
| try { |
| super.run(); |
| } catch (MessageException e) { |
| AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayError(title, e.getMessage()); |
| } catch (Exception e) { |
| String details = TngUtil.toStackTraceString(e); |
| String message = AuthoringUIResources.actions_LibraryActionBarContributor_deleteErrorMessage; |
| String reason = AuthoringUIResources.actions_LibraryActionBarContributor_deleteErrorReason; |
| AuthoringUIPlugin.getDefault().getMsgDialog() |
| .displayError(title, message, reason, details, |
| e); |
| } |
| } |
| |
| protected void deleteFailed() { |
| // Library need to be reloaded. |
| ViewHelper.reloadCurrentLibrary(getSite().getShell(), AuthoringUIResources.msg_reloadLibrary); |
| |
| // 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); |
| } |
| } |
| } |
| }; |
| action.setProgressMonitor(getActionBars().getStatusLineManager() |
| .getProgressMonitor()); |
| return action; |
| } |
| |
| /** |
| * @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(){ |
| |
| @Override |
| public boolean updateSelection(IStructuredSelection selection) { |
| if( ViewHelper.hasCustomizedLocker((IStructuredSelection) selection) && locked ){ |
| return false; |
| } |
| return super.updateSelection(selection); |
| } |
| |
| }; |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor#createPasteAction() |
| */ |
| protected PasteAction createPasteAction() { |
| LibraryViewPasteAction action = 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); |
| } |
| }; |
| action.setProgressMonitor(getActionBars().getStatusLineManager() |
| .getProgressMonitor()); |
| return action; |
| } |
| |
| private void checkLocked() { |
| if (selection instanceof IStructuredSelection) { |
| boolean wasLocked = locked; |
| // locked = ViewHelper.isLocked((IStructuredSelection) selection); |
| if(ViewHelper.hasCustomizedLocker((IStructuredSelection) selection) ){ |
| locked = ViewHelper.isLockedWithCustomizedLocker((IStructuredSelection) selection); |
| }else{ |
| 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); |
| |
| //assignAction.setEnabled(enabled); |
| unassignAction.setEnabled(enabled); |
| reassignAction.setEnabled(enabled); |
| //customCategoryDeepCopyAction.setEnabled(enabled); |
| } |
| } |
| } |
| |
| void updateSelection(ISelection selection) { |
| updateSelection_(selection); |
| getExtender().getActionBarExtender().updateSelection(selection); |
| } |
| |
| void updateSelection_(ISelection selection) { |
| IStructuredSelection sel = (IStructuredSelection) selection; |
| |
| renameAction.setActiveWorkbenchPart(LibraryView.this); |
| canRename = renameAction.updateSelection(sel); |
| |
| // locked = ViewHelper.isLocked(sel); |
| if(ViewHelper.hasCustomizedLocker(sel) ){ |
| locked = ViewHelper.isLockedWithCustomizedLocker(sel); |
| }else{ |
| locked = ViewHelper.isLocked(sel); |
| } |
| |
| boolean enabled = !locked; |
| if(canRename && !enabled) { |
| renameAction.setEnabled(enabled); |
| } |
| moveAction.setEnabled(enabled); |
| |
| unassignAction.setEnabled(enabled); |
| reassignAction.setEnabled(enabled); |
| |
| canMove = canMove(sel); |
| |
| canAssign = assignAction.updateSelection(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); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor#enableGlobalEditMenu() |
| */ |
| 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) { |
| int ix = canMoveCheck4CustomCategories(selection); |
| if (ix != 0) { |
| return ix == 1; |
| } |
| |
| MethodPlugin srcPlugin = null; |
| for (Iterator iter = selection.iterator(); iter.hasNext();) { |
| Object element = iter.next(); |
| if (element instanceof MethodElement) { |
| MethodPlugin plugin = UmaUtil.getMethodPlugin((MethodElement) element); |
| if (plugin == null) { |
| return false; |
| } else if (plugin != srcPlugin) { |
| if (srcPlugin != null) { |
| return false; |
| } |
| srcPlugin = plugin; |
| } |
| } |
| } |
| |
| 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; |
| } |
| |
| //-1: cannot move |
| //0: need futhre check |
| //1: can move |
| private int canMoveCheck4CustomCategories(IStructuredSelection selection) { |
| boolean hasCC = false; |
| boolean hasOther = false; |
| for (Iterator iter = selection.iterator(); iter.hasNext();) { |
| Object obj = iter.next(); |
| if (obj instanceof WrapperItemProvider && TngUtil.unwrap(obj) instanceof CustomCategory) { |
| if (customCategoryOwnedByOtherPlugin(obj)) { |
| return -1; |
| } |
| hasCC = true; |
| } else { |
| hasOther = true; |
| } |
| if (hasCC && hasOther) { |
| return -1; |
| } |
| } |
| return hasCC ? 1 : 0; |
| } |
| |
| |
| /** |
| * Adds Separators for editor additions to the tool bar. |
| */ |
| public void contributeToToolBar(IToolBarManager toolBarManager) { |
| // toolBarManager.add(new Separator("method-settings")); //$NON-NLS-1$ |
| // toolBarManager.add(new Separator("method-additions")); //$NON-NLS-1$ |
| performLibraryValidationAction.setId(PERFORM_ID); |
| // if (AuthoringUIPreferences.getEnableLibraryValidation()) { |
| toolBarManager.add(performLibraryValidationAction); |
| // } |
| |
| } |
| |
| /** |
| * @see LibraryActionBarContributor#menuAboutToShow(IMenuManager) |
| */ |
| public void menuAboutToShow(IMenuManager menuManager) { |
| menuAboutToShow_(menuManager); |
| getExtender().getActionBarExtender().menuAboutToShow(menuManager); |
| } |
| |
| private void menuAboutToShow_(IMenuManager menuManager) { |
| // This is needed to enable Paste after Copy but the selection has not been changed yet |
| // |
| updatePasteAction(); |
| |
| 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)); |
| } |
| |
| if (canAssign) { |
| menuManager.add(new ActionContributionItem(assignAction)); |
| menuManager.add(new ActionContributionItem(unassignAction)); |
| menuManager.add(new ActionContributionItem(reassignAction)); |
| menuManager.add(new ActionContributionItem(customCategoryDeepCopyAction)); |
| } |
| |
| 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( |
| AuthoringUIResources._UI_CreateChild_menu_item, |
| AuthoringUIResources._UI_CreateChild_menu_item); |
| populateManager(submenuManager, createChildActions, null); |
| menuManager.insertBefore("fixed-additions", submenuManager); //$NON-NLS-1$ |
| } |
| |
| // menuManager.add(new Action("Test") { |
| // /* |
| // * (non-Javadoc) |
| // * |
| // * @see org.eclipse.jface.action.Action#run() |
| // */ |
| // public void run() { |
| // // reload |
| // // |
| //// ISelection selection = getSelection(); |
| //// if (selection instanceof IStructuredSelection) { |
| //// Object object = ((IStructuredSelection) selection) |
| //// .getFirstElement(); |
| //// object = TngUtil.unwrap(object); |
| //// if (object instanceof InternalEObject) { |
| //// InternalEObject e = ((InternalEObject) object); |
| //// ILibraryResourceSet resourceSet = (ILibraryResourceSet) e |
| //// .eResource().getResourceSet(); |
| //// resourceSet.unload(e); |
| //// URI uri = e.eProxyURI(); |
| //// EObject newObject = resourceSet.getEObject(e, uri, |
| //// true); |
| //// refreshViews(); |
| //// } |
| //// } |
| // |
| // // plugin/config folder |
| // // |
| // ILibraryPersister persister = LibraryServiceUtil.getCurrentPersister(); |
| // if(persister instanceof IFileBasedLibraryPersister) { |
| // IFileBasedLibraryPersister filePersister = (IFileBasedLibraryPersister) persister; |
| // MethodLibrary library = LibraryService.getInstance().getCurrentMethodLibrary(); |
| // try { |
| // File file = filePersister.createMethodPluginFolder("plugin100", library); |
| // System.out.println("plugin dir: " + file); |
| // } |
| // catch(Exception e) { |
| // e.printStackTrace(); |
| // } |
| // try { |
| // File file = filePersister.getDefaultMethodConfigurationFolder(library); |
| // System.out.println("config dir: " + file); |
| // } |
| // catch(Exception e) { |
| // e.printStackTrace(); |
| // } |
| // } |
| // } |
| // }); |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.authoring.ui.actions.LibraryActionBarContributor#refreshViewer(org.eclipse.jface.viewers.Viewer) |
| */ |
| protected void refreshViewer(final Viewer viewer) { |
| if (viewer == LibraryView.this.getViewer()) { |
| ILibraryManager manager = (ILibraryManager) LibraryService |
| .getInstance().getCurrentLibraryManager(); |
| if (manager != null) { |
| ResourceSet resourceSet = manager.getEditingDomain() |
| .getResourceSet(); |
| if (resourceSet instanceof ILibraryResourceSet) { |
| final ILibraryResourceSet libResourceSet = (ILibraryResourceSet) resourceSet; |
| if(libResourceSet.getPersistenceType().equals(Services.XMI_PERSISTENCE_TYPE)) { |
| IRunnableWithProgress runnable = new IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, |
| InterruptedException { |
| List<Resource> resources = new ArrayList<Resource>(libResourceSet.getResources()); |
| int totalWorks = resources.size() + 3; |
| monitor.beginTask(AuthoringUIResources._UI_RefreshViewer_menu_item, totalWorks); //$NON-NLS-1$ |
| try { |
| // Refresh all loaded resources and load newly added resources |
| // |
| monitor.subTask("Loading new resources..."); |
| monitor.worked(1); |
| libResourceSet.loadNewResources(); |
| |
| List<Resource> removedResources = new ArrayList<Resource>(); |
| List<Resource> changedResources = new ArrayList<Resource>(); |
| for (Resource resource : resources) { |
| String loc = resource.getURI().toFileString(); |
| monitor.subTask(NLS.bind("Checking resource ''{0}''...", loc)); |
| monitor.worked(1); |
| IResource wsRes = FileManager.getResourceForLocation(loc); |
| if (wsRes == null) { |
| removedResources.add(resource); |
| } else if (!wsRes.isSynchronized(IResource.DEPTH_ZERO)) { |
| changedResources.add(resource); |
| } |
| } |
| monitor.subTask("Refreshing UI..."); |
| monitor.worked(2); |
| if (removedResources.isEmpty() |
| && changedResources.isEmpty()) { |
| viewer.refresh(); |
| } else { |
| refreshHandler.doRefresh(removedResources, |
| changedResources, null, false, new NullProgressMonitor()); |
| } |
| } 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.ProcessEditor_refreshErrorTitle; |
| AuthoringUIPlugin.getDefault().getMsgDialog().displayError( |
| title, e.toString(), e); |
| } |
| return; |
| } |
| } |
| } |
| } |
| super.refreshViewer(viewer); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.authoring.ui.views.AbstractBaseView#createActionBarContributor() |
| */ |
| public ILibraryActionBarContributor createActionBarContributor() { |
| ILibraryActionBarContributor actionBar = new LibraryViewActionBarContributor( |
| editingDomain); |
| return actionBar; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.authoring.ui.views.AbstractBaseView#createContextMenuFor(org.eclipse.jface.viewers.StructuredViewer) |
| */ |
| public void createContextMenuFor(final StructuredViewer viewer) { |
| super.createContextMenuFor(viewer); |
| int dndOperations = DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK; |
| Transfer[] transfers = new Transfer[] { HTMLTransfer.getInstance(), |
| TextTransfer.getInstance(), LocalTransfer.getInstance() }; |
| viewer.addDragSupport(dndOperations, transfers, |
| createDragSourceListener(viewer)); |
| } |
| |
| protected DragSourceListener createDragSourceListener(Viewer viewer) { |
| return new LibraryViewerDragAdapter(viewer); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.authoring.ui.views.AbstractBaseView#menuAboutToShow(org.eclipse.jface.action.IMenuManager) |
| */ |
| public void menuAboutToShow(IMenuManager menuManager) { |
| super.menuAboutToShow(menuManager); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.part.ViewPart#init(org.eclipse.ui.IViewSite) |
| */ |
| public void init(IViewSite site) throws PartInitException { |
| super.init(site); |
| |
| // add property change listener for library validation preference |
| AuthoringUIPlugin.getDefault().getPreferenceStore() |
| .addPropertyChangeListener(new IPropertyChangeListener() { |
| public void propertyChange(PropertyChangeEvent event) { |
| // if (event |
| // .getProperty() |
| // .equals( |
| // AuthoringUIPreferences.ENABLE_LIBRARY_VALIDATION)) { |
| // Boolean enabled = (Boolean) event.getNewValue(); |
| // IToolBarManager toolBarManager = getViewSite() |
| // .getActionBars().getToolBarManager(); |
| // |
| // if (enabled != null && enabled.booleanValue()) { //always on now |
| // performLibraryValidationAction |
| // .setId(PERFORM_ID); |
| // toolBarManager.insertAfter("additions", performLibraryValidationAction); //$NON-NLS-1$ |
| // } else { |
| // IContributionItem[] items = toolBarManager.getItems(); |
| // for (int i = 0; i < items.length; i++) { |
| // IContributionItem item = (IContributionItem) items[i]; |
| // if (item.getId().equals(PERFORM_ID)) |
| // toolBarManager.remove(item); |
| // } |
| // } |
| // toolBarManager.update(true); |
| // } |
| } |
| }); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.authoring.ui.views.AbstractBaseView#dispose() |
| */ |
| public void dispose() { |
| RefreshJob.getInstance().setRefreshHandler(null); |
| |
| if (fLayoutActionSet != null) |
| fLayoutActionSet.dispose(); |
| |
| super.dispose(); |
| if (doubleClickListener != null) { |
| treeViewer.removeDoubleClickListener(doubleClickListener); |
| } |
| |
| if (italicFont != null) { |
| italicFont.dispose(); |
| } |
| } |
| |
| /** |
| * @param obj |
| * ItemProvider |
| * @return ProcessComponent associated with the given obj |
| */ |
| 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; |
| } |
| } |
| |
| /** |
| * opens a Method Library |
| * |
| * @param path |
| * path to the library |
| */ |
| 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.openingLibraryTask_name, |
| 2); |
| try { |
| monitor.worked(1); |
| LibraryService.getInstance().closeCurrentMethodLibrary(); |
| MethodLibrary library = XMILibraryUtil |
| .openMethodLibrary(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.bind( |
| AuthoringUIResources.ElementsView_35, |
| (new Object[] { projectFileName })); |
| if (MsgBox.prompt(prompt, SWT.RETRY | SWT.CANCEL) == SWT.RETRY) { |
| openLibrary(path); |
| } |
| } |
| } else { |
| AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayError( |
| AuthoringUIResources.errorDialog_title, |
| AuthoringUIResources.openLibraryError_msg, |
| 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); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.authoring.ui.views.AbstractBaseView#handleActivate(org.eclipse.ui.IWorkbenchPart) |
| */ |
| protected void handleActivate(IWorkbenchPart part) { |
| super.handleActivate(part); |
| |
| // TODO: Review implementation. |
| // Make sure that the method library open is not closed. |
| XMILibraryUtil.openMethodLibraryProject(LibraryService.getInstance() |
| .getCurrentMethodLibrary(), getViewSite().getActionBars() |
| .getStatusLineManager().getProgressMonitor()); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.authoring.ui.views.SaveableLibraryViewPart#isSaveAsAllowed() |
| */ |
| 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() { |
| } |
| |
| /** |
| * 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 object) { |
| Object o = TngUtil.unwrap(object); |
| if (!(o instanceof MethodElement)) |
| return; |
| if (o instanceof MethodConfiguration) { |
| super.setSelectionToViewer(Arrays.asList(new Object[] { o })); |
| return; |
| } |
| try { |
| MethodPlugin plugin = UmaUtil.getMethodPlugin((MethodElement) o); |
| |
| MethodPluginItemProvider pluginAdapter = (MethodPluginItemProvider) TngUtil |
| .getAdapter(plugin, MethodPluginItemProvider.class); |
| |
| MethodLibraryItemProvider libraryAdapter = (MethodLibraryItemProvider) TngUtil |
| .getAdapter(LibraryService.getInstance().getCurrentMethodLibrary(), MethodLibraryItemProvider.class); |
| |
| // expand plugin packages |
| ItemProviderAdapter pluginTreeAdapter = libraryAdapter.getPluginItemProvider(plugin); |
| while (pluginTreeAdapter instanceof PluginUIPackagesItemProvider) { |
| treeViewer.setExpandedState(pluginTreeAdapter, true); |
| pluginTreeAdapter = ((PluginUIPackagesItemProvider)pluginTreeAdapter).getPluginItemProvider(plugin); |
| } |
| treeViewer.setExpandedState(plugin, true); |
| |
| |
| if (o instanceof BreakdownElement) { |
| Process proc = TngUtil.getOwningProcess((BreakdownElement)o); |
| if(proc != null) { |
| o = proc.eContainer(); |
| } |
| } |
| if (o instanceof ProcessComponent || o instanceof ProcessPackage) { |
| |
| if (pluginAdapter != null) { //Check null pointer here. To do: fix the root cause so that pluginAdapte would not be null here. |
| treeViewer.setExpandedState(pluginAdapter.getChildren(plugin) |
| .toArray()[1], true); |
| // Expand the process packages. |
| expandTreeViewerPackages(((MethodElement) o).eContainer()); |
| } |
| |
| } else if (pluginAdapter != null) { |
| ITreeItemContentProvider methodContentPkg = (ITreeItemContentProvider) pluginAdapter |
| .getChildren(plugin).toArray()[0]; |
| treeViewer.setExpandedState(methodContentPkg, true); |
| |
| if (o instanceof CustomCategory) { |
| CustomCategory rootCC = TngUtil |
| .getRootCustomCategory(plugin); |
| |
| // find the tree path to the custom category from the root custom category |
| // |
| final List<Object> treePath = new ArrayList<Object>(); |
| for(CustomCategory cc = (CustomCategory) o; cc != rootCC;) { |
| treePath.add(0, cc); |
| cc = (CustomCategory) AssociationHelper.getCustomCategories(cc).get(0); |
| } |
| |
| o = expandTree(rootCC, treePath); |
| |
| } else if (o instanceof ContentCategory) { |
| Object stdCats = methodContentPkg.getChildren(o).toArray()[1]; |
| |
| // find the tree path to the category from the root "Standard Categories" category |
| // |
| final List<Object> treePath = new ArrayList<Object>(); |
| if (o instanceof Discipline) { |
| // disciplines can nest |
| Object dis = o; |
| do { |
| treePath.add(0, dis); |
| List parentDisc = AssociationHelper.getDiscipline((Discipline)dis); |
| if (parentDisc.isEmpty()) break; |
| dis = parentDisc.get(0); |
| } while (true); |
| // get discipline group |
| if (!AssociationHelper.getDisciplineGroups((Discipline)dis).isEmpty()) { |
| DisciplineGrouping dg = (DisciplineGrouping) AssociationHelper.getDisciplineGroups((Discipline)dis).get(0); |
| treePath.add(0, dg); |
| } |
| // get "Disciplines" |
| treePath.add(0, TngUtil.getDisciplineCategoriesItemProvider(plugin)); |
| o = expandTree(stdCats, treePath); |
| } else if (o instanceof RoleSet) { |
| // rolesets cannot nest |
| treePath.add(0, o); |
| RoleSetGrouping rsg = (RoleSetGrouping) AssociationHelper.getRoleSetGroups((RoleSet)o).get(0); |
| treePath.add(0, rsg); |
| // get "RoleSets" |
| treePath.add(0, TngUtil.getRoleSetsItemProvider(plugin)); |
| o = expandTree(stdCats, treePath); |
| } else { |
| 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 })); |
| |
| if(o instanceof ProcessComponent && object instanceof BreakdownElement) { |
| // open the process in its editor and select the breakdown element |
| // |
| IEditorKeeper.REFERENCE.getEditorKeeper().openEditor(o); |
| IEditorPart editor = getSite().getPage().findEditor(new MethodElementEditorInput((MethodElement) o)); |
| if(editor instanceof ProcessEditor) { |
| ProcessEditor procEditor = ((ProcessEditor)editor); |
| String pageId; |
| if(object instanceof RoleDescriptor || object instanceof TeamProfile) { |
| pageId = ProcessEditor.TA_FORM_ID; |
| } |
| else if(object instanceof WorkProductDescriptor) { |
| pageId = ProcessEditor.WPBS_FORM_ID; |
| } |
| else { |
| pageId = ProcessEditor.WBS_FORM_ID; |
| } |
| procEditor.setActivePage(pageId); |
| procEditor.setSelectionToViewer(Collections.singletonList(object)); |
| } |
| } |
| } |
| |
| private Object expandTree(Object root, List treePath) { |
| Object parent = root; |
| int size = treePath.size(); |
| for (int i = 0; i < size; i++) { |
| Object e = treePath.get(i); |
| treeViewer.setExpandedState(parent, true); |
| // get wrapper |
| // |
| List notifyChangedListeners = TngUtil.getNotifyChangedListeners(adapterFactory, e); |
| if (!notifyChangedListeners.isEmpty()) { |
| find_wrapper: |
| for (Iterator iterator = notifyChangedListeners.iterator(); iterator.hasNext();) { |
| Object listener = iterator.next(); |
| if(listener instanceof FeatureValueWrapperItemProvider |
| && TngUtil.unwrap(listener) == e) { |
| FeatureValueWrapperItemProvider wrapper = (FeatureValueWrapperItemProvider) listener; |
| for(;wrapper != null && wrapper.getOwner() != parent; |
| wrapper = TngUtil.getWrapper(wrapper.getNotifyChangedListeners(), e)) { |
| } |
| if(wrapper != null) { |
| parent = wrapper; |
| break find_wrapper; |
| } |
| } |
| } |
| } else { |
| parent = e; |
| } |
| } |
| return parent; |
| |
| } |
| |
| private void expandTreeViewerPackages(EObject e) { |
| if (e == null) |
| return; |
| if (e instanceof ContentPackage || e instanceof ProcessPackage) { |
| expandTreeViewerPackages(e.eContainer()); |
| treeViewer.setExpandedState(e, true); |
| } |
| } |
| |
| /** |
| * Refreshes Library and Configuration views if necessary |
| * |
| */ |
| public synchronized 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) { |
| if (MultiResourceEObject.epfDebug(1)) { |
| AuthoringUIPlugin.getDefault().getLogger() |
| .logError(e); |
| } |
| } |
| } else { |
| ViewHelper.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(); |
| ViewHelper.restoreSelection(configView.getViewer(), selection); |
| } |
| } |
| } |
| } |
| } |
| |
| private Object[] selectDirtyEditors(List<?> dirtyEditors) { |
| return RefreshHandler.selectDirtyEditors(dirtyEditors, getSite().getShell()); |
| } |
| |
| /** |
| * rename an element |
| * |
| * @param e |
| * element to rename |
| * @param newName |
| * the new name |
| */ |
| public static void runRename(final NamedElement e, final String newName) { |
| Display.getDefault().syncExec(new Runnable() { |
| public void run() { |
| RenameAction.doRename(e, newName); |
| } |
| }); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.part.IShowInTarget#show(org.eclipse.ui.part.ShowInContext) |
| */ |
| public boolean show(ShowInContext context) { |
| // special handling for ShowInContext from problems view |
| // |
| if (context.getInput() instanceof MarkerAdapter) { |
| IViewPart view = getViewSite().getPage().findView( |
| "org.eclipse.ui.views.ProblemView"); //$NON-NLS-1$ |
| ISelectionProvider selectionProvider = view.getViewSite() |
| .getSelectionProvider(); |
| StructuredSelection selection = (StructuredSelection) selectionProvider |
| .getSelection(); |
| Object o = selection.getFirstElement(); |
| if (o instanceof IMarker) { |
| IMarker marker = (IMarker) o; |
| try { |
| String guid = (String) marker |
| .getAttribute(LibraryValidationMarkerHelper.GUID); |
| if (guid != null) { |
| IResource wsRes = marker.getResource(); |
| ILibraryManager libMgr = LibraryService.getInstance().getCurrentLibraryManager(); |
| Resource resource = libMgr.getEditingDomain().getResourceSet() |
| .getResource( |
| URI.createFileURI(wsRes.getLocation() |
| .toString()), false); |
| Object element; |
| if(resource != null) { |
| element = resource.getEObject(guid); |
| } |
| else { |
| element = libMgr.getMethodElement(guid); |
| } |
| if(element != null) { |
| setSelectionToViewer(element); |
| return true; |
| } |
| } |
| } catch (CoreException e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| } |
| ISelection contextSelection = context.getSelection(); |
| if (context.getSelection() instanceof TreeSelection) { |
| // from search results view |
| TreeSelection sel = (TreeSelection)context.getSelection(); |
| setSelectionToViewer(sel.getFirstElement()); |
| } else if (contextSelection instanceof StructuredSelection) { |
| // from problems view, perhaps others? |
| StructuredSelection sel = (StructuredSelection)contextSelection; |
| Object firstObj = sel.getFirstElement(); |
| if (firstObj instanceof IResource) { |
| IResource wsRes = (IResource)firstObj; |
| ILibraryManager libMgr = LibraryService.getInstance().getCurrentLibraryManager(); |
| Resource resource = libMgr.getEditingDomain().getResourceSet() |
| .getResource( |
| URI.createFileURI(wsRes.getLocation() |
| .toString()), false); |
| Object element = PersistenceUtil.getMethodElement(resource); |
| if(element != null) { |
| setSelectionToViewer(element); |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| @Override |
| public String getViewId() { |
| return VIEW_ID; |
| } |
| |
| public TreeViewer getTreeViewer() { |
| return treeViewer; |
| } |
| |
| @Override |
| public void setContentDescription(String description) { |
| super.setContentDescription(description); |
| } |
| |
| public void refresh(IProgressMonitor monitor) { |
| refreshHandler.refresh(monitor); |
| } |
| |
| private boolean customCategoryOwnedByOtherPlugin(Object element) { |
| if (!(element instanceof WrapperItemProvider)) { |
| return false; |
| } |
| Object unwrapped = TngUtil.unwrap(element); |
| if (! (unwrapped instanceof CustomCategory)) { |
| return false; |
| } |
| CustomCategory cc = (CustomCategory) unwrapped; |
| |
| while (element instanceof WrapperItemProvider) { |
| element = ((WrapperItemProvider) element).getParent(null); |
| } |
| if (element instanceof CustomCategory) { |
| return UmaUtil.getMethodPlugin(cc) != UmaUtil.getMethodPlugin((CustomCategory) element); |
| } |
| return false; |
| } |
| |
| public ISelection getCachedSelection() { |
| return selection; |
| } |
| } |
