"Open Type" Feature von Eclipse auf eigenen ListViewer anwenden

chris_sit

Erfahrenes Mitglied
Hallo zusammen,

ich habe mal ein wenig gegoogelt, kam jedoch nicht sonderlich weit. In Eclipse gibt es ja auf dem Shortcut STRG+Shift+T ein nettes Feature, um alle bekannten Java-Klassen im Workspace zu "filtern".
Sobald ich etwas eintippe, wird der Filter auf die Liste angewendet und die uninteressanten Elemente fliegen raus.

Bisher habe ich eine Textbox, dort kann ich etwas eingeben und wenn ich meine Eingabe bestätige wird erst gefiltert - wie bekomme ich das "on-the-fly" am elegantesten gelöst - wird das nötige Handwerkszeug vielleicht von Eclipse bereitgestellt und ich finde es nur nicht?

Bin für jeden Tipp dankbar =)

-chris
 
Ja, aber mir ging es nun eher um das "on-the-fly" filtering, also während ich in einem Textfeld etwas eintippe, werden die Ergenisse direkt gefiltert.. oder steh' ich mal wieder auf dem Schlauch?!
 
Hallo,

gar nicht so schwer. Ich weis gerade nicht ob Eclipse da schon von Haus aus etwas bietet aber zur Not kann man sich das auch folgendermaßen selbst bauen:
Bei deinem Suchtextfeld registrierst du einen Listener der bei Texteingabe getriggert wird.
Anschließend konfigurierst du einfach einen entsprechenden Filter und läst den über den ContentProvider bzw. das Modell das dem TreeViewer zugrundeliegt (rekursiv) laufen. Dabei sammelst du dann alle Ergebnisse (Matches) auf und fügst sie in eine Liste ein die du dann (beispielsweise über einen ListViewer) darstellst.

Kann man sich auch bei:
org.eclipse.jdt.internal.ui.dialogs.TypeSelectionDialog2 / org.eclipse.jdt.internal.ui.dialogs.OpenTypeSelectionDialog2 im org.eclipse.jdt.ui Plugin abkucken.

Gruß Tom
 
Dickes Danke =)

Habe zu dem von dir genannten Plugin bisher zwar nur die class-Files gefunden, werde ich heute Abend mal nach den Sourcen suchen.

Vielen Dank
-Chris
 
Hallo,

hier mal ein kleines Beispiel wie man eine JFace ListView dynamisch filtern kann:
Java:
/**
 * 
 */
package de.tutorials;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ListViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.jface.window.ApplicationWindow;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

/**
 * @author Tom
 */
public class JFaceFilteredListExample extends ApplicationWindow {

  public JFaceFilteredListExample(Shell parentShell) {
    super(parentShell);
    setBlockOnOpen(true);
  }

  @Override
  protected boolean showTopSeperator() {
    return false;
  }

  @Override
  protected Control createContents(Composite parent) {
    parent.setLayout(new GridLayout(1, true));
    final Text txtSearch = new Text(parent, SWT.BORDER);
    final ListViewer listViewer = new ListViewer(parent);

    TreeNode root = createTreeModel();
    Object[] flattenedTree = flatten(root);

    listViewer.setSorter(new ViewerSorter());
    listViewer.setContentProvider(new ArrayContentProvider());
    listViewer.setInput(flattenedTree);
    listViewer.addFilter(new ViewerFilter() {
      public boolean select(Viewer viewer, Object parentElement, Object element) {
        return element.toString().toLowerCase().startsWith(txtSearch.getText().toLowerCase());
      }
    });

    txtSearch.addKeyListener(new KeyAdapter() {
      public void keyReleased(KeyEvent e) {
        listViewer.refresh();
      }
    });

    parent.pack();
    return parent;
  };


  private Object[] flatten(TreeNode root) {
    List<TreeNode> nodes = new ArrayList<TreeNode>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    stack.push(root);
    while (!stack.isEmpty()) {
      TreeNode currentNode = stack.pop();
      nodes.add(currentNode);
      for (TreeNode child : currentNode.children) {
        stack.push(child);
      }
    }
    System.out.println(nodes);
    return nodes.toArray();
  }


  private TreeNode createTreeModel() {
    TreeNode root = new TreeNode("root");
    TreeNode nodeA = root.addChild(new TreeNode("A"));
    TreeNode nodeAA = nodeA.addChild(new TreeNode("AAX"));
    TreeNode nodeAB = nodeA.addChild(new TreeNode("AB"));
    TreeNode nodeABA = nodeAB.addChild(new TreeNode("ABAX"));

    TreeNode nodeB = root.addChild(new TreeNode("B"));
    TreeNode nodeBA = nodeB.addChild(new TreeNode("BA"));
    TreeNode nodeBB = nodeB.addChild(new TreeNode("BBX"));
    return root;
  }


  /**
   * @param args
   */
  public static void main(String[] args) {
    new JFaceFilteredListExample(new Shell(SWT.MIN)).open();
  }

  static class TreeNode {
    String id;
    int value;
    List<TreeNode> children;
    TreeNode parent;


    public TreeNode(String id) {
      this.id = id;
      this.value = id.hashCode();
      this.children = new ArrayList<TreeNode>();
    }


    TreeNode addChild(TreeNode node) {
      this.children.add(node);
      node.parent = this;
      return node;
    }


    TreeNode[] getChildren() {
      return this.children.toArray(new TreeNode[children.size()]);
    }


    boolean hasChildren() {
      return !this.children.isEmpty();
    }


    TreeNode getParent() {
      return this.parent;
    }


    /**
     * @return the id
     */
    public String getId() {
      return this.id;
    }


    /**
     * @param id the id to set
     */
    public void setId(String id) {
      this.id = id;
    }


    /**
     * @return the value
     */
    public int getValue() {
      return this.value;
    }


    /**
     * @param value the value to set
     */
    public void setValue(int value) {
      this.value = value;
    }


    public String toString() {
      return this.id + ": " + this.value;
    }
  }
}

Gruß Tom
 
Zurück