| /******************************************************************************* |
| * Copyright (c) 2001, 2009 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 API and implementation |
| * Jens Lukowski/Innoopract - initial renaming/restructuring |
| * |
| *******************************************************************************/ |
| package org.eclipse.wst.sse.ui; |
| |
| import java.lang.reflect.InvocationTargetException; |
| |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.ISafeRunnable; |
| import org.eclipse.core.runtime.SafeRunner; |
| import org.eclipse.core.runtime.jobs.ISchedulingRule; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchPartSite; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.progress.IWorkbenchSiteProgressService; |
| import org.eclipse.wst.sse.core.internal.IExecutionDelegate; |
| import org.eclipse.wst.sse.ui.internal.Logger; |
| import org.eclipse.wst.sse.ui.internal.SSEUIPlugin; |
| |
| class EditorExecutionContext implements IExecutionDelegate { |
| |
| /** |
| * Reusable runnable for the Display execution queue to cut down on |
| * garbage creation. Will make use of the progress service if possible. |
| */ |
| private static class ReusableUIRunner implements Runnable, IRunnableWithProgress { |
| private StructuredTextEditor editor; |
| private ISafeRunnable fRunnable = null; |
| |
| ReusableUIRunner(StructuredTextEditor part) { |
| super(); |
| editor = part; |
| } |
| |
| /* |
| * Expected to only be run by Display queue in the UI Thread |
| * |
| * @see java.lang.Runnable#run() |
| */ |
| public void run() { |
| IWorkbenchPartSite site = editor.getEditorPart().getSite(); |
| final IWorkbenchWindow workbenchWindow = (site == null) ? null : site.getWorkbenchWindow(); |
| final IWorkbenchSiteProgressService jobService = (IWorkbenchSiteProgressService) ((site == null) ? null : site.getAdapter(IWorkbenchSiteProgressService.class)); |
| /* |
| * Try to use the progress service so the workbench can give more |
| * feedback to the user (although editors seem to make less use of |
| * the service than views - |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=86221 . |
| */ |
| if (workbenchWindow != null && jobService != null) { |
| /* |
| * Doc is ambiguous, but it must be run from the UI thread - |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=165180 |
| */ |
| try { |
| jobService.runInUI(workbenchWindow, this, (ISchedulingRule) editor.getEditorPart().getEditorInput().getAdapter(IResource.class)); |
| } |
| catch (InvocationTargetException e) { |
| Logger.logException(e); |
| } |
| catch (InterruptedException e) { |
| Logger.logException(e); |
| } |
| } |
| else { |
| /* |
| * Run it directly and direct the UI of the editor. See |
| * StructuredTextEditor's begin/end background job for other |
| * activities to best accommodate (for example, there is a |
| * "timed delay" before the editor itself leaves |
| * background-update mode). NOTE: this execute method itself |
| * is always called from inside of an ILock block, so another |
| * block is not not needed here for all these sycnExec's. |
| */ |
| IWorkbench workbench = SSEUIPlugin.getInstance().getWorkbench(); |
| final Display display = workbench.getDisplay(); |
| if (display != null && !display.isDisposed()) { |
| editor.beginBackgroundOperation(); |
| try { |
| /* |
| * Here's where the document update/modification |
| * occurs |
| */ |
| SafeRunner.run(fRunnable); |
| } |
| finally { |
| /* |
| * This 'end' is just a signal to editor that this |
| * particular update is done. Its up to the editor to |
| * decide exactly when to leave its "background mode" |
| */ |
| editor.endBackgroundOperation(); |
| } |
| } |
| fRunnable = null; |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.jface.operation.IRunnableWithProgress#run(org.eclipse |
| * .core.runtime.IProgressMonitor) |
| */ |
| public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { |
| if (fRunnable != null) |
| SafeRunner.run(fRunnable); |
| } |
| |
| void setRunnable(ISafeRunnable r) { |
| fRunnable = r; |
| } |
| } |
| |
| StructuredTextEditor fEditor; |
| private ReusableUIRunner fReusableRunner; |
| |
| public EditorExecutionContext(StructuredTextEditor editor) { |
| super(); |
| fEditor = editor; |
| fReusableRunner = new ReusableUIRunner(fEditor); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.wst.sse.core.internal.IExecutionDelegate#execute(java.lang |
| * .Runnable) |
| */ |
| public void execute(final ISafeRunnable runnable) { |
| IWorkbench workbench = SSEUIPlugin.getInstance().getWorkbench(); |
| final Display display = workbench.getDisplay(); |
| if (display.getThread() == Thread.currentThread()) { |
| // *If already in display thread, we can simply run, "as usual"*/ |
| SafeRunner.run(runnable); |
| } |
| else { |
| // *otherwise run through the reusable runner */ |
| fReusableRunner.setRunnable(runnable); |
| display.syncExec(fReusableRunner); |
| } |
| } |
| } |