TreeViewer

org.eclipse.jface.viewers.TreeViewer

Siehe auch: TreeViewer mit mehreren Spalten

package com.sowas.javawiki.rpcbaseapplication;
 
import java.util.ArrayList;
import java.util.List;
 
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;
 
public class View extends ViewPart {
   public static final String	ID	= "TreeViewerDemo.view";
   private TreeViewer			m_treeViewer;
 
   class ViewLabelProvider extends LabelProvider implements ILabelProvider {
      public String getColumnText(Object obj, int index) {
         return getText(obj);
      }
 
      public Image getColumnImage(Object obj, int index) {
         return getImage(obj);
      }
 
      public Image getImage(Object obj) {
         return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT);
      }
   }
 
 
   public void createPartControl(Composite parent) {
      Tree addressTree = new Tree(parent, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
      addressTree.setHeaderVisible(true);
      m_treeViewer = new TreeViewer(addressTree);
      m_treeViewer.setContentProvider(new AddressContentProvider());
      m_treeViewer.setLabelProvider(new LabelProvider());  // Der LabelProvider verwendet die toString()-Methode
      List<City> cities = new ArrayList<City>();
      cities.add(new City());
      m_treeViewer.setInput(cities);
      m_treeViewer.expandAll();
   }
 
 
   public void setFocus() {
      m_treeViewer.getControl().setFocus();
   }
 
 
   class City{	
      Street[] streets = new Street[4];
 
      public City(){
         for (int i = 0; i<streets.length; i++)
            streets[i] = new Street(this, i);
      }
 
      public Street[] getStreets(){
         return streets;
      }
 
      public String toString(){ 
         return "Küchenhausen"; 
      }
   }
 
 
   class Street{
      City    city;
      House[] houses = new House[2];
      int     indx;
 
      public Street(City city, int index){
         this.city = city;
         indx = index + 1;
         for (int i = 0; i<houses.length; i++)
            houses[i] = new House(this, i);
      }
 
      public House[] getHouses(){
         return houses;
      }
 
      public String toString(){
         return "Topfdeckelstraße "+indx; 
      }
   }
 
 
   class House{
      Street	street;
      int       indx;
 
      public House(Street street, int i){
         this.street = street;
         indx = i + 1;
      }
 
      public String toString(){
         return "Haus " + indx;
      }
   }
 
 
   class AddressContentProvider implements ITreeContentProvider {
 
      /**
       * Liefert die Kinder eines Elements
       */
      public Object[] getChildren(Object parentElement) {
         if (parentElement instanceof List)
            return ((List<?>) parentElement).toArray();
         if (parentElement instanceof City)
            return ((City) parentElement).getStreets();
         if (parentElement instanceof Street)
            return ((Street) parentElement).getHouses();
         return new Object[0];
      }
 
      /**
       * Liefert die Eltern eines Elements
       */
      public Object getParent(Object element) {
         if (element instanceof Street)
            return ((Street)element).city;
         if (element instanceof House)
            return ((House)element).street;
         return null;
      }
 
      /**
       * Liefert, ob ein Element Kinder hat
       */
      public boolean hasChildren(Object element) {
         if (element instanceof List)
            return ((List<?>) element).size() > 0;
         if (element instanceof City)
            return ((City) element).getStreets().length > 0;
         if (element instanceof Street)
            return ((Street) element).getHouses().length > 0;
         return false;
      }
 
      /**
       * Liefert die Root-Elemente
       * Kann daher meist getChildren() aufrufen
       */
      public Object[] getElements(Object inputElement) {
         return getChildren(inputElement);
      }
 
      public void dispose() {	
      }
 
      public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {	
      }
   }
}