RowEditor für JTable

[Guest]

Hallo,

hat jemand von Euch zufällig den Code für einer Art "RowEditor" für
JTable parat oder kennt eine Opensource Implementierung eines
solchen Editors?

So ungefähr stelle ich es mir vor:

(ist nur Grafik, so weit bin ich damit nicht )

Wenn der Anwender eine Spalte doppelt anklickt, dann soll die ganze
Zeile in den Editiermodus versetzt werden, nicht nur die angeklickte
Spalte. Die erste Komponente der angeklickten Spalte bekommt dabei
den Focus. Focuswechsel zwischen den einzelnen Komponenten des
Row-Editors wie überall sonst mit TAB bzw. Umschalt-TAB. Beenden des
Editiermodus mit Return oder ESC. Also alles wie bei einem CellEditor auch,
nur halt für die ganze Zeile.

Wie kann man sowas machen? Die JTable-Implementierung scheint mir
auf das Editieren einzelner Spalten ausgelegt zu sein.

Gruß,
Michael

 

[CelikBlek]

du kannst den CellRenderer und den CellEditor überschreiben und deinen Bedürfnisse anpassen. Die Methoden, die dazu benötigt werden musst du dann anpassen.

    private class MyTableRenderer implements TableCellRenderer
    {
        private JLabel label;
        public Component getTableCellRendererComponent(JTable table,Object value,boolean isSelected,
            boolean hasFocus,int row,int column) {
            ...
        // hier kommen deine speziellen Krams rein
            ...
        }
    }

schöne grüße

 

[Guest]

Danke, leider ist es nicht so einfach, wie es auf den ersten Blick scheint.
JTable setzt die Größe eines CellEditors auf die Größe der Spalte, bevor das
Ding angezeigt wird.
Den Göttern sei dank, haben es die Swing-Macher in zwei Public-Methoden
unterbracht, die auch (größtenteils) überschrieben werden können.
Ich habe gerade folgendes (nur so zum Test) versucht, um den CellEditor
auf die volle Zeilenbreite zu bringen.

JTable table = new JTable() 
{
  public Rectangle getRowRect(int row)
  {
    return getCellRect(row, 0, false).union(getCellRect(row, getColumnCount()-1, false));
  }
  
  public boolean editCellAt(int row, int column, EventObject e)
  {
    if (cellEditor != null && !cellEditor.stopCellEditing())
      return false;

    if (row < 0 || row >= getRowCount() || column < 0 || column >= getColumnCount())
      return false;

    if (!isCellEditable(row, column))
      return false;

    TableCellEditor editor = getCellEditor(row, column);
    if (editor != null && editor.isCellEditable(e))
    {
      editorComp = prepareEditor(editor, row, column);
      if (editorComp == null)
      {
        removeEditor();
        return false;
      }
      
      // Den CellEditor auf die volle Zeilenbreite bringen, und nicht nur die Breite der Zelle
      editorComp.setBounds(getRowRect(row));
      add(editorComp);
      editorComp.validate();

      setCellEditor(editor);
      setEditingRow(row);
      setEditingColumn(column);
      editor.addCellEditorListener(this);
      return true;
    }
    return false;
  }
  
  public void removeEditor()
  {
    TableCellEditor editor = getCellEditor();
    if(editor != null)
    {
      editor.removeCellEditorListener(this);
      if (editorComp != null)
        remove(editorComp);
      Rectangle rowRect = getRowRect(editingRow); 
      setCellEditor(null);
      setEditingColumn(-1);
      setEditingRow(-1);
      editorComp = null;
      // Die komplette Zeile neu pinseln
      repaint(rowRect);
    }
  }
};

Wenn man einen CellEditor schreibt, der alle "CellEditoren" der Zeile gleichzeitig "bedienen" kann,
dann könnte es hinhauen. Nur noch die Getter/Setter vom Editor und das Focus-Handling fehlen
komplett (das habe ich aus den obigen Methoden entfernt, da private in JTable :roll.
Hat wirklich noch niemand von Euch sowas gemacht?
Es würde mir viel Tiperei sparen und den Tag retten

Gruß,
Michael

 

[Guest]

OK, TableUI funkt dazwischen. :cry:

private void paintCell(Graphics g, Rectangle cellRect, int row, int column) {
  if (table.isEditing() && table.getEditingRow()==row && table.getEditingColumn()==column) {
    Component component = table.getEditorComponent();
    component.setBounds(cellRect); // Warum ändert die UI-Klasse die Breite der Spalten?
  ...

Durch die Bedingung "table.getEditingColumn()==column" ist es unmöglich mehrere Spalten
gleichzeitig im Editiermodus zu halten und getEditorComponent() holt nur "den" einen
CellEditor, der aktiv ist. Einzige Lösung, die ich momentan sehe, ist das Überschreiben von TableUI,
was für mich leider nicht in Frage kommt, da die Anwendung, wo es eingesetzt wird, verschiedene
PLAF's unterstützt.

Help! Hat bisher niemand sowas gemacht? :bahnhof:

 

[Guest]

Kommt schon. Keiner mit einer Idee, wie man es machen könnte? :?

 

[Beni]

Eine Idee: Anstelle des TableCellEditors fügst du die Editor-Component dem JTable selbst hinzu (table.add( eineComponent );), dann musst du nur dafür sorgen, dass diese Component a) an der richtigen Stelle ist, und b) nur dann sichtbar ist, wenn der Benutzer z.b. zweimal auf die Tabelle klickt.

 

[Guest]

Alle Spalten müssten in diesem Fall "nicht editierbar" sein,
stattdessen aber ein Editor für die ganze Zeile aktivierbar.
Sowas wie

editRowAt(int row, int column)

Wobei 'column' nur dazu da, um den Focus in den entsprechenden
CellEditor zu setzen. Meist ist die Stelle, die man anklickt auch die,
die man editieren möchte.
Ich sehe schon das rapaint() Problem kommen, wenn TableUI den
Editor mit den CellRenderern überzechnet. :wink:
Hmm..., ist aber einen Versuch wert. ???:L

Gruß,
Michael