JButtons mit JTable verknüpfen

[PollerJava]

Hallo nochmal,

Ich habe mehrere JButtons und ich möchte jeden JButton mit einer JList verbinden,
Hätte da jemand einen Tipp, wie ich das am Besten realisieren kann? Mit einem Observer- Pattern oder soll ich den JButton und die JList direkt koppeln?

Vielen Dank für Eure Ideen,

lg

 

[mimo]

Das kommt auf die Fragestellung an, aber Observer ist laut Definition eine 1 zu n Verknüpfung. Also warum meherer Interfaces und sonstiges um ein Object zu steuern???

 

[PollerJava]

Naja, das Problem ist auch, wenn ich in der JListe z.B. die Größe des JButtons ändere, dann soll das der JButton auf dem JPanel tun (wenn ich in der JListe ENTER gedrückt habe),
Umgekehrt sollen sich z.B.: die x/y- Koordinaten in der JList ändern, wenn ich den JButton auf meinem JPanel umherziehe (das umherziehenfunktioniert schon, es geht nur um die Attribute des JButtons)

Ich bin mir eben nicht sicher, wie ich das machen kann, soll ich den JButton gemeinsam mit der dazugehörigen JList in einem Objekt speichern oder soll ich diese lose koppeln oder gibts vielleicht ein Design Pattern, mit dem ich dieses Problem lösen könnte,

Hat jemand noch eine Idee,

 

[PollerJava]

Muss mich nochmal nach oben schieben,

Gibts kein erprobtes Muster um einzelnen JButtons (z.B.: 10 JButtons) -> jeden JButton mit einer JTable zu verbinden,
und wenn ich in der JTable etwas verändere (z.B.: die Breite) dann sollte sich die Breite des JButtons ändern,

lg

 

[tuxedo]

Man man man.. Wozu gibts denn das Listener-Prinzip?

Du lässt jeden Button ein Listener-Interface implementieren. In deiner Tabelle bzw. dem CellEditor machst du dann eine "addXyzListener()" Methode rein mit der du die Buttons mit der Tabelle verknüpfst. Bei änderungen in der Tabelle (da gibts auch wieder modified oder changelistener) meldest du die änderungen an die registrierten Listsner der Buttons. Fertig.

BTW: ob's jetzt ne Tabelle oder ne Liste ist, ist wurscht.

- Alex

 

[PollerJava]

Hört sich ganz gut an,
ganz hab ichs noch nicht,

Mein Interface schaut dann so irgendwie aus:

interface MyXYZListener {
void modified();
void changelistener();
}

meine JButton- Klasse schaut dann so aus:

public class MyButton extends JButton implements MyXYZListener {
// Methoden des XYZListener
}

Bei meiner Tabelle mache ich dann folgendes?:

myTable.addMyXYZListener();
...
// wenn sich was tut:
myTable.modified() oder myTable.changelistener();

lieg ich da richtig oder hab ich da was falsch verstanden, mir ist die unterscheidung nicht ganz klar -> wenn Tabelle 2 geändert wurde sollte ja z.B.: nut Button 2 die Änderung mitbekommen,

Vielen Dank für deine Antworten (und Geduld),

lg

 

[tuxedo]

Aaaalso. Ist doch ganz einfach.


Du hast eine JTable. Zusammen mit dieser hat du einen TableCellEditor. Dieser kennt eine addCellEditorListener() Methode der du einen CellEditorListener mitgibst.

Dieser Listener wird dann getriggert wenn sich was an der Tabelle änder (z.B. eine Benutzereingabe gemacht wurde).

So. Das ist der erste Streich.

Deine Tabelle/TableCellEditor braucht dann eine weitere Methode wie z.B. addMyButtonListener (). Diese Methode nimmt dann ein Objekt entgegen das das Interface "MyButtonListener " implementiert hat.

Dieses Interface sieht dann z.B. so aus:

interface MyButtonListener {
void changeSize(int width, int height);
void changeText(String text);
void changeLocation(int x, int y);
}

So, dann hast du deine Buttons:

public class MyButton extends JButton implements MyButtonListener {
// implementiert Methoden des MyButtonListeners
}

So... Der CellEditorListener hat laut API Doc folgende Methode:

void editingStopped(ChangeEvent e)

Darin kannst du also abfangen wenn es Änderungen gab. In dieser Methode, die du ja selbst implementieren musst, kannst du dann durch alle in deiner Tabelle/TableCellEditor mit addMyButtonListener() registrierten MyButtonListener gehen und die Änderungen die in der Tabelle gemacht wurden (z.B. die größe des Buttons geändert) entsprechend über die Methoden in MyButtonListener dem Button mitteilen.

Mehr ist es nicht.

 

[PollerJava]

VIIIELEN Dank!!,

lg

 

[tuxedo]

Vielleicht ist der CellEditorListener nicht der beste für diesen Anwendungszweck, aber es ist ein erster Anhaltspunkt.

 

[PollerJava]

Hallo Alex nochmal,

ich komm nicht ganz hin,
Mein Programm schaut mom so aus, Könntest Du vielleicht kurz drüberschaun, irgendwie wird keine Methode aufgerufen, wenn ich etwas in der Tabelle ändere,

Dankeschön,

//**************** Main *************************/
package listenerprojekt;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellEditor;

public class Main {
    String[][] data = new String[][]{
            {"a", "b", "c", "d"},
            {"e", "f", "g", "h"},
            {"i", "j", "k", "l"}
      };            
      String[] title = new String[]{
            "A", "B", "C", "D"
      };
    private JScrollPane pane;
  
    public Main() {
        MyButton but = new MyButton("TestButton");
        but.setBackground(Color.RED);
        but.setBounds(10, 10, 200, 50);
        JFrame frame = new JFrame("Listener- Beispiel");
        frame.setBounds(10,10, 300, 700);
        frame.setLayout(new BorderLayout());
                                                                           // hier irgendwo vermute ich meinen Fehler:
        JTable table = new JTable(data,title);                           // tabelle anlegen
        MyTableCellEditor tce = new MyTableCellEditor();         // TableCellEditor anlegen 
        tce.addCellEditorListener(new MyCellEditorListener());  // listener zu TableCellEditor hinzufügen
        tce.addMyButtonListener(but);
        table.setCellEditor(tce);
        pane = new JScrollPane(table);
        frame.add(pane, BorderLayout.NORTH);
        frame.add(but, BorderLayout.SOUTH);
        frame.setVisible(true);
    }
       
    public static void main(String[] args) {
       new Main();
    }    
}

//**************** MyTableCellEditor  *************************/
package listenerprojekt;

import java.awt.Component;
import java.util.EventObject;
import javax.swing.AbstractCellEditor;
import javax.swing.JTable;
import javax.swing.event.CellEditorListener;
import javax.swing.table.TableCellEditor;

public class MyTableCellEditor extends AbstractCellEditor implements TableCellEditor {
    MyButtonListener but;
       
    public MyTableCellEditor() {
    }
    public Object getCellEditorValue() {
        return "Methode getCellEditorValue";
    }
    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
        return table;
    }    
    public void addMyButtonListener(MyButtonListener mbl) {
        this.but = mbl;
    }
}

//**************** MyCellEditorListener *************************/

package listenerprojekt;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;

public class MyCellEditorListener implements CellEditorListener {
    
    public MyCellEditorListener() {
        super();
    }
    public void editingStopped(ChangeEvent e) {
        System.out.println("Es hat sich was getan in der Methode editingStopped");
    }
    public void editingCanceled(ChangeEvent e) {
        System.out.println("Es hat sich was getan in der Methode editingCanceled");
    } 
}

//**************** MyButtonListener *************************/ 
package listenerprojekt;

public interface MyButtonListener {
    void changeSize(int width, int height);
    void changeText(String text);
    void changeLocation(int x, int y);
}


//**************** MyButton *************************/ 
package listenerprojekt;
import javax.swing.JButton;

public class MyButton extends JButton implements MyButtonListener {

    public MyButton(String name) {
        super("My" + name);
    }
    public void changeSize(int width, int height) {
        System.out.println("Die Größe muss geändert werden");
    }
    public void changeText(String text) {
        this.setText("Irgendwas");
    }
    public void changeLocation(int x, int y) {
        System.out.println("Die Location muss geändert werden");
    }   
}

 

[tuxedo]

Hmm, gute Frage. Hab lang nix mehr mit Tabellen gemacht und da auch noch keinen Listener verwendet. google doch einfach mal nach listener und tablecelleditor ..

- Alex

 

[PollerJava]

aber grundsätzlich müsste es ja so passen, oder, nur die Methoden
public void editingStopped(ChangeEvent e)
public void editingCanceled(ChangeEvent e)
werden nicht aufgerufen, aber vom Aufbau her glaub ich, passts,

lg

 

[tuxedo]

Jupp, Grundsätzlich müssts stimmen. Aber irgendwo is noch der Wurm drin.

- Alex

 

[tuxedo]

Probier's mal mit dem hier:

http://java.sun.com/javase/6/docs/api/javax/swing/event/TableModelListener.html

Da bekommst du auch gleich zurück welche Zelle sich in der Tabelle geändert hat.

- Alex

 

[PollerJava]

Hallo,

Das mit dem TableModelListener funktioniert schon, wennn ich den Listenener zum den Model hinzufüge ,dann wird die Methode unten aufgerufen, aber wie kann ich jes jetzt realidieren, dass mein JButton sich ändert wenn ich in der JTabel etwas eingabe?

Vielen dank für Deine/Eure Hilfe,

lg

table.getModel().addTableModelListener(new MyTableModelListener());

public class MyTableModelListener implements TableModelListener {
    
    public MyTableModelListener() {
        super();
    } 

    public void tableChanged(TableModelEvent e) {
        System.out.println("Es hat sich was getan in der Tabelle: " + e.getSource());
    }
}

 

[tuxedo]

Man, Bub, daz braucht man nichtmal Hirnschmalz.

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

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


public class MyTableModelListener implements TableModelListener{

	private List<ButtonListener> buttonListeners = new ArrayList<ButtonListener>();

	public void tableChanged(TableModelEvent e) {
		
		// jeden registrierten ButtonListener ansprechen
		for (ButtonListener buttonListener : buttonListeners) {
			
			int column = e.getColumn();
			int firstRow = e.getFirstRow();
			
			// Irgendwie aus der Tabelle mit column und firstRow 
			// die notwenidgen Daten gewinnen un din x und y speichern
			// Das ist dein Part, den musst du dir ausdenken. Weiß ja nicht
			// wie die Tabelle aussieht. Soll hier ja auch nur ein Beispiel sein.
			int x = 0;
			int y = 0;
			
			
			buttonListener.sizeChanged(x, y);
		}
	}

	public void addButtonListener(ButtonListener buttonListener){
		buttonListeners.add(buttonListener);
	}

}

Das ganze muss nicht im MyTableModelListener stattfinden. Du kannst das auch weiter oben in der Hierarchie (in der Tabelle selbst) platzieren.

- Alex

 

[PollerJava]

Dankeschön!!!
lg