Swing JTable: edit Cell -> versteckten Wert ändern

[chrissy]

Hallo,

iregendwie steh ich grad voll auf dem Schlauch ...
Ich habe eine JTable mit eigenem TableModel ... editieren an sich funktioniert auch. Jetzt möchte ich nur nach einem manuellem Update einer Zelle, einen Wert in einer versteckten Spalte ändern. Das sollte ja eigentlich über mymodel.setValueat("OK", row, column) ohne weiteres funktionieren. Aber wo muss ich die Methode aufrufen. Im Moment habe ich irgendwie den Überblick von Listenern und Events verloren.

Wär echt nett, wenn mir mal schnell jemand auf die Sprünge hilft ...

Danke,
chrissy

 

[ymene]

Ist etwas schwierig so pauschal zu beantworten, da es auch von der Datenstruktur die hinter dem TableModel liegt abhängig ist. Vermute mal du nutzt ein mehrdimensionales ObjektArray, die Daten haben sonst zueinander keinen Bezug und die Tabelle soll der einzige Ort sein, an dem du die Daten editieren kannst?

Dann wäre vermutlich ein TableModelListener das richtige für dich. Diesen addest du einfach an das Model und kannst so alle Änderungen verfolgen:

class CustomTableModel extends AbstractTableModel implements TableModelListener
{
  public CustomTableModel()
  {
    addTableModelListener( this );
  }

  //ggf. weitere Methoden.

  @Override
  public void tableChanged( TableModelEvent e )
  {
    if( e.getType() == TableModelEvent.UPDATE )
    {
      if ( getColumnName( e.getColumn() ).equals( "SpalteXY" ) )
      {//Wurde die Spalte XY editiert, dann setz das value von SpalteToEdit auf "Ok"
        setValueAt( "Ok", e.getFirstRow(), SpalteToEditIndex );
      }
    }
  }
}

Vielleicht nicht die eleganteste Lösung, aber zweckmäßig. Das Ganze ist Pseudocode und setzt natürlich vorraus, dass du die Spalten entsprechend mit Namen versehen hast und den Index der zu editierenden Spalte kennst. Diesen musst ggfs. dann natürlich ermitteln.

Grüße,
ymene

 

[KrokoDiehl]

Eigentlich könnte man es auch direkt im TableModel machen:

class MyTableModel implements TableModel
{
    ...

    @Override
    public void setValueAt( Object value, int row, int col )
    {
        // ...normaler set value at code
        if (col == meineBestimmteSpalte)
        {
            myTableData[row][meineVersteckteSpalte] = machWasMit(value);
            // vermutlich ist ein update-event vom Modell hier nicht nötig,
            // weil man die Spalte nicht sieht :)
        }
    }    
}

 

[chrissy]

Danke für die Hilfe, leider habe ich das so ähnlich implementiert ... sorry hab vergessen meinen Code anzuhängen

Tabelle:

    model = new MyTableModel((Vector) datas.elementAt(1), columnNames);
    model.addTableModelListener(new TableModelListener()
      {
        public void tableChanged(TableModelEvent e) 
        {
          model.setValueAt("CHANGED", e.getFirstRow(), 11);   
        }
      }
    );
    table = new JTable(model);

Model:

package models;

import java.io.Serializable;

import java.util.Vector;

import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.AbstractTableModel;

public class MyTableModel
  extends AbstractTableModel implements Serializable
{  
  protected Vector    dataVector;
  protected Vector    columnIdentifiers;

  public MyTableModel(Vector data, Vector columnNames)
  {
    setDataVector(data, columnNames);
  }
 
  public int getColumnCount() 
  {
      return columnIdentifiers.size();
  }

  public int getRowCount() 
  {
      return dataVector.size();
  }
  
  public String getColumnName(int column) 
  {
      Object id = null; 
      // This test is to cover the case when 
      // getColumnCount has been subclassed by mistake ... 
      if (column < columnIdentifiers.size()) 
      {  
          id = columnIdentifiers.elementAt(column); 
      }
      return (id == null) ? super.getColumnName(column) 
                          : id.toString();
  }

  public Object getValueAt(int row, int column) 
  {
      Vector rowVector = (Vector)dataVector.elementAt(row);
      return rowVector.elementAt(column);
  }

  public boolean isCellEditable(int row, int column) 
  {
      return true;
  }

  public void setValueAt(Object aValue, int row, int column) 
  {
      Vector rowVector = (Vector)dataVector.elementAt(row);
      rowVector.setElementAt(aValue, column);
      fireTableCellUpdated(row, column);
  }
  
  public Vector getDataVector() {
      return dataVector;
  }  
  
  public void setDataVector(Vector dataVector, Vector columnIdentifiers) 
  {
      this.dataVector = nonNullVector(dataVector);
      this.columnIdentifiers = nonNullVector(columnIdentifiers); 
      justifyRows(0, getRowCount()); 
      fireTableStructureChanged();
  }
  
  public void addRow(Vector rowData) {
      insertRow(getRowCount(), rowData);
  }
  
  public void insertRow(int row, Vector rowData) {
      dataVector.insertElementAt(rowData, row); 
      justifyRows(row, row+1); 
      fireTableRowsInserted(row, row);
  }
  

  public void updateRow(int row, Vector rowData )
  {
    dataVector.setElementAt(rowData, row); 
    fireTableRowsUpdated(row, row);
  }
    
  public Vector getRowData(int row)
  {
    return (Vector)dataVector.elementAt(row);
  }
  
  public void removeRow(int row) {
      dataVector.removeElementAt(row);
      fireTableRowsDeleted(row, row);
  }
  
  private static Vector nonNullVector(Vector v) 
  { 
      return (v != null) ? v : new Vector(); 
  }
  
  private void justifyRows(int from, int to) 
  { 
      dataVector.setSize(getRowCount()); 

      for (int i = from; i < to; i++) { 
          if (dataVector.elementAt(i) == null) { 
              dataVector.setElementAt(new Vector(), i); 
          }
          ((Vector)dataVector.elementAt(i)).setSize(getColumnCount());
      }
  }
  
  public Class getColumnClass(int columnIndex)
  {
    return Object.class;
  }
}

Da in meinem setValueAt ein fireTableCellUpdated(row, column) aufgerufen wird, ende ich immer in einer Endlosschleife. Allerdings benötige ich das Update, da Werte nicht nur manuell geändert werden könnnen, sondern auch durch Klick auf Buttons z.B. Datensätze neu generiert.
Noch ne Idee, was man da machen kann? Ich habe für die Table eine Eigenschaft "editingstopped" gefunden, kann man die irgendwie nutzen?

Danke

 

[KrokoDiehl]

Nun, du darfst nicht beides machen! Entweder den Wert der versteckten Spalte in einem TableModelListener setzen, oder in der

setValueAt()

. Natürlich kommt es sonst zu einer Endlosschleife, wenn beim setValue ein Update-Event ausgelöst wird und in der Event-Behandlung wieder ein setValue aufgerufen wird.

Das

editingStopped()

könnte auch funktionieren, ist jedoch vom Zusammenhang her nicht passend. So wie ich dein Modell verstehe, ist es eben eine Eigenschaft des Modells, dass bei gewissen Änderungen in einer weiteren Spalte Werte angepasst werden.

 

[chrissy]

hm, soweit war ich auch schon mal ... allerdings wird ja setValueAt ja immer aufgerufen, wenn Daten in die Tabelle geschrieben werden, also auch beim Füllen.
Kann man irgendwie abfragen, ob die Daten händisch, also über den CellEditor, geändert wurden?

Danke

 

[KrokoDiehl]

Dafür wäre das

editingStopped()

der Tabelle eine Anlaufstelle, oder ein CellEditorListener, den müsste man aber direkt an den CellEditor hängen.

 

[ymene]

Wenn ich das auf den ersten Blick so richtig deute, landest du in der Endlosschleife, da du in der tableChanged(TableModelEvent e) - Methode deines TableListeners nicht abfragst, welche Spalte sich geändert hat. Daher wird bei jeder Änderung wieder die setValueAt(...) - Methode dort aufgerufen wodurch wiederum ein TableChangedEvent ausgelöst wird und so weiter.

Nun ist die Frage: Beim Füllen der Daten ins Model möchtest du nicht, dass dieses automatische setzen des Feldes passiert? Wenn der Wert ohnehin vom Inhalt des Feldes abhängig ist, dann dürfte das keine Rolle spielen, oder wie genau soll es ablaufen?

 

[chrissy]

@ymene

Ich frage das Feld nicht ab, da es egal ist welches Feld in der Tabelle geändert wird und nicht vom Inhalt des Feldes abhängig st, immer soll der Wert in der versteckten Spalte geändert werden. Beim Füllen möchte ich das nicht tun, da ich den Wert nur ändern möchte, wenn er händisch geändert wurde.
Ich wered jetzt versuchen, wie von KrokoDiehl vorgeschlagen und von mir befürchtet, über den CellEditoListener und editingstopped() der Tabelle zu gehen.

Danke

 

[Michael...]

Ich frage das Feld nicht ab, da es egal ist welches Feld in der Tabelle geändert wird und nicht vom Inhalt des Feldes abhängig st, immer soll der Wert in der versteckten Spalte geändert werden.

Ist eben nicht egal. Es soll ja nichts geändert werden, wenn in der versteckten Spalte (Spalte 11) etwas geändert wird.

 

[ymene]

Ich frage das Feld nicht ab, da es egal ist welches Feld in der Tabelle geändert wird und nicht vom Inhalt des Feldes abhängig st, immer soll der Wert in der versteckten Spalte geändert werden.

Dennoch bräuchtest du eine Abbruchbedingung in deiner tableChanged() - Methode , um die Schleife zu verhindern. Und zwar müsste die dann lauten:

Rufe nur setValue(..) auf, wenn ich nicht die versteckte Spalte bin.

Aber das verhindert natürlich nicht dass beim Füllen der Tabelle die Events gefeuert werden. Über die CellEditorListener sollte es auf jeden Fall klappen.

EDIT: Oh, hätte kein Kaffee holen dürfen beim Schreiben dieses Posts. Da warst du schon deutlich schneller mit der Antwort

 

[chrissy]

so ... *HandgegenKopfklatsch* ... sorry für meine Dummheit.

Habe setValueAt geändert:

  public void setValueAt(Object aValue, int row, int column) 
  {
      Vector rowVector = (Vector)dataVector.elementAt(row);
      System.out.println("Change");
      rowVector.setElementAt(aValue, column);
      rowVector.setElementAt("CHANGED", 11);
      if ( column != 11 ) fireTableCellUpdated(row, column);
  }

so nun funktioniert das auch, ohne CellEditorListener ...

Aber ... ( im Moment zeig ich die Spalte ja noch an ) warum wird der Wert, wenn ich im Debug-Modus bin und einen Haltepunkt auf die erste Zeile in der Methode setze und die Zelle mit Tab verlasse sofort geändert angezeigt (nach dem weitersteppen) und wenn ich normal laufen lasse, erst wenn ich in eine andere Spalte klicke?

Danke für eure Geduld, aber nach einem Jahr Java-Pause, ist die Gehirnregion fürs Java-Programmieren fast vollstädnig abgestorben.

 

[ymene]

So kann man es natürlich auch lösen. Das setzt aber natürlich vorraus, dass du den TableModelListener wieder entfernt hast, sonst machst du das doppelt. Eine Kleinigkeit noch: Solltest du im moment die Spalte 11 editieren (was ja aktuell möglich ist), dann wird das Feld auch immer wieder auf "changed" gesetzt und der ursprüngliche Inhalt den man setzen wollte überschrieben. Um es ganz sauber zu haben müsstest

[JAVA=6]
rowVector.setElementAt("CHANGED", 11);
[/code]

in den If Block setzen und

[JAVA=7]
fireTableCellUpdated(row, column);
[/code]

außerhalb des If-Blocks definieren, da dies bei jeder Änderung des TableModels einmal gefeuert werden sollte. Da du es nicht mehr via setValueAt setzt wird es auch nur einmal gefeuert, trotz beider Änderungen. Auch wenn die Column später ausgeblendet werden sollte, so ist das Verhalten so konsistenter.

Das mit dem Debug Modus kann ich so leider nicht so einfach nachvollziehen. Kann ich dir leider nicht sagen.