| //------------------------------------------------------------------------------ |
| // 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(); |
| } |
| |
| } |
