Java Code Examples for org.eclipse.jdt.core.JavaCore#removeElementChangedListener()

public void doHierarchyRefresh(IJavaElement[] elements, IProgressMonitor pm) throws JavaModelException {
	boolean hierachyCreationNeeded= (fHierarchy == null || !Arrays.equals(elements, fInputElements));
	// to ensure the order of the two listeners always remove / add listeners on operations
	// on type hierarchies
	if (fHierarchy != null) {
		fHierarchy.removeTypeHierarchyChangedListener(this);
		JavaCore.removeElementChangedListener(this);
	}
	if (hierachyCreationNeeded) {
		fHierarchy= createTypeHierarchy(elements, pm);
		if (pm != null && pm.isCanceled()) {
			throw new OperationCanceledException();
		}
		fInputElements= elements;
	} else {
		fHierarchy.refresh(pm);
		if (pm != null && pm.isCanceled())
			throw new OperationCanceledException();
	}
	fHierarchy.addTypeHierarchyChangedListener(this);
	JavaCore.addElementChangedListener(this);
	fHierarchyRefreshNeeded= false;
}
 

@Override
public void uninstall() {

	IWorkbenchPartSite site= fTextEditor.getSite();
	IWorkbenchWindow window= site.getWorkbenchWindow();
	window.getPartService().removePartListener(fPartListener);
	fPartListener= null;

	Shell shell= window.getShell();
	if (shell != null && !shell.isDisposed())
		shell.removeShellListener(fActivationListener);
	fActivationListener= null;

	JavaCore.removeElementChangedListener(fJavaElementChangedListener);
	fJavaElementChangedListener= null;

	IWorkspace workspace= JavaPlugin.getWorkspace();
	workspace.removeResourceChangeListener(fResourceChangeListener);
	fResourceChangeListener= null;

	JavaPlugin.getDefault().getCombinedPreferenceStore().removePropertyChangeListener(fPropertyChangeListener);
	fPropertyChangeListener= null;

	super.uninstall();
}
 

public String waitForElementChangedEvent(final int eventMask, final Procedure0 producer) {
  String _xblockexpression = null;
  {
    if ((JavaEditorExtension.VERBOSE).booleanValue()) {
      StringConcatenation _builder = new StringConcatenation();
      _builder.append("start waiting for an element changed event: ");
      _builder.append(eventMask);
      InputOutput.<String>println(_builder.toString());
    }
    final ArrayList<Boolean> changed = CollectionLiterals.<Boolean>newArrayList(Boolean.valueOf(false));
    final IElementChangedListener _function = new IElementChangedListener() {
      @Override
      public void elementChanged(final ElementChangedEvent it) {
        JavaCore.removeElementChangedListener(this);
        Boolean _head = IterableExtensions.<Boolean>head(changed);
        boolean _not = (!(_head).booleanValue());
        if (_not) {
          changed.set(0, Boolean.valueOf(true));
          if ((JavaEditorExtension.VERBOSE).booleanValue()) {
            InputOutput.<ElementChangedEvent>println(it);
          }
        }
      }
    };
    JavaCore.addElementChangedListener(_function, eventMask);
    producer.apply();
    while ((!(IterableExtensions.<Boolean>head(changed)).booleanValue())) {
    }
    String _xifexpression = null;
    if ((JavaEditorExtension.VERBOSE).booleanValue()) {
      StringConcatenation _builder_1 = new StringConcatenation();
      _builder_1.append("end waiting for an element changed event: ");
      _builder_1.append(eventMask);
      _xifexpression = InputOutput.<String>println(_builder_1.toString());
    }
    _xblockexpression = _xifexpression;
  }
  return _xblockexpression;
}
 

@Override
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
	super.inputChanged(viewer, oldInput, newInput);
	fViewer= (TreeViewer)viewer;
	if (oldInput == null && newInput != null) {
		JavaCore.addElementChangedListener(this);
	} else if (oldInput != null && newInput == null) {
		JavaCore.removeElementChangedListener(this);
	}
	fInput= newInput;
}
 

/**
 * {@inheritDoc}
 */
public void dispose() {
	synchronized(fWorkingSets) {
		fWorkingSets.clear();
	}
	JavaCore.removeElementChangedListener(this);
}
 

public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
	if (newInput != null) {
		JavaCore.addElementChangedListener(this);
	} else {
		JavaCore.removeElementChangedListener(this);
	}
	fInputIsProject= (newInput instanceof IJavaProject);

	if(viewer instanceof StructuredViewer)
		fViewer= (StructuredViewer)viewer;
}
 

public void discard() {
	JavaCore.removeElementChangedListener(javaChangeQueueFiller);

	JavaCore.removeElementChangedListener(typeResourceUnloader);
	typeResourceUnloader.removeListener(eventBroker);
}
 

void clear() {
	JavaCore.removeElementChangedListener(classpathChagedListener);
	currentPlatform = null;
	addResourceChangeListenerToWorkspace();
}
 

public void removeElementChangeListener() {
	JavaCore.removeElementChangedListener(this);
}
 

@Override
public void unregisterAsListener() {
	JavaCore.removeElementChangedListener(this);
	super.unregisterAsListener();
}
 

@Override
public void dispose() {
	super.dispose();
	JavaCore.removeElementChangedListener(this);
}
 

/**
 * Waits indefinitely until the given classpath entries are on the given
 * project's raw classpath.
 *
 * @throws JavaModelException
 * @throws InterruptedException
 */
public static void waitUntilEntriesAreOnClasspath(
    final IJavaProject javaProject,
    final List<IClasspathEntry> classpathEntries) throws JavaModelException,
    InterruptedException {

  // Used to notify when we are finished -- either all entries are on the
  // classpath or the anon class had an exception
  final Object finished = new Object();
  final JavaModelException[] anonClassException = new JavaModelException[1];

  ClasspathChangedListener listener = new ClasspathChangedListener() {
    @Override
    protected void classpathChanged(IJavaProject curJavaProject) {
      synchronized (finished) {
        try {
          if (curJavaProject.equals(javaProject)
              && areEntriesOnClasspath(javaProject, classpathEntries)) {
            finished.notifyAll();
          }
        } catch (JavaModelException e) {
          anonClassException[0] = e;
          finished.notifyAll();
        }
      }
    }
  };

  synchronized (finished) {
    JavaCore.addElementChangedListener(listener);

    try {
      // We're in a state where either the entries already exist on the
      // classpath, or we have a callback queued up (because of the
      // synchronization on finished) that will notify us when they are added.
      while (!areEntriesOnClasspath(javaProject, classpathEntries)) {
        finished.wait();
      }

      if (anonClassException[0] != null) {
        throw anonClassException[0];
      }
    } finally {
      JavaCore.removeElementChangedListener(listener);
    }
  }
}
 

/**
 * Stops listening for changes.
 */
public void stop() {
  JavaCore.removeElementChangedListener(classpathChangedListener);
}
 

/**
 * Stops tracking element changes.
 */
void stop() {
  JavaCore.removeElementChangedListener(this);
}
 

private void doShutdown() {
	JavaCore.removeElementChangedListener(fDeltaListener);
	save();
}
 

public void dispose() {
	if (fListener != null) {
		JavaCore.removeElementChangedListener(fListener);
		fListener= null;
	}
}
 

public void dispose() {
	super.dispose();
	getSite().getWorkbenchWindow().getSelectionService().removeSelectionListener(selectionListener);
	JavaCore.removeElementChangedListener(elementChangedListener);
}
 

/**
 * Uninstalls the synchronizer.
 */
public void uninstall() {
	JavaCore.removeElementChangedListener(this);
}
 

@Override
public void dispose() {
	super.dispose();
	JavaCore.removeElementChangedListener(this);
	JavaPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(this);
}
 

@Override
public void stop(BundleContext context) {
  JavaCore.removeElementChangedListener(listener);
}