//------------------------------------------------------------------------------
// 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.util;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.WorkspaceJob;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.emf.common.ui.viewer.IViewerProvider;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.epf.authoring.ui.AuthoringUIResources;
import org.eclipse.epf.authoring.ui.editors.MethodElementEditor;
import org.eclipse.epf.authoring.ui.editors.MethodElementEditorInput;
import org.eclipse.epf.library.ILibraryManager;
import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.library.services.SafeUpdateController;
import org.eclipse.epf.library.ui.BusyIndicatorHelper;
import org.eclipse.epf.persistence.MultiFileResourceSetImpl;
import org.eclipse.epf.persistence.refresh.IRefreshHandler;
import org.eclipse.epf.persistence.refresh.RefreshJob;
import org.eclipse.epf.persistence.util.PersistenceUtil;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.ListSelectionDialog;
import org.eclipse.ui.part.ViewPart;
/**
* Notify changes in resources to refresh
*
* @author Phong Nguyen Le
* @since 1.0
*/
public class RefreshHandler implements IRefreshHandler {
private ViewPart view;
public RefreshHandler(ViewPart view) {
this.view = view;
}
private Control getControl() {
if(view instanceof IViewerProvider) {
Viewer viewer = ((IViewerProvider)view).getViewer();
if(viewer != null) {
return viewer.getControl();
}
}
return null;
}
public void refresh(IProgressMonitor monitor) {
Control ctrl = getControl();
if (ctrl == null || ctrl.isDisposed())
return;
doRefresh(monitor);
}
private void doRefresh(IProgressMonitor monitor) {
final boolean refreshViews = !RefreshJob.getInstance()
.getReloadedBeforeRefreshResources().isEmpty()
|| !RefreshJob.getInstance().getAddedResources().isEmpty();
ArrayList<Resource> removedResources = new ArrayList<Resource>(RefreshJob.getInstance()
.getRemovedResources());
ArrayList<Resource> changedResources = new ArrayList<Resource>(RefreshJob.getInstance()
.getChangedResources());
ArrayList<IResource> addedWsResources = new ArrayList<IResource>(RefreshJob.getInstance()
.getAddedWorkspaceResources());
if (!removedResources.isEmpty() || !changedResources.isEmpty()
|| !addedWsResources.isEmpty() || refreshViews) {
doRefresh(removedResources, changedResources,
addedWsResources, refreshViews, monitor);
}
if (!removedResources.isEmpty()) {
RefreshJob.getInstance().getRemovedResources().removeAll(
removedResources);
}
if (!changedResources.isEmpty()) {
RefreshJob.getInstance().getChangedResources().removeAll(
changedResources);
}
if (!addedWsResources.isEmpty()) {
RefreshJob.getInstance().getAddedWorkspaceResources().removeAll(
addedWsResources);
}
if (refreshViews) {
RefreshJob.getInstance().getReloadedBeforeRefreshResources()
.clear();
RefreshJob.getInstance().getAddedResources().clear();
}
}
/**
* Must be synchronized to avoid stepping on each other in reloading
* resources/refreshing UI
*
* @param removedResources
* @param changedResources
* @param addedWorkspaceResources
* collection of IResource objects that are just newly added to
* the library
* @param refreshViews
*/
public synchronized void doRefresh(final Collection<Resource> removedResources,
final Collection<Resource> changedResources, final Collection<IResource> addedWorkspaceResources,
final boolean refreshViews, IProgressMonitor monitor) {
final boolean[] refreshViewsHolder = new boolean[1];
final HashSet<IEditorPart> editorsToRefresh = new HashSet<IEditorPart>();
final Collection<Resource> changedResourcesToRefresh = new ArrayList<Resource>();
SafeUpdateController.syncExec(new Runnable() {
public void run() {
if (!removedResources.isEmpty()) {
collectEditorsToRefreshForRemovedResources(editorsToRefresh, removedResources);
refreshViewsHolder[0] = true;
}
if (!changedResources.isEmpty()) {
changedResourcesToRefresh.addAll(prepareChangedResources(editorsToRefresh, changedResources, null));
}
}
});
// long running operations
//
final boolean[] validateMarkersHolder = new boolean[1];
final WorkspaceJob refreshJob = new WorkspaceJob("Refresh Resources"){
@Override
public IStatus runInWorkspace(IProgressMonitor monitor)
throws CoreException {
monitor.beginTask("Refresh resources", IProgressMonitor.UNKNOWN);
try {
// Unload the removed resources.
if (!removedResources.isEmpty()) {
monitor.subTask("Unloading resources...");
PersistenceUtil.unload(removedResources);
}
// Reload the selected changed resources.
if(changedResourcesToRefresh != null && !changedResourcesToRefresh.isEmpty()) {
ILibraryManager manager = (ILibraryManager) LibraryService
.getInstance().getCurrentLibraryManager();
if (manager != null) {
monitor.subTask("Reloading resources...");
Collection<Resource> reloadedResources = manager.reloadResources(changedResourcesToRefresh);
refreshViewsHolder[0] = !reloadedResources.isEmpty();
}
}
// load new resources
MultiFileResourceSetImpl libResourceSet = null;
if (addedWorkspaceResources != null
&& !addedWorkspaceResources.isEmpty()) {
ILibraryManager mgr = LibraryService.getInstance()
.getCurrentLibraryManager();
if (mgr != null) {
ResourceSet resourceSet = mgr.getEditingDomain()
.getResourceSet();
if (resourceSet instanceof MultiFileResourceSetImpl) {
monitor.subTask("Loading new resources...");
libResourceSet = ((MultiFileResourceSetImpl) resourceSet);
libResourceSet.loadNewResources(addedWorkspaceResources);
}
}
}
validateMarkersHolder[0] = libResourceSet != null;
return Status.OK_STATUS;
} finally {
monitor.done();
}
}
};
SafeUpdateController.syncExec(new Runnable() {
public void run() {
PlatformUI.getWorkbench().getProgressService().showInDialog(Display.getDefault().getActiveShell(), refreshJob);
}
});
refreshJob.addJobChangeListener(new JobChangeAdapter() {
@Override
public void done(IJobChangeEvent event) {
SafeUpdateController.asyncExec(new Runnable() {
public void run() {
collectionEditorsToRefreshAfterUnload(editorsToRefresh, removedResources);
Integer busyId = null;
try {
busyId = BusyIndicatorHelper.showWhile(Display.getCurrent());
if (refreshViews || refreshViewsHolder[0]) {
refreshViews();
}
if (!editorsToRefresh.isEmpty()) {
// refresh the editors that handleRemovedResources requested
//
for (Iterator<IEditorPart> iter = editorsToRefresh.iterator(); iter
.hasNext();) {
Object editor = iter.next();
if (editor instanceof MethodElementEditor) {
((MethodElementEditor) editor).refresh();
}
}
}
} finally {
if(busyId != null) {
BusyIndicatorHelper.hideWhile(Display.getCurrent(), busyId);
}
}
}
});
}
});
refreshJob.setSystem(true);
refreshJob.schedule();
if(validateMarkersHolder[0]) {
// do this in background
WorkspaceJob job = new WorkspaceJob("Validate unresolved reference errors") {
@Override
public IStatus runInWorkspace(IProgressMonitor monitor)
throws CoreException {
ILibraryManager mgr = LibraryService.getInstance()
.getCurrentLibraryManager();
if (mgr != null) {
ResourceSet resourceSet = mgr.getEditingDomain()
.getResourceSet();
if (resourceSet instanceof MultiFileResourceSetImpl) {
((MultiFileResourceSetImpl) resourceSet).getUnresolvedProxyMarkerManager().validateAllMarkers();
}
}
return Status.OK_STATUS;
}
};
job.setSystem(true);
job.schedule();
}
}
private void collectionEditorsToRefreshAfterUnload(Set<IEditorPart> editorsToRefresh,
Collection<Resource> removedResources) {
IEditorReference[] editorReferences = view.getSite().getPage()
.getEditorReferences();
ArrayList<Resource> removedResourceList = new ArrayList<Resource>(removedResources);
for (int i = 0; i < editorReferences.length; i++) {
IEditorReference reference = editorReferences[i];
IEditorPart editor = reference.getEditor(true);
if (editor instanceof MethodElementEditor && !editor.isDirty()) {
Collection<Resource> usedResources = ((MethodElementEditor) editor)
.getUsedResources();
check_resource: for (int j = 0; j < removedResourceList.size(); j++) {
Resource resource = (Resource) removedResourceList.get(j);
if (usedResources.contains(resource)) {
editorsToRefresh.add(editor);
break check_resource;
}
}
}
}
}
/**
* Returns changed resources to be refreshed
*
* @param editorsToRefresh
* @param changedResources
* @return
*/
protected Collection<Resource> prepareChangedResources(
Set<IEditorPart> editorsToRefresh,
Collection<Resource> changedResources, Set<IEditorPart> editorsNotToRefresh) {
Control ctrl = getControl();
if (ctrl == null || ctrl.isDisposed())
return Collections.emptyList();
IWorkbenchPage workbenchPage = view.getSite().getPage();
IEditorReference[] editorReferences = workbenchPage
.getEditorReferences();
ArrayList<IEditorPart> dirtyEditorsWithConflict = new ArrayList<IEditorPart>();
ArrayList<Resource> changedResourceList = new ArrayList<Resource>(changedResources);
// find all editor with dirty conflict
//
for (int i = 0; i < editorReferences.length; i++) {
IEditorReference reference = editorReferences[i];
IEditorPart editor = reference.getEditor(true);
if (editor instanceof MethodElementEditor && editor.isDirty()) {
Collection<Resource> usedResources = ((MethodElementEditor) editor)
.getUsedResources();
check_resource: for (int j = 0; j < changedResourceList.size(); j++) {
Resource resource = (Resource) changedResourceList.get(j);
if (usedResources.contains(resource)) {
dirtyEditorsWithConflict.add(editor);
break check_resource;
}
}
}
}
if (!dirtyEditorsWithConflict.isEmpty()) {
Object[] result = selectDirtyEditors(dirtyEditorsWithConflict);
if(result != null) {
for (int i = 0; i < result.length; i++) {
Object editor = result[i];
if (editor instanceof IEditorPart && (editorsNotToRefresh == null || !editorsNotToRefresh
.contains(editor))
&& (editorsToRefresh == null || !editorsToRefresh
.contains(editor))) {
editorsToRefresh.add((IEditorPart) editor);
dirtyEditorsWithConflict.remove(editor);
}
}
}
// remove all resources used by dirty editors with conflict from the
// collection of changed resources after updating cached modification stamp
// so they will not be prompted to reload again until the next external change
//
for (int i = 0; i < dirtyEditorsWithConflict.size(); i++) {
MethodElementEditor editor = (MethodElementEditor) dirtyEditorsWithConflict
.get(i);
Collection<Resource> usedResources = editor.getUsedResources();
usedResources.retainAll(changedResourceList);
editor.updateResourceInfos(usedResources);
editor.ovewriteResources(usedResources);
changedResourceList.removeAll(usedResources);
}
}
if (!changedResourceList.isEmpty()) {
for (int i = 0; i < editorReferences.length; i++) {
IEditorReference reference = editorReferences[i];
IEditorPart editor = reference.getEditor(true);
if (editor instanceof MethodElementEditor && !editor.isDirty()) {
Collection<Resource> usedResources = ((MethodElementEditor) editor)
.getUsedResources();
check_resource: for (int j = 0; j < changedResourceList
.size(); j++) {
Resource resource = (Resource) changedResourceList
.get(j);
if (usedResources.contains(resource)) {
editorsToRefresh.add(editor);
break check_resource;
}
}
}
}
}
return changedResourceList;
}
private void collectEditorsToRefreshForRemovedResources(
Set<IEditorPart> editorsToRefresh,
Collection<Resource> removedResources) {
IWorkbenchPage workbenchPage = view.getSite().getPage();
IEditorReference[] editorReferences = workbenchPage
.getEditorReferences();
ArrayList<IEditorPart> dirtyEditorsWithConflict = new ArrayList<IEditorPart>();
ArrayList<Resource> removedResourceList = new ArrayList<Resource>(removedResources);
if (editorsToRefresh == null) {
editorsToRefresh = new HashSet<IEditorPart>();
}
// find all editor with dirty conflict
//
for (int i = 0; i < editorReferences.length; i++) {
IEditorReference reference = editorReferences[i];
IEditorPart editor = reference.getEditor(true);
if (editor instanceof MethodElementEditor && editor.isDirty()) {
MethodElementEditorInput input = (MethodElementEditorInput) editor
.getEditorInput();
Resource resource = input.getMethodElement() != null ? input
.getMethodElement().eResource() : null;
if (!removedResources.contains(resource)) {
Collection<Resource> usedResources = ((MethodElementEditor) editor)
.getUsedResources();
check_resource: for (int j = 0; j < removedResourceList
.size(); j++) {
resource = (Resource) removedResourceList.get(j);
if (usedResources.contains(resource)) {
dirtyEditorsWithConflict.add(editor);
break check_resource;
}
}
} else {
editorsToRefresh.add(editor);
}
}
}
if (!dirtyEditorsWithConflict.isEmpty()) {
Object[] selected = selectDirtyEditors(dirtyEditorsWithConflict);
for (int i = 0; i < selected.length; i++) {
editorsToRefresh.add((IEditorPart) selected[i]);
}
}
}
protected void refreshViews() {
}
private Object[] selectDirtyEditors(
ArrayList<IEditorPart> dirtyEditorsWithConflict) {
return selectDirtyEditors(dirtyEditorsWithConflict, view.getSite().getShell());
}
public static Object[] selectDirtyEditors(List<?> dirtyEditors, Shell shell) {
String title = AuthoringUIResources._UI_FileConflict_label;
String msg = AuthoringUIResources.selectEditorsToDiscardConflictChanges;
return selectEditors(dirtyEditors, title, msg, shell);
}
private static Object[] selectEditors(List<?> editors, String title, String msg, Shell shell) {
// prompt user to discard changes in editors that conflict with outside
// change
//
IStructuredContentProvider contentProvider = new IStructuredContentProvider() {
List<?> fContents;
public Object[] getElements(Object inputElement) {
if (fContents != null && fContents == inputElement)
return fContents.toArray();
return new Object[0];
}
public void dispose() {
}
public void inputChanged(Viewer viewer, Object oldInput,
Object newInput) {
if (newInput instanceof List)
fContents = (List<?>) newInput;
else
fContents = null;
}
};
ILabelProvider labelProvider = new LabelProvider() {
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
*/
public String getText(Object element) {
if (element instanceof IEditorPart) {
return ((IEditorPart) element).getTitle();
}
return super.getText(element);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.viewers.LabelProvider#getImage(java.lang.Object)
*/
public Image getImage(Object element) {
if (element instanceof IEditorPart) {
return ((IEditorPart) element).getTitleImage();
}
return super.getImage(element);
}
};
ListSelectionDialog dlg = new ListSelectionDialog(shell,
editors, contentProvider, labelProvider, msg);
dlg.setTitle(title);
dlg.setBlockOnOpen(true);
dlg.open();
return dlg.getResult();
}
}