net.sourceforge.phpeclipse.ui/src/net/sourceforge/phpdt/internal/ui/text/JavaReconciler.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11
  12 package net.sourceforge.phpdt.internal.ui.text;
  13
  14 import net.sourceforge.phpdt.core.ElementChangedEvent;
  15 import net.sourceforge.phpdt.core.IElementChangedListener;
  16 import net.sourceforge.phpdt.core.JavaCore;
  17 //import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  18 import net.sourceforge.phpeclipse.phpeditor.PHPUnitEditor;
  19 import net.sourceforge.phpeclipse.ui.WebUI;
  20
  21 import org.eclipse.core.resources.IMarkerDelta;
  22 import org.eclipse.core.resources.IResource;
  23 import org.eclipse.core.resources.IResourceChangeEvent;
  24 import org.eclipse.core.resources.IResourceChangeListener;
  25 import org.eclipse.core.resources.IResourceDelta;
  26 import org.eclipse.core.resources.IWorkspace;
  27 import org.eclipse.jface.text.IDocument;
  28 import org.eclipse.jface.text.ITextViewer;
  29 import org.eclipse.jface.text.reconciler.DirtyRegion;
  30 import org.eclipse.jface.text.reconciler.MonoReconciler;
  31 import org.eclipse.swt.events.ShellAdapter;
  32 import org.eclipse.swt.events.ShellEvent;
  33 import org.eclipse.swt.events.ShellListener;
  34 import org.eclipse.swt.widgets.Control;
  35 import org.eclipse.swt.widgets.Shell;
  36 import org.eclipse.ui.IEditorInput;
  37 import org.eclipse.ui.IFileEditorInput;
  38 import org.eclipse.ui.IPartListener;
  39 import org.eclipse.ui.IWorkbenchPart;
  40 import org.eclipse.ui.IWorkbenchPartSite;
  41 import org.eclipse.ui.IWorkbenchWindow;
  42 import org.eclipse.ui.texteditor.ITextEditor;
  43
  44 /**
  45  * A reconciler that is also activated on editor activation.
  46  */
  47 public class JavaReconciler extends MonoReconciler {
  48
  49         /**
  50          * Internal part listener for activating the reconciler.
  51          */
  52         private class PartListener implements IPartListener {
  53
  54                 /*
  55                  * @see org.eclipse.ui.IPartListener#partActivated(org.eclipse.ui.IWorkbenchPart)
  56                  */
  57                 public void partActivated(IWorkbenchPart part) {
  58                         if (part == fTextEditor && hasJavaModelChanged())
  59                                 JavaReconciler.this.forceReconciling();
  60                 }
  61
  62                 /*
  63                  * @see org.eclipse.ui.IPartListener#partBroughtToTop(org.eclipse.ui.IWorkbenchPart)
  64                  */
  65                 public void partBroughtToTop(IWorkbenchPart part) {
  66                 }
  67
  68                 /*
  69                  * @see org.eclipse.ui.IPartListener#partClosed(org.eclipse.ui.IWorkbenchPart)
  70                  */
  71                 public void partClosed(IWorkbenchPart part) {
  72                 }
  73
  74                 /*
  75                  * @see org.eclipse.ui.IPartListener#partDeactivated(org.eclipse.ui.IWorkbenchPart)
  76                  */
  77                 public void partDeactivated(IWorkbenchPart part) {
  78                         if (part == fTextEditor)
  79                                 setJavaModelChanged(false);
  80                 }
  81
  82                 /*
  83                  * @see org.eclipse.ui.IPartListener#partOpened(org.eclipse.ui.IWorkbenchPart)
  84                  */
  85                 public void partOpened(IWorkbenchPart part) {
  86                 }
  87         }
  88
  89         /**
  90          * Internal Shell activation listener for activating the reconciler.
  91          */
  92         private class ActivationListener extends ShellAdapter {
  93
  94                 private Control fControl;
  95
  96                 public ActivationListener(Control control) {
  97                         fControl = control;
  98                 }
  99
 100                 /*
 101                  * @see org.eclipse.swt.events.ShellListener#shellActivated(org.eclipse.swt.events.ShellEvent)
 102                  */
 103                 public void shellActivated(ShellEvent e) {
 104                         if (!fControl.isDisposed() && fControl.isVisible()
 105                                         && hasJavaModelChanged())
 106                                 JavaReconciler.this.forceReconciling();
 107                 }
 108
 109                 /*
 110                  * @see org.eclipse.swt.events.ShellListener#shellDeactivated(org.eclipse.swt.events.ShellEvent)
 111                  */
 112                 public void shellDeactivated(ShellEvent e) {
 113                         setJavaModelChanged(false);
 114                 }
 115         }
 116
 117         /**
 118          * Internal Java element changed listener
 119          *
 120          * @since 3.0
 121          */
 122         private class ElementChangedListener implements IElementChangedListener {
 123                 /*
 124                  * @see net.sourceforge.phpdt.core.IElementChangedListener#elementChanged(net.sourceforge.phpdt.core.ElementChangedEvent)
 125                  */
 126                 public void elementChanged(ElementChangedEvent event) {
 127                         setJavaModelChanged(true);
 128                 }
 129         }
 130
 131         /**
 132          * Internal resource change listener.
 133          *
 134          * @since 3.0
 135          */
 136         class ResourceChangeListener implements IResourceChangeListener {
 137
 138                 private IResource getResource() {
 139                         IEditorInput input = fTextEditor.getEditorInput();
 140                         if (input instanceof IFileEditorInput) {
 141                                 IFileEditorInput fileInput = (IFileEditorInput) input;
 142                                 return fileInput.getFile();
 143                         }
 144                         return null;
 145                 }
 146
 147                 /*
 148                  * @see IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent)
 149                  */
 150                 public void resourceChanged(IResourceChangeEvent e) {
 151                         IResourceDelta delta = e.getDelta();
 152                         IResource resource = getResource();
 153                         if (delta != null && resource != null) {
 154                                 IResourceDelta child = delta.findMember(resource.getFullPath());
 155                                 if (child != null) {
 156                                         IMarkerDelta[] deltas = child.getMarkerDeltas();
 157                                         if (deltas.length > 0)
 158                                                 forceReconciling();
 159                                 }
 160                         }
 161                 }
 162         }
 163
 164         /** The reconciler's editor */
 165         private ITextEditor fTextEditor;
 166
 167         /** The part listener */
 168         private IPartListener fPartListener;
 169
 170         /** The shell listener */
 171         private ShellListener fActivationListener;
 172
 173         /**
 174          * The mutex that keeps us from running multiple reconcilers on one editor.
 175          * TODO remove once we have ensured that there is only one reconciler per
 176          * editor.
 177          */
 178         private Object fMutex;
 179
 180         /**
 181          * The Java element changed listener.
 182          *
 183          * @since 3.0
 184          */
 185         private IElementChangedListener fJavaElementChangedListener;
 186
 187         /**
 188          * Tells whether the Java model sent out a changed event.
 189          *
 190          * @since 3.0
 191          */
 192         private volatile boolean fHasJavaModelChanged = true;
 193
 194         /**
 195          * The resource change listener.
 196          *
 197          * @since 3.0
 198          */
 199         private IResourceChangeListener fResourceChangeListener;
 200
 201         private boolean fIninitalProcessDone = false;
 202
 203         /**
 204          * Creates a new reconciler.
 205          */
 206         public JavaReconciler(ITextEditor editor,
 207                         JavaCompositeReconcilingStrategy strategy, boolean isIncremental) {
 208                 super(strategy, isIncremental);
 209                 fTextEditor = editor;
 210
 211                 // https://bugs.eclipse.org/bugs/show_bug.cgi?id=63898
 212                 // when re-using editors, a new reconciler is set up by the source
 213                 // viewer
 214                 // and the old one uninstalled. However, the old reconciler may still be
 215                 // running.
 216                 // To avoid having to reconcilers calling
 217                 // CompilationUnitEditor.reconciled,
 218                 // we synchronized on a lock object provided by the editor.
 219                 // The critical section is really the entire run() method of the
 220                 // reconciler
 221                 // thread, but synchronizing process() only will keep
 222                 // JavaReconcilingStrategy
 223                 // from running concurrently on the same editor.
 224                 // TODO remove once we have ensured that there is only one reconciler
 225                 // per editor.
 226                 if (editor instanceof PHPUnitEditor)
 227                         fMutex = ((PHPUnitEditor) editor).getReconcilerLock();
 228                 else
 229                         fMutex = new Object(); // Null Object
 230         }
 231
 232         /*
 233          * @see org.eclipse.jface.text.reconciler.IReconciler#install(org.eclipse.jface.text.ITextViewer)
 234          */
 235         public void install(ITextViewer textViewer) {
 236                 super.install(textViewer);
 237
 238                 fPartListener = new PartListener();
 239                 IWorkbenchPartSite site = fTextEditor.getSite();
 240                 IWorkbenchWindow window = site.getWorkbenchWindow();
 241                 window.getPartService().addPartListener(fPartListener);
 242
 243                 fActivationListener = new ActivationListener(textViewer.getTextWidget());
 244                 Shell shell = window.getShell();
 245                 shell.addShellListener(fActivationListener);
 246
 247                 fJavaElementChangedListener = new ElementChangedListener();
 248                 JavaCore.addElementChangedListener(fJavaElementChangedListener);
 249
 250                 fResourceChangeListener = new ResourceChangeListener();
 251                 IWorkspace workspace = WebUI.getWorkspace();
 252                 workspace.addResourceChangeListener(fResourceChangeListener);
 253         }
 254
 255         /*
 256          * @see org.eclipse.jface.text.reconciler.IReconciler#uninstall()
 257          */
 258         public void uninstall() {
 259
 260                 IWorkbenchPartSite site = fTextEditor.getSite();
 261                 IWorkbenchWindow window = site.getWorkbenchWindow();
 262                 window.getPartService().removePartListener(fPartListener);
 263                 fPartListener = null;
 264
 265                 Shell shell = window.getShell();
 266                 if (shell != null && !shell.isDisposed())
 267                         shell.removeShellListener(fActivationListener);
 268                 fActivationListener = null;
 269
 270                 JavaCore.removeElementChangedListener(fJavaElementChangedListener);
 271                 fJavaElementChangedListener = null;
 272
 273                 IWorkspace workspace = WebUI.getWorkspace();
 274                 workspace.removeResourceChangeListener(fResourceChangeListener);
 275                 fResourceChangeListener = null;
 276
 277                 super.uninstall();
 278         }
 279
 280         /*
 281          * @see org.eclipse.jface.text.reconciler.AbstractReconciler#forceReconciling()
 282          */
 283         protected void forceReconciling() {
 284                 if (!fIninitalProcessDone)
 285                         return;
 286
 287                 super.forceReconciling();
 288                 JavaCompositeReconcilingStrategy strategy = (JavaCompositeReconcilingStrategy) getReconcilingStrategy(IDocument.DEFAULT_CONTENT_TYPE);
 289                 strategy.notifyListeners(false);
 290         }
 291
 292         /*
 293          * @see org.eclipse.jface.text.reconciler.AbstractReconciler#aboutToReconcile()
 294          * @since 3.0
 295          */
 296         protected void aboutToBeReconciled() {
 297                 JavaCompositeReconcilingStrategy strategy = (JavaCompositeReconcilingStrategy) getReconcilingStrategy(IDocument.DEFAULT_CONTENT_TYPE);
 298                 strategy.aboutToBeReconciled();
 299         }
 300
 301         /*
 302          * @see org.eclipse.jface.text.reconciler.AbstractReconciler#reconcilerReset()
 303          */
 304         protected void reconcilerReset() {
 305                 super.reconcilerReset();
 306                 JavaCompositeReconcilingStrategy strategy = (JavaCompositeReconcilingStrategy) getReconcilingStrategy(IDocument.DEFAULT_CONTENT_TYPE);
 307                 strategy.notifyListeners(true);
 308         }
 309
 310         /*
 311          * @see org.eclipse.jface.text.reconciler.MonoReconciler#initialProcess()
 312          */
 313         protected void initialProcess() {
 314                 // TODO remove once we have ensured that there is only one reconciler
 315                 // per editor.
 316                 synchronized (fMutex) {
 317                         super.initialProcess();
 318                 }
 319                 fIninitalProcessDone = true;
 320         }
 321
 322         /*
 323          * @see org.eclipse.jface.text.reconciler.MonoReconciler#process(org.eclipse.jface.text.reconciler.DirtyRegion)
 324          */
 325         protected void process(DirtyRegion dirtyRegion) {
 326                 // TODO remove once we have ensured that there is only one reconciler
 327                 // per editor.
 328                 synchronized (fMutex) {
 329                         super.process(dirtyRegion);
 330                 }
 331         }
 332
 333         /**
 334          * Tells whether the Java Model has changed or not.
 335          *
 336          * @return <code>true</code> iff the Java Model has changed
 337          * @since 3.0
 338          */
 339         private synchronized boolean hasJavaModelChanged() {
 340                 return fHasJavaModelChanged;
 341         }
 342
 343         /**
 344          * Sets whether the Java Model has changed or not.
 345          *
 346          * @param state
 347          *            <code>true</code> iff the java model has changed
 348          * @since 3.0
 349          */
 350         private synchronized void setJavaModelChanged(boolean state) {
 351                 fHasJavaModelChanged = state;
 352         }
 353 }
 354 // /**
 355 // * A reconciler that is also activated on editor activation.
 356 // */
 357 // public class JavaReconciler extends MonoReconciler {
 358 //
 359 // /**
 360 // * Internal part listener for activating the reconciler.
 361 // */
 362 // class PartListener implements IPartListener {
 363 //
 364 // /*
 365 // * @see IPartListener#partActivated(IWorkbenchPart)
 366 // */
 367 // public void partActivated(IWorkbenchPart part) {
 368 // if (part == fTextEditor)
 369 // JavaReconciler.this.forceReconciling();
 370 // }
 371 //
 372 // /*
 373 // * @see IPartListener#partBroughtToTop(IWorkbenchPart)
 374 // */
 375 // public void partBroughtToTop(IWorkbenchPart part) {
 376 // }
 377 //
 378 // /*
 379 // * @see IPartListener#partClosed(IWorkbenchPart)
 380 // */
 381 // public void partClosed(IWorkbenchPart part) {
 382 // }
 383 //
 384 // /*
 385 // * @see IPartListener#partDeactivated(IWorkbenchPart)
 386 // */
 387 // public void partDeactivated(IWorkbenchPart part) {
 388 // }
 389 //
 390 // /*
 391 // * @see IPartListener#partOpened(IWorkbenchPart)
 392 // */
 393 // public void partOpened(IWorkbenchPart part) {
 394 // }
 395 // };
 396 //
 397 //
 398 // /** The reconciler's editor */
 399 // private ITextEditor fTextEditor;
 400 // /** The part listener */
 401 // private IPartListener fPartListener;
 402 //
 403 //
 404 // /**
 405 // * Creates a new reconciler.
 406 // */
 407 // public JavaReconciler(ITextEditor editor, IReconcilingStrategy strategy,
 408 // boolean isIncremental) {
 409 // super(strategy, isIncremental);
 410 // fTextEditor= editor;
 411 // }
 412 //
 413 // /*
 414 // * @see IReconciler#install(ITextViewer)
 415 // */
 416 // public void install(ITextViewer textViewer) {
 417 // super.install(textViewer);
 418 //
 419 // fPartListener= new PartListener();
 420 // IWorkbenchPartSite site= fTextEditor.getSite();
 421 // IWorkbenchWindow window= site.getWorkbenchWindow();
 422 // window.getPartService().addPartListener(fPartListener);
 423 // }
 424 //
 425 // /*
 426 // * @see IReconciler#uninstall()
 427 // */
 428 // public void uninstall() {
 429 //
 430 // IWorkbenchPartSite site= fTextEditor.getSite();
 431 // IWorkbenchWindow window= site.getWorkbenchWindow();
 432 // window.getPartService().removePartListener(fPartListener);
 433 // fPartListener= null;
 434 //
 435 // super.uninstall();
 436 // }
 437 //
 438 // /*
 439 // * @see AbstractReconciler#forceReconciling()
 440 // */
 441 // protected void forceReconciling() {
 442 // super.forceReconciling();
 443 // IReconcilingStrategy strategy=
 444 // getReconcilingStrategy(IDocument.DEFAULT_CONTENT_TYPE);
 445 // if (strategy instanceof JavaReconcilingStrategy) {
 446 // JavaReconcilingStrategy java= (JavaReconcilingStrategy) strategy;
 447 // java.notifyParticipants(false);
 448 // }
 449 // }
 450 //
 451 // /*
 452 // * @see AbstractReconciler#reconcilerReset()
 453 // */
 454 // protected void reconcilerReset() {
 455 // super.reconcilerReset();
 456 // IReconcilingStrategy strategy=
 457 // getReconcilingStrategy(IDocument.DEFAULT_CONTENT_TYPE);
 458 // if (strategy instanceof JavaReconcilingStrategy) {
 459 // JavaReconcilingStrategy java= (JavaReconcilingStrategy) strategy;
 460 // java.notifyParticipants(true);
 461 // }
 462 // }
 463 // }