//------------------------------------------------------------------------------
// 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.util.Collection;
import java.util.Collections;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.ui.viewer.IViewerProvider;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EValidator;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.domain.IEditingDomainProvider;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
import org.eclipse.epf.authoring.ui.AuthoringUIPlugin;
import org.eclipse.epf.authoring.ui.AuthoringUIResources;
import org.eclipse.epf.authoring.ui.UIActionDispatcher;
import org.eclipse.epf.authoring.ui.actions.ILibraryActionBarContributor;
import org.eclipse.epf.authoring.ui.providers.IContentProviderFactory;
import org.eclipse.epf.library.ILibraryManager;
import org.eclipse.epf.library.ILibraryServiceListener;
import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.library.ui.LibraryUIManager;
import org.eclipse.epf.library.ui.LibraryUIUtil;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWindowListener;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.ide.IGotoMarker;
import org.eclipse.ui.views.properties.IPropertySheetPage;
import org.eclipse.ui.views.properties.PropertySheetPage;
import org.osgi.framework.Bundle;
/**
* The abstract base class for all Method Library views.
*
* @author Phong Nguyen Le
* @author Shilpa Toraskar
* @author Kelvin Low
* @since 1.0
*/
public abstract class AbstractBaseView extends SaveableLibraryViewPart
implements IEditingDomainProvider, ISelectionProvider,
ILibraryServiceListener, IMenuListener, IViewerProvider, IGotoMarker {
protected AdapterFactoryEditingDomain editingDomain;
protected PropertySheetPage propertySheetPage;
protected UIActionDispatcher actionDispatcher = null;
protected AdapterFactory adapterFactory;
protected ILibraryActionBarContributor actionBarContributor;
protected ISelectionChangedListener selectionChangedListener;
protected IPartListener partListener = new IPartListener() {
public void partActivated(IWorkbenchPart part) {
if (part == AbstractBaseView.this) {
handleActivate(part);
}
}
public void partBroughtToTop(IWorkbenchPart part) {
}
public void partClosed(IWorkbenchPart part) {
}
public void partDeactivated(IWorkbenchPart part) {
}
public void partOpened(IWorkbenchPart part) {
}
};
/**
* Handles the activation of this view.
*/
protected void handleActivate(IWorkbenchPart part) {
// Set the right adapter factory for the editing domain.
editingDomain.setAdapterFactory(adapterFactory);
// Recompute the read only state.
if (editingDomain.getResourceToReadOnlyMap() != null) {
editingDomain.getResourceToReadOnlyMap().clear();
// Refresh any actions that may become enabled or disabled.
setSelection(getSelection());
}
}
// this window listener is for opening the library when the
// view first becomes visible
private IWindowListener windowListener = new IWindowListener() {
public void windowActivated(IWorkbenchWindow window) {
}
public void windowClosed(IWorkbenchWindow window) {
}
public void windowDeactivated(IWorkbenchWindow window) {
}
public void windowOpened(IWorkbenchWindow window) {
window.getWorkbench().removeWindowListener(this);
boolean isVisible = getSite().getPage().isPartVisible(AbstractBaseView.this);
if (isVisible) {
LibraryUIManager.getInstance().startupOpenLibrary();
} else {
LibraryUIManager.getInstance().addMethodViewPartListener(getViewId());
}
}
};
private IContentProviderFactory contentProviderFactory;
/**
* Displays a dialog that asks if conflicting changes should be discarded.
*/
protected boolean handleDirtyConflict() {
String title = AuthoringUIResources._UI_FileConflict_label;
String msg = AuthoringUIResources._WARN_FileConflict;
return AuthoringUIPlugin.getDefault().getMsgDialog().displayPrompt(
title, msg);
}
/**
* Handles changed resources when this view is activated.
*/
protected void handleChangedResources() {
}
/**
* @see org.eclipse.ui.part.WorkbenchPart#createPartControl(Composite)
*/
public void createPartControl(Composite parent) {
init();
actionDispatcher = new UIActionDispatcher(this);
// Create the viewer.
createViewer(parent);
// Create and initialize the action bar contributor.
try {
actionBarContributor = createActionBarContributor();
actionBarContributor.init(getViewSite().getActionBars(), getSite()
.getPage());
} catch (Exception e) {
AuthoringUIPlugin.getDefault().getLogger().logError(e);
}
// Add a selection change listener for the viewer.
Viewer viewer = getViewer();
if (viewer != null) {
if (selectionChangedListener == null) {
selectionChangedListener = new ISelectionChangedListener() {
public void selectionChanged(
SelectionChangedEvent selectionChangedEvent) {
setSelection(selectionChangedEvent.getSelection());
}
};
}
viewer.addSelectionChangedListener(selectionChangedListener);
}
// Add a library service listener.
LibraryService.getInstance().addListener(this);
Object library = LibraryService.getInstance().getCurrentMethodLibrary();
if (library != null) {
setInputForViewer(library);
LibraryUIUtil.updateShellTitle();
}
IWorkbench workbench = AuthoringUIPlugin.getDefault().getWorkbench();
if (workbench != null) {
workbench.addWindowListener(windowListener);
}
}
private void init() {
ILibraryManager manager = (ILibraryManager) LibraryService
.getInstance().getCurrentLibraryManager();
if (manager != null) {
editingDomain = manager.getEditingDomain();
adapterFactory = (ComposedAdapterFactory) editingDomain
.getAdapterFactory();
}
IViewSite site = (IViewSite) this.getSite();
site.setSelectionProvider(this);
site.getPage().addPartListener(partListener);
}
/**
* creates a context menu for the viewer
* @param viewer
*/
public void createContextMenuFor(final StructuredViewer viewer) {
MenuManager contextMenu = new MenuManager("#PopUp"); //$NON-NLS-1$
contextMenu.add(new Separator("additions")); //$NON-NLS-1$
contextMenu.setRemoveAllWhenShown(true);
contextMenu.addMenuListener(this);
Menu menu = contextMenu.createContextMenu(viewer.getControl());
viewer.getControl().setMenu(menu);
getSite().registerContextMenu(contextMenu, viewer);
}
/*
* (non-Javadoc)
* @see org.eclipse.jface.action.IMenuListener#menuAboutToShow(org.eclipse.jface.action.IMenuManager)
*/
public void menuAboutToShow(IMenuManager menuManager) {
try {
actionBarContributor.setActiveView(this);
actionBarContributor.menuAboutToShow(menuManager);
} catch (RuntimeException e) {
AuthoringUIPlugin.getDefault().getLogger().logError(e);
throw e;
}
}
/*
* (non-Javadoc)
* @see org.eclipse.ui.part.WorkbenchPart#setFocus()
*/
public void setFocus() {
}
/**
* @see org.eclipse.emf.edit.domain.IEditingDomainProvider#getEditingDomain()
*/
public EditingDomain getEditingDomain() {
return editingDomain;
}
/*
* (non-Javadoc)
* @see org.eclipse.jface.viewers.ISelectionProvider#addSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener)
*/
public void addSelectionChangedListener(ISelectionChangedListener listener) {
actionDispatcher.addSelectionChangedListener(listener);
}
/*
* (non-Javadoc)
* @see org.eclipse.jface.viewers.ISelectionProvider#removeSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener)
*/
public void removeSelectionChangedListener(
ISelectionChangedListener listener) {
actionDispatcher.removeSelectionChangedListener(listener);
}
/**
* @see org.eclipse.ui.part.WorkbenchPart#getAdapter(Class)
*/
public Object getAdapter(Class key) {
if (key.equals(IGotoMarker.class)) {
return this;
} else {
return super.getAdapter(key);
}
}
/*
* (non-Javadoc)
* @see org.eclipse.jface.viewers.ISelectionProvider#getSelection()
*/
public ISelection getSelection() {
return actionDispatcher.getSelection();
}
/*
* (non-Javadoc)
* @see org.eclipse.jface.viewers.ISelectionProvider#setSelection(org.eclipse.jface.viewers.ISelection)
*/
public void setSelection(ISelection selection) {
setSelection(this, selection);
}
private void setSelection(ISelectionProvider source, ISelection selection) {
actionDispatcher.setSelection(source, selection);
UIActionDispatcher.getInstance().setSelection(source, selection);
}
/**
* @see org.eclipse.epf.library.ILibraryServiceListener#libraryCreated(MethodLibrary)
*/
public void libraryCreated(MethodLibrary library) {
}
/**
* @see org.eclipse.epf.library.ILibraryServiceListener#libraryOpened(MethodLibrary)
*/
public void libraryOpened(MethodLibrary library) {
}
/**
* @see org.eclipse.epf.library.ILibraryServiceListener#libraryReopened(MethodLibrary)
*/
public void libraryReopened(MethodLibrary library) {
}
/**
* @see org.eclipse.epf.library.ILibraryServiceListener#libraryClosed(MethodLibrary)
*/
public void libraryClosed(MethodLibrary library) {
setInputForViewer(null);
if (adapterFactory instanceof ComposedAdapterFactory) {
((ComposedAdapterFactory) adapterFactory).dispose();
}
}
/**
* @see org.eclipse.epf.library.ILibraryServiceListener#librarySet(MethodLibrary)
*/
public void librarySet(MethodLibrary library) {
setInputForViewer(library);
if (library != null) {
actionBarContributor.setActiveView(AbstractBaseView.this);
}
}
/**
* @see org.eclipse.epf.library.ILibraryServiceListener#configurationSet(MethodConfiguration)
*/
public void configurationSet(MethodConfiguration config) {
}
/*
* (non-Javadoc)
* @see org.eclipse.ui.part.WorkbenchPart#dispose()
*/
public void dispose() {
// ResourcesPlugin.getWorkspace().removeResourceChangeListener(
// resourceChangeListener);
getSite().getPage().removePartListener(partListener);
if (adapterFactory instanceof ComposedAdapterFactory) {
((ComposedAdapterFactory) adapterFactory).dispose();
}
if (actionBarContributor.getActiveView() == this) {
actionBarContributor.setActiveView(null);
}
if (propertySheetPage != null) {
propertySheetPage.dispose();
}
IWorkbench workbench = AuthoringUIPlugin.getDefault().getWorkbench();
if (workbench != null) {
workbench.removeWindowListener(windowListener);
}
LibraryService.getInstance().removeListener(this);
super.dispose();
}
/**
* This accesses a cached version of the property sheet.
*/
public IPropertySheetPage getPropertySheetPage() {
if (propertySheetPage == null) {
propertySheetPage = new PropertySheetPage() {
public void makeContributions(IMenuManager menuManager,
IToolBarManager toolBarManager,
IStatusLineManager statusLineManager) {
super.makeContributions(menuManager, toolBarManager,
statusLineManager);
}
public void setActionBars(IActionBars actionBars) {
super.setActionBars(actionBars);
if (actionBarContributor != null) {
actionBarContributor.shareGlobalActions(this,
actionBars);
}
}
};
propertySheetPage
.setPropertySourceProvider(new AdapterFactoryContentProvider(
adapterFactory));
}
return propertySheetPage;
}
/**
* @see org.eclipse.ui.ide.IGotoMarker#gotoMarker(IMarker)
*/
public void gotoMarker(IMarker marker) {
try {
if (marker.getType().equals(EValidator.MARKER)) {
String uriAttribute = marker.getAttribute(
EValidator.URI_ATTRIBUTE, null);
if (uriAttribute != null) {
URI uri = URI.createURI(uriAttribute);
EObject eObject = editingDomain.getResourceSet()
.getEObject(uri, true);
if (eObject != null) {
setSelectionToViewer(Collections
.singleton(editingDomain.getWrapper(eObject)));
}
}
}
} catch (CoreException e) {
AuthoringUIPlugin.getDefault().getLogger().logError(e);
}
}
/**
* This sets the selection into whichever viewer is active.
*/
public void setSelectionToViewer(Collection collection) {
final Collection theSelection = collection;
if (theSelection != null && !theSelection.isEmpty()) {
Runnable runnable = new Runnable() {
public void run() {
// Try to select the items in the current content viewer of
// the editor.
Viewer viewer = getViewer();
if (viewer != null) {
viewer.setSelection(new StructuredSelection(
theSelection.toArray()), true);
}
}
};
runnable.run();
}
}
protected IContentProviderFactory getContentProviderFactory() {
if(contentProviderFactory == null) {
// Process the contributors.
//
IExtensionRegistry extensionRegistry = Platform
.getExtensionRegistry();
IExtensionPoint extensionPoint = extensionRegistry
.getExtensionPoint(AuthoringUIPlugin.getDefault().getId(),
"contentProviderFactories"); //$NON-NLS-1$
if (extensionPoint != null) {
IExtension[] extensions = extensionPoint.getExtensions();
Object ext = null;
ext_walk:
for (int i = 0; i < extensions.length; i++) {
IExtension extension = extensions[i];
String pluginId = extension.getNamespaceIdentifier();
Bundle bundle = Platform.getBundle(pluginId);
IConfigurationElement[] configElements = extension
.getConfigurationElements();
for (int j = 0; j < configElements.length; j++) {
IConfigurationElement configElement = configElements[j];
try {
String viewId = configElement.getAttribute("view"); //$NON-NLS-1$
if (getViewId().equals(viewId)) {
String className = configElement
.getAttribute("class"); //$NON-NLS-1$
if (className != null) {
ext = bundle.loadClass(className)
.newInstance();
if (ext instanceof IContentProviderFactory) {
contentProviderFactory = (IContentProviderFactory) ext;
break ext_walk;
}
}
}
} catch (Exception e) {
AuthoringUIPlugin.getDefault().getLogger()
.logError(e);
}
}
}
}
}
return contentProviderFactory;
}
/**
* @return a new AdapterFactoryContentProvider
*/
protected AdapterFactoryContentProvider createContentProvider() {
IContentProviderFactory factory = getContentProviderFactory();
AdapterFactoryContentProvider cp = null;
if(factory != null) {
IContentProvider contentProvider = factory.createProvider(adapterFactory, this);
if(contentProvider instanceof AdapterFactoryContentProvider) {
cp = (AdapterFactoryContentProvider) contentProvider;
}
}
return cp != null ? cp : new AdapterFactoryContentProvider(adapterFactory);
}
/**
* @return the viewer
*/
public abstract Viewer getViewer();
/**
* Creates the viewer in the given parent
* @param parent
*/
public abstract void createViewer(Composite parent);
/**
* @return a new actionBarContributer
*/
public abstract ILibraryActionBarContributor createActionBarContributor();
/**
* Sets the input for the viewer
* @param model new input for the viewer
*/
public abstract void setInputForViewer(Object model);
public abstract String getViewId();
}