You can use the TableViewer class to create tables using the JFace framework. The SWT Table widget is wrapped into the TableViewer and can still be accessed to set its properties.

// Define the TableViewer
viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
      | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);

// Create the columns 
// Not yet implemented
createColumns(parent);

// Make lines and make header visible
final Table table = viewer.getTable();
table.setHeaderVisible(true);
table.setLinesVisible(true); 

As with other JFace Viewers the ContentProvider provides the data which should be displayed in the TableViewer.

You can implement your own ContentProvider for a table by implementing the interface IStructuredContentProvider from the org.eclipse.jface.viewers package.

Eclipse provides an implementation of this interface via the ArrayContentProvider class. The ArrayContentProvider class supports Arrays or Lists as input, containing the domain data. Because ArrayContentProviders do not store any data, it is possible to share an instances with several Viewers. To get a shared instance use the ArrayContentProvider.getInstance() method.

The getElements() method of the ContentProvider is called by the JFace table Viewer to translate the input into an array of elements.

These elements are displayed as individual elements by the table Viewer, i.e. as individual rows.

The input to the ContentProvider is set via the setInput() method of the Viewer class.

// Continued after the definition of 
// the Viewer

// Set the ContentProvider
viewer.setContentProvider(ArrayContentProvider.getInstance());

// Get the content for the Viewer,
// setInput will call getElements in the ContentProvider
viewer.setInput(someData...); 

Columns for a JFace TableViewer are defined by creating instances of TableViewerColumn.

You define LabelProviders for a TableViewer per column.

Each TableViewerColumn needs to get a LabelProvider assigned via the setLabelProvider() method. The LabelProvider defines how the data from the model will be displayed. Typically you return the String which should be displayed.

The setLabelProvider() method expects an instance of the abstract CellLabelProvider class. A default implementation of this class is provided by the ColumnLabelProvider class.

// First column is for the first name
TableViewerColumn col = new TableViewerColumn(viewer, SWT.NONE);
col.getColumn().setWidth(200);
col.getColumn().setText("Firstname:");
col.setLabelProvider(new ColumnLabelProvider() {
  @Override
  public String getText(Object element) {
    Person p = (Person) element;
    return p.getFirstName();
  }
});

// Maybe more text columns...

// Now the status married
// Uses an getImage instead o getText
// CHECKED and UNCHECK are fields of type Image

col = new TableViewerColumn(viewer, SWT.NONE);
col.getColumn().setWidth(200);
col.getColumn().setText("Lastname:");
col.setLabelProvider(new ColumnLabelProvider() {
@Override
public Image getImage(Object element) {
  if (((Person) element).isMarried()) {
    return CHECKED;
  } 
  return UNCHECKED;
  }
}); 

The following code uses two fields which contain Image instances. These fields could for example be initialized via the following code. Using the classes in this code requires a dependency to the org.eclipse.core.runtime plug-in.

// Fields for your class
// Assuming your have these two icons
// in your icons folder
private static final Image CHECKED = getImage("checked.gif");
private static final Image UNCHECKED = getImage("unchecked.gif");



// More code...


// Helper Method to load the images
private static Image getImage(String file) {
  Bundle bundle = FrameworkUtil.getBundle(View.class);
  URL url = FileLocator.find(bundle, new Path("icons/" + file), null);
  ImageDescriptor image = ImageDescriptor.createFromURL(url);
  return image.createImage();

} 

To reflect data changes in the data model which is displayed by the Viewer, you can call the viewer.refresh() method. This method will update the Viewer based on the data which was assigned to it.

To change the data which is displayed use the viewer.setInput() method.

Via the addSelectionChangedListener method you can add a ISelectionChangedListener listener to a viewer. The following code shows an example.

viewer.addSelectionChangedListener(new ISelectionChangedListener() {
  @Override
  public void selectionChanged(SelectionChangedEvent event) {
    IStructuredSelection selection = (IStructuredSelection)
        viewer.getSelection();
    Object firstElement = selection.getFirstElement();
    // Do something with it
  }
}); 

We will build an Eclipse RCP application which displays data of persons in a JFace table. Each person is displayed in one individual row. This tutorial the basic setup of a JFace Table.

The final application will look like this.

Create a new RCP Project de.vogella.jface.tableviewer using the "RCP application with a view" as a template. Create a package "de.vogella.jface.tableviewer.model" and the following class "Person".

package de.vogella.jface.tableviewer.model;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;

public class Person {
  private String firstName;
  private String lastName;
  private boolean married;
  private String gender;
  private Integer age;
  private PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this);

  public Person() {
  }

  public Person(String firstName, String lastName, String gender,
      boolean married) {
    super();
    this.firstName = firstName;
    this.lastName = lastName;
    this.gender = gender;
    this.married = married;
  }

  public void addPropertyChangeListener(String propertyName,
      PropertyChangeListener listener) {
    propertyChangeSupport.addPropertyChangeListener(propertyName, listener);
  }

  public void removePropertyChangeListener(PropertyChangeListener listener) {
    propertyChangeSupport.removePropertyChangeListener(listener);
  }

  public String getFirstName() {
    return firstName;
  }

  public String getGender() {
    return gender;
  }

  public String getLastName() {
    return lastName;
  }

  public boolean isMarried() {
    return married;
  }

  public void setFirstName(String firstName) {
    propertyChangeSupport.firePropertyChange("firstName", this.firstName,
        this.firstName = firstName);
  }

  public void setGender(String gender) {
    propertyChangeSupport.firePropertyChange("gender", this.gender,
        this.gender = gender);
  }

  public void setLastName(String lastName) {
    propertyChangeSupport.firePropertyChange("lastName", this.lastName,
        this.lastName = lastName);
  }

  public void setMarried(boolean isMarried) {
    propertyChangeSupport.firePropertyChange("married", this.married,
        this.married = isMarried);
  }

  public Integer getAge() {
    return age;
  }

  public void setAge(Integer age) {
    propertyChangeSupport.firePropertyChange("age", this.age,
        this.age = age);
  }

  @Override
  public String toString() {
    return firstName + " " + lastName;
  }

} 

The class "Person" represents the data model for this example. It has also propertyChange support, which is not necessary for this example but is nice if you would later extend this example with Eclipse Databinding support.

Create the ModelProvider class which is a in-memory representation of your data. This class is defined as a Singleton.

package de.vogella.jface.tableviewer.model;

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

public enum ModelProvider {
  INSTANCE;

  private List<Person> persons;

  private ModelProvider() {
    persons = new ArrayList<Person>();
    // Image here some fancy database access to read the persons and to
    // put them into the model
    persons.add(new Person("Rainer", "Zufall", "male", true));
    persons.add(new Person("Reiner", "Babbel", "male", true));
    persons.add(new Person("Marie", "Dortmund", "female", false));
    persons.add(new Person("Holger", "Adams", "male", true));
    persons.add(new Person("Juliane", "Adams", "female", true));
  }

  public List<Person> getPersons() {
    return persons;
  }

} 

Change the class "View.java" to the following.

package de.vogella.jface.tableviewer;

import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TableViewerColumn;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.part.ViewPart;

import de.vogella.jface.tableviewer.model.ModelProvider;
import de.vogella.jface.tableviewer.model.Person;

public class View extends ViewPart {
  public static final String ID = "de.vogella.jface.tableviewer.view";

  private TableViewer viewer;
  // We use icons
  private static final Image CHECKED = Activator.getImageDescriptor("icons/checked.gif").createImage();
  private static final Image UNCHECKED = Activator.getImageDescriptor("icons/unchecked.gif").createImage();

  public void createPartControl(Composite parent) {
    GridLayout layout = new GridLayout(2, false);
    parent.setLayout(layout);
    Label searchLabel = new Label(parent, SWT.NONE);
    searchLabel.setText("Search: ");
    final Text searchText = new Text(parent, SWT.BORDER | SWT.SEARCH);
    searchText.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL
        | GridData.HORIZONTAL_ALIGN_FILL));
    createViewer(parent);
  }

  private void createViewer(Composite parent) {
    viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
        | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
    createColumns(parent, viewer);
    final Table table = viewer.getTable();
    table.setHeaderVisible(true);
    table.setLinesVisible(true);

    viewer.setContentProvider(new ArrayContentProvider());
    // Get the content for the viewer, setInput will call getElements in the
    // contentProvider
    viewer.setInput(ModelProvider.INSTANCE.getPersons());
    // Make the selection available to other views
    getSite().setSelectionProvider(viewer);
    // Set the sorter for the table

    // Layout the viewer
    GridData gridData = new GridData();
    gridData.verticalAlignment = GridData.FILL;
    gridData.horizontalSpan = 2;
    gridData.grabExcessHorizontalSpace = true;
    gridData.grabExcessVerticalSpace = true;
    gridData.horizontalAlignment = GridData.FILL;
    viewer.getControl().setLayoutData(gridData);
  }

  public TableViewer getViewer() {
    return viewer;
  }

  // This will create the columns for the table
  private void createColumns(final Composite parent, final TableViewer viewer) {
    String[] titles = { "First name", "Last name", "Gender", "Married" };
    int[] bounds = { 100, 100, 100, 100 };

    // First column is for the first name
    TableViewerColumn col = createTableViewerColumn(titles[0], bounds[0], 0);
    col.setLabelProvider(new ColumnLabelProvider() {
      @Override
      public String getText(Object element) {
        Person p = (Person) element;
        return p.getFirstName();
      }
    });

    // Second column is for the last name
    col = createTableViewerColumn(titles[1], bounds[1], 1);
    col.setLabelProvider(new ColumnLabelProvider() {
      @Override
      public String getText(Object element) {
        Person p = (Person) element;
        return p.getLastName();
      }
    });

    // Now the gender
    col = createTableViewerColumn(titles[2], bounds[2], 2);
    col.setLabelProvider(new ColumnLabelProvider() {
      @Override
      public String getText(Object element) {
        Person p = (Person) element;
        return p.getGender();
      }
    });

    // // Now the status married
    col = createTableViewerColumn(titles[3], bounds[3], 3);
    col.setLabelProvider(new ColumnLabelProvider() {
      @Override
      public String getText(Object element) {
        return null;
      }

      @Override
      public Image getImage(Object element) {
        if (((Person) element).isMarried()) {
          return CHECKED;
        } else {
          return UNCHECKED;
        }
      }
    });

  }

  private TableViewerColumn createTableViewerColumn(String title, int bound, final int colNumber) {
    final TableViewerColumn viewerColumn = new TableViewerColumn(viewer,
        SWT.NONE);
    final TableColumn column = viewerColumn.getColumn();
    column.setText(title);
    column.setWidth(bound);
    column.setResizable(true);
    column.setMoveable(true);
    return viewerColumn;
  }

  
/**
   * Passing the focus request to the viewer's control.
   */
  public void setFocus() {
    viewer.getControl().setFocus();
  }
} 

The method createColumns create the table columns, headers, sets the size of the columns and makes the columns re-sizable.

createTableViewerColumn() has three parameters. The third is currently not used, but we will use it in the advanced tutorial .

Run the example. The application should display a non-working search field and a table.

Source Code of Examples

Eclipse JFace

JFace Tree Tutorial

JFace Data Binding

http://www.eclipse.org/articles/Article-Table-viewer/table_viewer.html Building and delivering a table editor with SWT/JFace

vogella Training Android and Eclipse Training from the vogella team

Android Tutorial Introduction to Android Programming

GWT Tutorial Program in Java and compile to JavaScript and HTML

Eclipse RCP Tutorial Create native applications in Java

JUnit Tutorial Test your application

Git Tutorial Put everything you have under distributed version control system