Probleme bie Erweiterung Plugin Call Hierarchy

E

Est4cado

Grünschnabel
Hallo,

ich versuche gerade das Plugin für den Call Hierarchy Aufruf um weitere Fuktionalitäten zu erweitern und stehe hier vor einem Problem. Habe nun soweit meine View auf Basis der CallHierarchyViewPart erstellt und mit Funktionalitäten erweitert.
Eine dieser Funktionen soll beinhalten, dass der Baum auf Wunsch komplett aufgeklappt werden kann. Dazu habe ich nun weitere extends eingebaut, um meinen eigenen ContentProvider einzuschleussen. (Hört sich fies an, gell?).
Nun laufen alle Anfragen über den neuen ContentProvider, der für Recherchen den alten erstmal im Prinzip im nichts nachsteht.

Der Code ist identisch! Doch trotzdem wird nun schon bei Aufruf, also bei Initialisierung der ViewPart ein Fehler geworfen. Ich hoffe, jemanden kann mir hier ein wenig unter die Arme greifen, da ich es einfach nicht verstehe... Code habe ich mir schon angeschaut, dank sei dem Open Source, aber einfach nichts feststelllen können:

Der neue ContentProvider:

Code: 
package org.eclipse.jdt.internal.ui.callhierarchy;

import java.lang.reflect.InvocationTargetException;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.operation.IRunnableContext;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jdt.core.IJavaElement;

import org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.callhierarchy.CallHierarchyContentProvider;
import org.eclipse.jdt.internal.ui.callhierarchy.CallHierarchyMessages;
import org.eclipse.jdt.internal.ui.callhierarchy.CallHierarchyUI;
import org.eclipse.jdt.internal.ui.callhierarchy.CallHierarchyViewPart;
import org.eclipse.jdt.internal.ui.callhierarchy.DeferredMethodWrapper;
import org.eclipse.jdt.internal.ui.util.ExceptionHandler;
import org.eclipse.ui.progress.DeferredTreeContentManager;

import org.eclipse.jdt.internal.ui.callhierarchy.TreeRootExtended;

public class CallHierarchyExtendedContentProvider extends
		CallHierarchyContentProvider {

	private final static Object[] EMPTY_ARRAY = new Object[0];

	private CallHierarchyViewPart fPart;

	private DeferredTreeContentManager fManager;

	private class MethodWrapperRunnable implements IRunnableWithProgress {
		private MethodWrapper fMethodWrapper;

		private MethodWrapper[] fCalls = null;

		MethodWrapperRunnable(MethodWrapper methodWrapper) {
			fMethodWrapper = methodWrapper;
		}

		public void run(IProgressMonitor pm) {
			fCalls = fMethodWrapper.getCalls(pm);
		}

		MethodWrapper[] getCalls() {
			if (fCalls != null) {
				return fCalls;
			}
			return new MethodWrapper[0];
		}
	}

	public CallHierarchyExtendedContentProvider(CallHierarchyViewPart part) {
		super(part);
		this.fPart = part;
	}

	/**
	 * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)
	 * 
	 */
	public Object[] getChildren(Object parentElement) {

		System.out.println("element: " + parentElement.getClass());

		if (parentElement instanceof TreeRoot) {

			// TODO: Hier austausch des Roots
			TreeRoot dummyRoot = (TreeRoot) parentElement;

//			TreeRootExtended dummyExtRoot = new TreeRootExtended(dummyRoot
//					.getRoot());

			return new Object[] { dummyRoot.getRoot()};
			
			
		} else if (parentElement instanceof MethodWrapper) {
			MethodWrapper methodWrapper = ((MethodWrapper) parentElement);
			if (shouldStopTraversion(methodWrapper)) {
				return EMPTY_ARRAY;
			} else {
				if (this.fManager != null) {
					Object[] children = this.fManager
							.getChildren(new DeferredMethodWrapper(this,
									methodWrapper));
					if (children != null)
						return children;
				}
				return fetchChildren(methodWrapper);
			}
		}

		return EMPTY_ARRAY;
	}

	protected Object[] fetchChildren(MethodWrapper methodWrapper) {
		IRunnableContext context = JavaPlugin.getActiveWorkbenchWindow();
		MethodWrapperRunnable runnable = new MethodWrapperRunnable(
				methodWrapper);
		try {
			context.run(true, true, runnable);
		} catch (InvocationTargetException e) {
			ExceptionHandler
					.handle(
							e,
							CallHierarchyMessages.CallHierarchyContentProvider_searchError_title,
							CallHierarchyMessages.CallHierarchyContentProvider_searchError_message);
			return EMPTY_ARRAY;
		} catch (InterruptedException e) {
			return new Object[] { TreeTermination.SEARCH_CANCELED };
			// return new Object[] { new String("Search Canceled") };
		}

		return runnable.getCalls();
	}

	private boolean shouldStopTraversion(MethodWrapper methodWrapper) {
		return (methodWrapper.getLevel() > CallHierarchyUI.getDefault()
				.getMaxCallDepth())
				|| methodWrapper.isRecursive();
	}

	/**
	 * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
	 */
	public Object[] getElements(Object inputElement) {
		return getChildren(inputElement);
	}

	/**
	 * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object)
	 */
	public Object getParent(Object element) {
		if (element instanceof MethodWrapper) {
			return ((MethodWrapper) element).getParent();
		}

		return null;
	}

	/**
	 * @see org.eclipse.jface.viewers.IContentProvider#dispose()
	 */
	public void dispose() {
		// Nothing to dispose
	}

	/**
	 * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)
	 */
	public boolean hasChildren(Object element) {
		if (element == TreeRoot.EMPTY_ROOT
				|| element == TreeTermination.SEARCH_CANCELED) {

			return false;
		}

		// Only methods can have subelements, so there's no need to fool
		// the
		// user into believing that there is more
		if (element instanceof MethodWrapper) {
			MethodWrapper methodWrapper = (MethodWrapper) element;
			if (methodWrapper.getMember().getElementType() != IJavaElement.METHOD) {
				return false;
			}
			if (shouldStopTraversion(methodWrapper)) {
				return false;
			}
			return true;
		} else if (element instanceof TreeRoot) {
			return true;
		} else if (element instanceof DeferredMethodWrapper) {
			// Err on the safe side by returning true even though
			// we don't know for sure that there are children.
			return true;
		}

		return false; // the "Update ..." placeholder has no children
	}

	/**
	 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
	 *      java.lang.Object, java.lang.Object)
	 */
	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		System.out.println("xx");
		if (oldInput instanceof TreeRoot) {
			Object root = ((TreeRoot) oldInput).getRoot();
			if (root instanceof MethodWrapper) {
				cancelJobs((MethodWrapper) root);
			}
		}
		if (viewer instanceof AbstractTreeViewer) {
			this.fManager = new DeferredTreeContentManager(this,
					(AbstractTreeViewer) viewer, fPart.getSite());
		}
	}

	/**
	 * Cancel all current jobs.
	 */
	void cancelJobs(MethodWrapper wrapper) {
		if (this.fManager != null && wrapper != null) {
			this.fManager.cancel(wrapper);
			if (fPart != null) {
				fPart.setCancelEnabled(false);
			}
		}
	}

	/**
	 * 
	 */
	public void doneFetching() {
		if (fPart != null) {
			fPart.setCancelEnabled(false);
		}
	}

	/**
	 * 
	 */
	public void startFetching() {
		if (fPart != null) {
			fPart.setCancelEnabled(true);
		}
	}
}

In der Methode
Code: 
public Object[] getChildren(Object parentElement)
wird bei z.B. "drag&drop" einer Methode in die View das Root-Objekt übergeben. Nach InstanceOf-Check wird dann der Aufruf
Code: 
dummyRoot.getRoot
aufgerufen und genau hier wird der Fehler geworfen.

Hier der doch sehr einfach Code der TreeRoot-Klasse:

Code: 
public class TreeRoot{

	private Object myRoot;

	/**
	 * Constructor for TreeRoot.
	 */
	public TreeRootExtended(Object root) {
		super(root);

		this.myRoot = root;
	}

	public Object getRoot() {
		return this.myRoot;
	}
}

Wie man sieht, passiert hier nichts ausserordentliches. Was auffällt, der Methoden-Kopf besitzt keine Zugriff-Klassifizierung, wie public oder privat. Der Aufruf ist somit nur von Instanzen aus der gleiche Package möglich.
Daher habe ich auch meinen ContentProvider in das entsprechende Package gelegt.

Könnte hier ein Problem sein?

Desweiteren zeigt mir Eclipse bei allen von mir verwendeten Aufrufen eines fremden Plugins eine Hinweis an der Seite mit der Meldung
"Discouraged access: The method getRoot() from the type TreeRoot is not accessible due to restriction on required library C:\user\cim\eclipse\Eclipse-bol-3.2\eclipse\plugins\org.eclipse.jdt.ui_3.2.2.r322_v20070124.jar de.aldata.eclipse/src/org/eclipse/jdt/internal/ui/callhierarchy CallHierarchyExtendedContentProvider.java"

Habe es bisher nicht hinbekommen, dies zu unterbinden. Hieran könnte es auch vielleicht liegen.

schonmal ein danke, dass ihr euch mein jammern "anhört".

Grüße Est4cado
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück