//------------------------------------------------------------------------------
// 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;
public 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);
getExtender().getActionBarExtender().contributeToViewMenu(actionBars.getMenuManager());
}
/**
* @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;
}
}