package runjettyrun.tabs.classpath;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import runjettyrun.tabs.AbstractClasspathTab;
/**
* Content provider that maintains a list of classpath entries which are shown in a tree
* viewer.
*/
public class UserClassesClasspathContentProvider implements ITreeContentProvider {
private TreeViewer treeViewer;
private UserClassesClasspathModel model= null;
private boolean refreshEnabled= false;
private boolean refreshRequested= false;
private AbstractClasspathTab fTab;
public UserClassesClasspathContentProvider(AbstractClasspathTab tab) {
fTab = tab;
}
public void add(IRJRClasspathEntry parent, IRuntimeClasspathEntry child, Object beforeElement) {
Object newEntry= null;
if (parent == null || parent == model) {
newEntry= model.addEntry(child);
parent= model;
} else if (parent instanceof ClasspathGroup) {
newEntry= model.createEntry(child, parent);
((ClasspathGroup)parent).addEntry((ClasspathEntry)newEntry, beforeElement);
}
if (newEntry != null) {
treeViewer.add(parent, newEntry);
treeViewer.setExpandedState(parent, true);
treeViewer.reveal(newEntry);
refresh();
}
}
public void add(int entryType, IRuntimeClasspathEntry child) {
Object newEntry= model.addEntry(entryType, child);
if (newEntry != null) {
treeViewer.add(getParent(newEntry), newEntry);
refresh();
}
}
public void removeAll() {
model.removeAll();
refresh();
}
private void refresh() {
if (refreshEnabled) {
treeViewer.refresh();
refreshRequested= false;
} else {
refreshRequested= true;
}
}
public void removeAll(IRJRClasspathEntry parent) {
if (parent instanceof ClasspathGroup) {
((ClasspathGroup)parent).removeAll();
}
refresh();
}
/**
* @see ITreeContentProvider#getParent(Object)
*/
public Object getParent(Object element) {
if (element instanceof ClasspathEntry) {
return ((ClasspathEntry)element).getParent();
}
if (element instanceof ClasspathGroup) {
return model;
}
return null;
}
/**
* @see ITreeContentProvider#hasChildren(Object)
*/
public boolean hasChildren(Object element) {
if (element instanceof ClasspathEntry) {
return (((ClasspathEntry)element).hasChildren());
}
if (element instanceof ClasspathGroup) {
return ((ClasspathGroup)element).hasEntries();
}
if (element instanceof UserClassesClasspathModel) {
return ((UserClassesClasspathModel) element).hasEntries();
}
return false;
}
/**
* @see IStructuredContentProvider#getElements(Object)
*/
public Object[] getElements(Object inputElement) {
return getChildren(inputElement);
}
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.IContentProvider#dispose()
*/
public void dispose() {
}
/* (non-Javadoc)
* @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) {
treeViewer = (TreeViewer) viewer;
if (newInput != null) {
model= (UserClassesClasspathModel)newInput;
} else {
if (model != null) {
model.removeAll();
}
model= null;
}
}
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)
*/
public Object[] getChildren(Object parentElement) {
if (parentElement instanceof ClasspathGroup) {
Object[] returnObjectArray = ((ClasspathGroup) parentElement)
.getEntries();
return returnObjectArray;
}
if (parentElement instanceof UserClassesClasspathModel) {
Object[] returnObjectArray = ((UserClassesClasspathModel) parentElement)
.getEntries();
return returnObjectArray;
}
if (parentElement instanceof ClasspathEntry) {
return ((ClasspathEntry)parentElement).getChildren(fTab.getLaunchConfiguration());
}
if (parentElement == null) {
List<Object> all= new ArrayList<Object>();
IRJRClasspathEntry[] topEntries= model.getEntries();
for (int i = 0; i < topEntries.length; i++) {
Object object = topEntries[i];
if (object instanceof ClasspathEntry) {
all.add(object);
} else if (object instanceof ClasspathGroup) {
all.addAll(Arrays.asList(((ClasspathGroup)object).getEntries()));
}
}
Object[] returnObjectArray = all.toArray();
return returnObjectArray;
}
return null;
}
public void removeAll(List<?> selection) {
Object[] array= selection.toArray();
model.removeAll(array);
treeViewer.remove(array);
refresh();
}
public IRJRClasspathEntry[] getCustomClasspathEntries() {
return model.getEntries(UserClassesClasspathModel.CUSTOM);
}
public IRJRClasspathEntry[] getUserClasspathEntries() {
return model.getEntries(UserClassesClasspathModel.USER);
}
public void handleMove(boolean direction, IRJRClasspathEntry entry) {
IRJRClasspathEntry parent = (IRJRClasspathEntry)getParent(entry);
parent.moveChild(direction, entry);
}
public UserClassesClasspathModel getModel() {
return model;
}
public void setRefreshEnabled(boolean refreshEnabled) {
this.refreshEnabled = refreshEnabled;
treeViewer.getTree().setRedraw(refreshEnabled);
if (refreshEnabled && refreshRequested) {
refresh();
}
}
public void setCustomEntries(IRuntimeClasspathEntry[] entries) {
model.cleanRootGroup(UserClassesClasspathModel.CUSTOM);
for (int i = 0; i < entries.length; i++) {
model.addEntry(UserClassesClasspathModel.CUSTOM, entries[i]);
}
refresh();
}
public void setEntries(IRuntimeClasspathEntry[] entries) {
model.cleanRootGroup(UserClassesClasspathModel.USER);
IRuntimeClasspathEntry entry;
for (int i = 0; i < entries.length; i++) {
entry= entries[i];
switch (entry.getClasspathProperty()) {
case IRuntimeClasspathEntry.USER_CLASSES:
model.addEntry(UserClassesClasspathModel.USER, entry);
break;
}
}
refresh();
}
}