| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2008 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.library.edit.ui; |
| |
| import java.io.PrintWriter; |
| import java.io.StringWriter; |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| 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.MultiStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.jobs.ISchedulingRule; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.emf.common.notify.AdapterFactory; |
| import org.eclipse.emf.common.ui.viewer.IViewerProvider; |
| import org.eclipse.emf.common.util.WrappedException; |
| import org.eclipse.emf.edit.provider.ITreeItemContentProvider; |
| import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider; |
| import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider; |
| import org.eclipse.epf.common.ui.util.MsgBox; |
| import org.eclipse.epf.library.edit.LibraryEditPlugin; |
| import org.eclipse.epf.library.edit.LibraryEditResources; |
| import org.eclipse.epf.library.edit.TngAdapterFactory; |
| import org.eclipse.epf.library.edit.process.BSActivityItemProvider; |
| import org.eclipse.epf.library.edit.util.ExposedAdapterFactory; |
| import org.eclipse.epf.library.edit.util.ExtensionManager; |
| import org.eclipse.epf.library.edit.util.IRunnableWithProgress; |
| import org.eclipse.epf.library.edit.util.ProcessUtil; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.uma.Activity; |
| import org.eclipse.epf.uma.BreakdownElement; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.Process; |
| import org.eclipse.epf.uma.ProcessComponent; |
| import org.eclipse.epf.uma.Role; |
| import org.eclipse.epf.uma.TeamProfile; |
| import org.eclipse.epf.uma.VariabilityType; |
| import org.eclipse.epf.uma.WorkProduct; |
| import org.eclipse.epf.uma.util.MessageException; |
| import org.eclipse.jface.dialogs.ProgressMonitorDialog; |
| import org.eclipse.jface.operation.IRunnableContext; |
| import org.eclipse.jface.operation.ModalContext; |
| import org.eclipse.jface.viewers.IContentProvider; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.viewers.IStructuredContentProvider; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.custom.BusyIndicator; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.progress.WorkbenchJob; |
| |
| /** |
| * @author Phong Nguyen Le |
| * @since 1.5 |
| * |
| */ |
| public class UIHelper implements IUIHelper { |
| /** |
| * Get teams in scope |
| * |
| * @param adapterFactory |
| * @param e |
| * @param role |
| * @param teamList |
| */ |
| private static void getTeamsInScope(AdapterFactory adapterFactory, |
| BreakdownElement e, Role role, List teamList) { |
| // get children for activity |
| ITreeItemContentProvider itemProvider = (ITreeItemContentProvider) adapterFactory |
| .adapt(e, ITreeItemContentProvider.class); |
| Collection children = itemProvider.getChildren(e); |
| for (Iterator itor = children.iterator(); itor.hasNext();) { |
| Object obj = itor.next(); |
| if (obj instanceof TeamProfile) { |
| TeamProfile team = (TeamProfile) obj; |
| List allTeams = new ArrayList(); |
| // get all sub teams as well |
| ProcessUtil.getAllSubTeams(team, allTeams); |
| |
| for (Iterator teamItor = allTeams.iterator(); teamItor |
| .hasNext();) { |
| Object o = teamItor.next(); |
| if (o instanceof TeamProfile) { |
| // get roles from teams |
| List roles = ProcessUtil.getRoles(((TeamProfile) o) |
| .getTeamRoles()); |
| if (roles.contains(role)) { |
| teamList.add(o); |
| } |
| } |
| } |
| } |
| } |
| |
| // get parent |
| Object currentParent = itemProvider.getParent(e); |
| if (currentParent != null) { |
| // go up |
| getTeamsInScope(adapterFactory, (BreakdownElement) currentParent, |
| role, teamList); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.epf.library.edit.util.IUIHelper#getTeam(org.eclipse.epf.uma.Activity, org.eclipse.epf.uma.Role, java.lang.Object) |
| */ |
| public TeamProfile getTeam(Activity activity, Role role, Object UIContext) { |
| List teamList = new ArrayList(); |
| AdapterFactory adapterFactory = TngAdapterFactory.INSTANCE |
| .getOBS_ComposedAdapterFactory(); |
| // find out all team in visible scope |
| getTeamsInScope(adapterFactory, activity, role, teamList); |
| if (teamList.size() == 1) { |
| return (TeamProfile) teamList.get(0); |
| } |
| if (teamList.size() > 1) { |
| return TeamSelection.getSelectedTeam(teamList, role, |
| UIContext instanceof Shell ? (Shell) UIContext : null); |
| } |
| // there are no teams to assign |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.epf.library.edit.util.IUIHelper#runInModalContext(org.eclipse.epf.library.edit.util.IRunnableWithProgress, boolean, org.eclipse.core.runtime.IProgressMonitor, java.lang.Object) |
| */ |
| public IStatus runInModalContext(final IRunnableWithProgress operation, |
| boolean fork, IProgressMonitor monitor, Object uiContext) { |
| org.eclipse.jface.operation.IRunnableWithProgress op = new org.eclipse.jface.operation.IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, InterruptedException { |
| operation.run(monitor); |
| } |
| |
| }; |
| try { |
| ModalContext.run(op, true, monitor, ((Shell)uiContext) |
| .getDisplay()); |
| return Status.OK_STATUS; |
| } catch (Exception e) { |
| LibraryEditPlugin.INSTANCE.log(e); |
| Throwable ex; |
| if (e instanceof InvocationTargetException) { |
| ex = ((InvocationTargetException) e) |
| .getTargetException(); |
| } else { |
| ex = e; |
| } |
| String msg = TngUtil.toStackTraceString(ex); |
| return new Status(IStatus.ERROR, |
| LibraryEditPlugin.INSTANCE.getSymbolicName(), 0, |
| msg, ex); |
| } |
| |
| } |
| |
| public List selectTasks(List taskList, WorkProduct wp) { |
| ILabelProvider labelProvider = new AdapterFactoryLabelProvider( |
| TngAdapterFactory.INSTANCE |
| .getNavigatorView_ComposedAdapterFactory()) { |
| public String getColumnText(Object obj, int column) { |
| if (obj instanceof MethodElement) { |
| return TngUtil.getPresentationName(obj); |
| } |
| return super.getText(obj); |
| } |
| }; |
| |
| IStructuredContentProvider contentProvider = new AdapterFactoryContentProvider( |
| TngAdapterFactory.INSTANCE |
| .getNavigatorView_ComposedAdapterFactory()) { |
| public Object[] getElements(Object object) { |
| return ((List) object).toArray(); |
| } |
| }; |
| |
| try { |
| ProcessListSelectionDialog dlg = new ProcessListSelectionDialog( |
| PlatformUI.getWorkbench().getActiveWorkbenchWindow() |
| .getShell(), |
| taskList, |
| contentProvider, |
| labelProvider, |
| NLS |
| .bind( |
| LibraryEditResources.ui_UserInteractionHelper_wplistdlg_msg, |
| wp.getName())); |
| |
| dlg.setTitle(LibraryEditResources.ui_UserInteractionHelper_tasks); |
| dlg.setBlockOnOpen(true); |
| dlg.open(); |
| Object[] objs = dlg.getResult(); |
| |
| List selectedTasks = new ArrayList(); |
| if ((objs != null) && (objs.length > 0)) { |
| for (int i = 0; i < objs.length; i++) { |
| selectedTasks.add(objs[i]); |
| } |
| } |
| return selectedTasks; |
| } finally { |
| // dispose |
| labelProvider.dispose(); |
| contentProvider.dispose(); |
| } |
| } |
| |
| public List selectWorkProducts(List wpList, Role role) { |
| ILabelProvider labelProvider = new AdapterFactoryLabelProvider( |
| TngAdapterFactory.INSTANCE |
| .getNavigatorView_ComposedAdapterFactory()) { |
| public String getColumnText(Object obj, int column) { |
| if (obj instanceof MethodElement) { |
| return TngUtil.getPresentationName(obj); |
| } |
| return super.getText(obj); |
| } |
| }; |
| |
| IStructuredContentProvider contentProvider = new AdapterFactoryContentProvider( |
| TngAdapterFactory.INSTANCE |
| .getNavigatorView_ComposedAdapterFactory()) { |
| public Object[] getElements(Object object) { |
| return ((List) object).toArray(); |
| } |
| }; |
| |
| try { |
| ProcessListSelectionDialog dlg = new ProcessListSelectionDialog( |
| PlatformUI.getWorkbench().getActiveWorkbenchWindow() |
| .getShell(), |
| // MsgBox.getDefaultShell(), |
| wpList, |
| contentProvider, |
| labelProvider, |
| NLS |
| .bind( |
| LibraryEditResources.ui_UserInteractionHelper_rolelistdlg_msg, |
| role.getName())); |
| |
| dlg |
| .setTitle(LibraryEditResources.ui_UserInteractionHelper_workproducts); |
| dlg.setBlockOnOpen(true); |
| dlg.open(); |
| Object[] objs = dlg.getResult(); |
| |
| List selectedWps = new ArrayList(); |
| if ((objs != null) && (objs.length > 0)) { |
| for (int i = 0; i < objs.length; i++) { |
| selectedWps.add(objs[i]); |
| } |
| } |
| return selectedWps; |
| } finally { |
| // dispose |
| labelProvider.dispose(); |
| contentProvider.dispose(); |
| } |
| } |
| |
| private static class RunnableWithProgress implements org.eclipse.jface.operation.IRunnableWithProgress { |
| private IRunnableWithProgress operation; |
| |
| public RunnableWithProgress(IRunnableWithProgress op) { |
| this.operation = op; |
| } |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, InterruptedException { |
| operation.run(monitor); |
| } |
| |
| } |
| |
| public IStatus runAsJob(final IRunnableWithProgress runnable, String taskName, |
| Object shell) { |
| Job job = new WorkspaceJob(taskName) { |
| |
| public IStatus runInWorkspace(IProgressMonitor monitor) |
| throws CoreException { |
| try { |
| // monitor.beginTask(taskName, IProgressMonitor.UNKNOWN); |
| runnable.run(monitor); |
| return Status.OK_STATUS; |
| } catch (InvocationTargetException e) { |
| Throwable ex; |
| if (e.getCause() != null) { |
| ex = e.getCause(); |
| } else { |
| ex = e; |
| } |
| return new Status(IStatus.ERROR, LibraryEditPlugin |
| .getPlugin().getId(), 0, ex.toString(), ex); |
| } catch (InterruptedException e) { |
| return new Status(IStatus.ERROR, LibraryEditPlugin |
| .getPlugin().getId(), 0, e.toString(), e); |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| }; |
| PlatformUI.getWorkbench().getProgressService().showInDialog((Shell) shell, job); |
| job.schedule(); |
| return job.getResult(); |
| } |
| |
| public boolean runInUI(IRunnableWithProgress runnable, |
| ISchedulingRule rule, Object shell) { |
| if (shell == null) { |
| shell = LibraryEditPlugin.getDefault().getContext(); |
| } |
| IRunnableContext context = new ProgressMonitorDialog((Shell) shell); |
| try { |
| PlatformUI.getWorkbench().getProgressService().runInUI(context, |
| new RunnableWithProgress(runnable), rule); |
| return true; |
| } catch (Exception e) { |
| LibraryEditPlugin.getDefault().getLogger().logError(e); |
| String title = LibraryEditResources.errorDialog_title; |
| ExtensionManager.getDefaultUserInteractionHandler().getMessenger() |
| .showError(title, e.toString(), null, e); |
| // LibraryEditPlugin.getDefault().getMsgDialog().displayError(title, |
| // e.toString(), e); |
| } |
| return false; |
| } |
| |
| public static boolean runWithProgress(final IRunnableWithProgress runnable, |
| final IRunnableContext runnableContext, final boolean canCancel, final String msg) { |
| final MultiStatus status = new MultiStatus(LibraryEditPlugin.INSTANCE |
| .getSymbolicName(), IStatus.OK, |
| LibraryEditResources.error_reason, null); |
| |
| final org.eclipse.jface.operation.IRunnableWithProgress operation = new org.eclipse.jface.operation.IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, InterruptedException { |
| monitor.beginTask(msg, IProgressMonitor.UNKNOWN); |
| monitor.subTask(""); //$NON-NLS-1$ |
| try { |
| runnable.run(monitor); |
| } catch (RuntimeException e) { |
| String msg; |
| if (e instanceof MessageException) { |
| msg = e.getMessage(); |
| } else { |
| StringWriter strWriter = new StringWriter(); |
| e.printStackTrace(new PrintWriter(strWriter)); |
| msg = strWriter.toString(); |
| } |
| status.add(new Status(IStatus.ERROR, |
| LibraryEditPlugin.INSTANCE.getSymbolicName(), 0, |
| msg, e)); |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| }; |
| |
| try { |
| if (Display.getCurrent() == null) { |
| // current thread is not a user-interface thread |
| // |
| Display.getDefault().syncExec(new Runnable() { |
| |
| public void run() { |
| try { |
| runnableContext.run(true, canCancel, operation); |
| } catch (Exception e) { |
| LibraryEditPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| |
| }); |
| } else { |
| runnableContext.run(true, canCancel, operation); |
| } |
| |
| if (!status.isOK()) { |
| ExtensionManager.getDefaultUserInteractionHandler() |
| .getMessenger().showError( |
| LibraryEditResources.errorDialog_title, |
| LibraryEditResources.error_msgWithDetails, |
| status); |
| } else { |
| return true; |
| } |
| } catch (Exception exception) { |
| // Something went wrong that shouldn't. |
| // |
| LibraryEditPlugin.getDefault().getLogger().logError(exception); |
| } |
| |
| return false; |
| } |
| |
| public boolean runWithProgress(IRunnableWithProgress runnable, |
| boolean canCancel, String msg) { |
| return runWithProgress(runnable, getRunnableContext(), false, msg); |
| } |
| |
| public IRunnableContext getRunnableContext() { |
| Shell shell; |
| Object uiCtx = ExtensionManager.getDefaultUserInteractionHandler().getUIContext(); |
| if (uiCtx instanceof Shell) { |
| shell = (Shell) uiCtx; |
| } else { |
| shell = MsgBox.getDefaultShell(); |
| } |
| return new ProgressMonitorDialog(shell); |
| } |
| |
| public static Viewer doGetViewer(AdapterFactory adapterFactory, Process proc) { |
| if (adapterFactory instanceof ExposedAdapterFactory) { |
| for (Iterator iter = Collections.unmodifiableList( |
| ((ExposedAdapterFactory) adapterFactory) |
| .getChangeListeners()).iterator(); iter.hasNext();) { |
| Object listener = iter.next(); |
| if (listener instanceof IContentProvider && listener instanceof IViewerProvider) { |
| Viewer viewer = ((IViewerProvider) listener).getViewer(); |
| if (viewer.getInput() instanceof ProcessComponent |
| && ((ProcessComponent) viewer.getInput()) |
| .getProcess() == proc) |
| return viewer; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public boolean refreshNeeded(AdapterFactory adapterFactory, |
| BSActivityItemProvider itemProvider) { |
| Process process = (Process) itemProvider.getTopItem(); |
| if (process == null) |
| return false; |
| |
| // check if the given process is currently opened in editor |
| // |
| Viewer viewer = doGetViewer(adapterFactory, process); |
| if (viewer != null && viewer.getControl() != null |
| && !viewer.getControl().isDisposed()) { |
| return true; |
| } |
| |
| for (Iterator iter = TngUtil.getContributors(process); iter.hasNext();) { |
| Object element = iter.next(); |
| BSActivityItemProvider adapter = (BSActivityItemProvider) adapterFactory |
| .adapt(element, ITreeItemContentProvider.class); |
| if (refreshNeeded(adapterFactory, adapter)) |
| return true; |
| } |
| |
| for (Iterator iter = TngUtil.getGeneralizers(process, |
| VariabilityType.EXTENDS); iter.hasNext();) { |
| Object element = iter.next(); |
| BSActivityItemProvider adapter = (BSActivityItemProvider) adapterFactory |
| .adapt(element, ITreeItemContentProvider.class); |
| if (refreshNeeded(adapterFactory, adapter)) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| public void refreshAllViewers(final ExposedAdapterFactory adapterFactory) { |
| UserInteractionHelper.getUIHelper().runSafely(new Runnable() { |
| |
| public void run() { |
| for (Iterator iter = Collections.unmodifiableList( |
| adapterFactory.getChangeListeners()).iterator(); iter.hasNext();) { |
| Object listener = iter.next(); |
| if (listener instanceof IContentProvider && listener instanceof IViewerProvider) { |
| Viewer viewer = ((IViewerProvider) listener).getViewer(); |
| if (viewer != null && viewer.getControl() != null |
| && !viewer.getControl().isDisposed() |
| && viewer.getInput() instanceof ProcessComponent) { |
| viewer.refresh(); |
| } |
| } |
| } |
| } |
| |
| }, true); |
| } |
| |
| public void refreshViewer(AdapterFactory factory, Process proc) { |
| final Viewer viewer = doGetViewer(factory, proc); |
| if (viewer != null && viewer.getControl() != null |
| && !viewer.getControl().isDisposed()) { |
| UserInteractionHelper.getUIHelper().runSafely(new Runnable() { |
| |
| public void run() { |
| viewer.refresh(); |
| } |
| |
| }, true); |
| } |
| } |
| |
| public void refreshIDsInViewer(final ExposedAdapterFactory adapterFactory) { |
| UserInteractionHelper.getUIHelper().runSafely(new Runnable() { |
| |
| public void run() { |
| for (Iterator iter = Collections.unmodifiableList( |
| adapterFactory.getChangeListeners()).iterator(); iter.hasNext();) { |
| Object listener = iter.next(); |
| if (listener instanceof IContentProvider && listener instanceof IViewerProvider) { |
| Viewer viewer = ((IViewerProvider) listener).getViewer(); |
| if (viewer != null && viewer.getControl() != null |
| && !viewer.getControl().isDisposed() |
| && viewer.getInput() instanceof ProcessComponent) { |
| Process proc = ((ProcessComponent) viewer.getInput()) |
| .getProcess(); |
| BSActivityItemProvider itemProvider = (BSActivityItemProvider) adapterFactory |
| .adapt(proc, ITreeItemContentProvider.class); |
| if (itemProvider.isRefreshAllIDsRequired()) { |
| ProcessUtil.updateIDs(adapterFactory, proc); |
| viewer.refresh(); |
| itemProvider.setRefreshAllIDsRequired(false); |
| } |
| } |
| } |
| } |
| } |
| |
| }, true); |
| } |
| |
| public Object getViewer(AdapterFactory adapterFactory, Process proc) { |
| return doGetViewer(adapterFactory, proc); |
| } |
| |
| public void runSafely(final Runnable runnable, boolean synchronous) { |
| Display display = null; |
| try { |
| display = Display.getCurrent(); |
| } catch (Exception e) { |
| // |
| } |
| |
| Runnable runner = new Runnable() { |
| |
| public void run() { |
| try { |
| runnable.run(); |
| } catch (Exception e) { |
| LibraryEditUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| |
| }; |
| |
| if(display == null) { |
| // current thread is not a user-interface thread |
| // |
| try { |
| display = Display.getDefault(); |
| } |
| catch(Exception e) { |
| |
| } |
| if(display != null) { |
| if(synchronous) { |
| display.syncExec(runner); |
| } |
| else { |
| display.asyncExec(runner); |
| } |
| } |
| else { |
| runner.run(); |
| } |
| } |
| else { |
| // current thread is a user-interface thread |
| // |
| if(synchronous) { |
| runner.run(); |
| } |
| else { |
| display.asyncExec(runner); |
| } |
| } |
| } |
| |
| public void runWithBusyIndicator(Runnable runnable) { |
| BusyIndicator.showWhile(Display.getCurrent(), runnable); |
| } |
| |
| public void runInUI(final IRunnableWithProgress runnable, String taskName) { |
| Shell shell = (Shell) LibraryEditPlugin.getDefault().getContext(); |
| if (shell == null) { |
| try { |
| runnable.run(new NullProgressMonitor()); |
| return; |
| } catch (Exception e) { |
| LibraryEditPlugin.getDefault().getLogger().logError(e); |
| throw new WrappedException(e); |
| } |
| } |
| Job job = new WorkbenchJob(taskName) { |
| |
| public IStatus runInUIThread(IProgressMonitor monitor) { |
| monitor.beginTask("", IProgressMonitor.UNKNOWN); //$NON-NLS-1$ |
| try { |
| runnable.run(monitor); |
| return Status.OK_STATUS; |
| } catch (InvocationTargetException e) { |
| Throwable ex; |
| if (e.getCause() != null) { |
| ex = e.getCause(); |
| } else { |
| ex = e; |
| } |
| return new Status(IStatus.ERROR, LibraryEditPlugin |
| .getPlugin().getId(), 0, ex.toString(), ex); |
| } catch (InterruptedException e) { |
| return new Status(IStatus.ERROR, LibraryEditPlugin |
| .getPlugin().getId(), 0, e.toString(), e); |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| }; |
| PlatformUI.getWorkbench().getProgressService().showInDialog(shell, job); |
| job.schedule(); |
| } |
| |
| } |
