How to display time duration (NOT dates) with an input mask in a JTable?

Question

Background: I am trying to display in a JTable, in two columns, the start position and time duration of an audio clip.
They are stored as type float internally eg. startPosition = 72.7 seconds.
However I wish to display on screen in the table in HH:mm:ss:S format. eg. 00:01:12:7. The user can edit the cell and input values to update the internal member fields.
Problem: I am finding it very difficult to implement this - what with the interactions of MaskFormatter, DefaultCellEditor etc.
Also using SimpleDateFormat and DateFormatter does not work as they insist on displaying the day, month, year also in the table cell.
Taking the Swing Tutorial TableFTFEditDemo example as a template,
(http://java.sun.com/docs/books/tutorial/uiswing/components/example-1dot4/index.html#TableFTFEditDemo)
does anyone know how to do this?
I can post my (buggy) modifications to the example code - if it would help.
Appreciate any help.
thanks,
Anil

Answer 1

Here are my modifications to the TableFTFEditDemo example. If you run it, you get an exception
like java.lang.NumberFormatException: For input string: "18:00:03.500"
The two modified classes are taken from the Tutorial and are listed below:
=================
* IntegerEditor is a 1.4 class used by TableFTFEditDemo.java.
import javax.swing.AbstractAction;
import javax.swing.BorderFactory;
import javax.swing.DefaultCellEditor;
import javax.swing.JFormattedTextField;
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.KeyStroke;
import javax.swing.SwingUtilities;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.awt.Color;
import java.awt.Component;
import java.awt.Toolkit;
import java.text.DateFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import javax.swing.text.DateFormatter;
import javax.swing.text.DefaultFormatterFactory;
import javax.swing.text.MaskFormatter;
import javax.swing.text.NumberFormatter;
class TimeRenderer {
     float seconds;
     TimeRenderer(String str) {
          int hSec = Integer.parseInt(str.substring(0,2)) * 60 * 60;
          int mSec = Integer.parseInt(str.substring(2,4)) * 60;
          int sSec = Integer.parseInt(str.substring(4,6));
          float tSec = Integer.parseInt(str.substring(6,7))/10.0F;
          seconds = hSec + mSec + sSec + tSec;
* Implements a cell editor that uses a formatted text field to edit Integer
* values.
public class IntegerEditor extends DefaultCellEditor {
     JFormattedTextField ftf;
     static Date zeroTime = new Date(0L);
     private boolean DEBUG = true;
     SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.S");
     MaskFormatter maskFo = new MaskFormatter("##:##:##.#");
     protected MaskFormatter createFormatter(String s) {
          MaskFormatter formatter = null;
          try {
               formatter = new MaskFormatter(s);
          } catch (java.text.ParseException exc) {
               System.err.println("formatter is bad: " + exc.getMessage());
               System.exit(-1);
          return formatter;
     public IntegerEditor(int min, int max) throws ParseException {
          super(new JFormattedTextField(new MaskFormatter("##:##:##.#")));
          ftf = (JFormattedTextField) getComponent();
          // Set up the editor for the cells.
          ftf.setFormatterFactory(new DefaultFormatterFactory(new DateFormatter(sdf)));
          ftf.setFocusLostBehavior(JFormattedTextField.PERSIST);
          // React when the user presses Enter while the editor is
          // active. (Tab is handled as specified by
          // JFormattedTextField's focusLostBehavior property.)
          ftf.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "check");
          ftf.getActionMap().put("check", new AbstractAction() {
               public void actionPerformed(ActionEvent e) {
                    if (!ftf.isEditValid()) { // The text is invalid.
                         ftf.setBorder(BorderFactory.createLineBorder(Color.RED));
                         ftf.setBackground(Color.PINK);
                         ftf.postActionEvent(); // inform the editor
                    } else
                         try { // The text is valid,
                              ftf.commitEdit(); // so use it.
                              ftf.postActionEvent(); // stop editing
                         } catch (java.text.ParseException exc) {
     // Override to invoke setValue on the formatted text field.
     public Component getTableCellEditorComponent(JTable table, Object value,
               boolean isSelected, int row, int column) {
          JFormattedTextField ftf = (JFormattedTextField) super
                    .getTableCellEditorComponent(table, value, isSelected, row, column);
          System.out.println("value:" + value);
//          long milliseconds =(long) (Float.parseFloat(value.toString()) * 1000);
          long milliseconds =(long) (((Float) value).floatValue() * 1000);
          Date dt = new Date(milliseconds);
          ftf.setValue(dt);
          return ftf;
     // Override to ensure that the value remains an Integer.
     public Object getCellEditorValue() {
          JFormattedTextField ftf = (JFormattedTextField) getComponent();
          Object o = ftf.getValue();
          try {               
               Calendar cal = Calendar.getInstance();
               cal.setTime((Date)o);
               float seconds = cal.getTimeInMillis()/1000.0F;
               return sdf.format(o);
               //return new Float(seconds);
          } catch (Exception exc) {
               System.err.println("getCellEditorValue: can't parse o: " + o);
               exc.printStackTrace();
               return null;
     // Override to check whether the edit is valid,
     // setting the value if it is and complaining if
     // it isn't. If it's OK for the editor to go
     // away, we need to invoke the superclass's version
     // of this method so that everything gets cleaned up.
     public boolean stopCellEditing() {
          JFormattedTextField ftf = (JFormattedTextField) getComponent();
          if (ftf.isEditValid()) {
               try {
                    ftf.commitEdit();
               } catch (java.text.ParseException exc) {
          } else { // text is invalid
               ftf.setBorder(BorderFactory.createLineBorder(Color.RED));
               ftf.setBackground(Color.PINK);
               return false; // don't let the editor go away
          return super.stopCellEditing();
//=====================================================
* TableFTFEditDemo.java is a 1.4 application that requires one other file:
*   IntegerEditor.java
import javax.swing.JFrame;
import javax.swing.JDialog;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.text.ParseException;
* This is exactly like TableDemo, except that it uses a
* custom cell editor to validate integer input.
public class TableFTFEditDemo extends JPanel {
    private boolean DEBUG = false;
    public TableFTFEditDemo() throws ParseException {
        super(new GridLayout(1,0));
        JTable table = new JTable(new MyTableModel());
        table.setPreferredScrollableViewportSize(new Dimension(500, 70));
        //Create the scroll pane and add the table to it.
        JScrollPane scrollPane = new JScrollPane(table);
        //Set up stricter input validation for the integer column.
     //   table.setDefaultEditor(Float.class,
       //                        new IntegerEditor(0, 100));
     //If we didn't want this editor to be used for other
     //Integer columns, we'd do this:
     table.getColumnModel().getColumn(3).setCellEditor(
          new IntegerEditor(0, 100));
        //Add the scroll pane to this panel.
        add(scrollPane);
    class MyTableModel extends AbstractTableModel {
        private String[] columnNames = {"First Name",
                                        "Last Name",
                                        "Sport",
                                        "# of Years",
                                        "Vegetarian"};
        private Object[][] data = {
            {"Mary", "Campione",
             "Snowboarding", new Float(5.7), new Boolean(false)},
            {"Alison", "Huml",
             "Rowing", new Float(3.5), new Boolean(true)},
            {"Kathy", "Walrath",
             "Knitting", new Float(2.9), new Boolean(false)},
            {"Sharon", "Zakhour",
             "Speed reading", new Float(20.8), new Boolean(true)},
            {"Philip", "Milne",
             "Pool", new Float(10.5), new Boolean(false)}
        public int getColumnCount() {
            return columnNames.length;
        public int getRowCount() {
            return data.length;
        public String getColumnName(int col) {
            return columnNames[col];
        public Object getValueAt(int row, int col) {
            return data[row][col];
         * JTable uses this method to determine the default renderer/
         * editor for each cell.  If we didn't implement this method,
         * then the last column would contain text ("true"/"false"),
         * rather than a check box.
        public Class getColumnClass(int c) {
             Object obj = getValueAt(0, c);
             System.out.println("getColumnClass.obj:" + obj);
            return obj.getClass();
        public boolean isCellEditable(int row, int col) {
            //Note that the data/cell address is constant,
            //no matter where the cell appears onscreen.
            if (col < 2) {
                return false;
            } else {
                return true;
        public void setValueAt(Object value, int row, int col) {
            if (DEBUG) {
                System.out.println("Setting value at " + row + "," + col
                                   + " to " + value
                                   + " (an instance of "
                                   + value.getClass() + ")");
            data[row][col] = value;
            fireTableCellUpdated(row, col);
            if (DEBUG) {
                System.out.println("New value of data:");
                printDebugData();
        private void printDebugData() {
            int numRows = getRowCount();
            int numCols = getColumnCount();
            for (int i=0; i < numRows; i++) {
                System.out.print("    row " + i + ":");
                for (int j=0; j < numCols; j++) {
                    System.out.print("  " + data[i][j]);
                System.out.println();
            System.out.println("--------------------------");
     * Create the GUI and show it.  For thread safety,
     * this method should be invoked from the
     * event-dispatching thread.
     * @throws ParseException
    private static void createAndShowGUI() throws ParseException {
        //Make sure we have nice window decorations.
        JFrame.setDefaultLookAndFeelDecorated(true);
        //Create and set up the window.
        JFrame frame = new JFrame("TableFTFEditDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //Create and set up the content pane.
        TableFTFEditDemo newContentPane = new TableFTFEditDemo();
        newContentPane.setOpaque(true); //content panes must be opaque
        frame.setContentPane(newContentPane);
        //Display the window.
        frame.pack();
        frame.setVisible(true);
    public static void main(String[] args) {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                try {
                         createAndShowGUI();
                    } catch (ParseException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
}