2 Tabs Parallel Editieren

[pr0pag4nda]

Hallo zusammen,
ich habe folgendes Problem:

Ich schreibe an einem Editor, mit dem ich eine Datei auf 2 unterschiedliche Weisen anzeigen lassen und Editieren kann.
Dazu verwende ich ein JFrame mit 2 Tabs - jeder Tab hat ein eigenes DefaultTableModel zugewiesen.
Im ersten Tab soll die Datei in Ihrem Uhrsprungsformat angezeigt werden und im zweiten Tab soll sie Sortiert angezeigt werden.
Soweit so gut, aber mein problem ist nun, dass wenn ich einen Eintrag in einem Tab ändere, er sich gleichzeitig auch im anderen Tab ändern soll, denn sonst macht das ganze nicht viel Sinn...

Gibt es eine Möglichkeit, Änderungen in einem TableModel festzustellen UND diese in ein Anderes TableModel zu Übernehmen, das zwar die selbe Datei enthält, allerdings vollkommen anders aufgebaut ist?


Ich hoffe mein Problem ist Verständlich und jemand kann helfen...

MfG pr0pag4nda

 

[genodeftest]

Natürlich, TableModelListener und evtl. CellEditorListener sollten das tun, was du brauchst. Den Rest vom Code musst du dir selber schreiben.
Wenn du in beiden Tabellen die gleiche Datei offen hast, müssten die Daten im TableModel auch identisch sein (die werden meines Wissens nicht verändert, wenn du z.B. nach einer Spalte sortierst).

 

[pr0pag4nda]

Danke für die Antwort, aber das hilft mir auch nicht viel weiter...
Den TableModelListener verwende ich bereits um festzustellen, ob sich etwas in einer Tabelle geändert hat (für eine "Möchten sie Speichern" - Abfrage beim beenden), jedoch sagt mir CellEditorListener nichts.
Ich habe es bereits geschafft, dass reihen in der Tabelle parallel hinzugefügt und gelöscht werden,
jedoch beziehe ich mich hierbei auf die Value einer Zelle, die in beiden Tabellen eindeutig ist.
Hier der Code:

ActionListener odeleteRow = new ActionListener()
		{
			public void actionPerformed(ActionEvent arg0)
			{
				if (bCmdinstModus)
				{
					if (tabbedPane.getSelectedIndex() == 1)
					{
						for (int i = 0; i < oTable.getRowCount(); i++)
						{
							if (oTable.getValueAt(i, 0).equals(oTableSorted.getValueAt(oTableSorted.getSelectedRow(), 0)))
							{
								DefaultTableModel oTableModel = (DefaultTableModel)oTable.getModel();
								oTableModel.removeRow(i);
								DefaultTableModel oTableModelSorted = (DefaultTableModel)oTableSorted.getModel();
								oTableModelSorted.removeRow(oTableSorted.getSelectedRow());
								return;
							}
						}
					}
					else
					{
						for (int i = 0; i < oTableSorted.getRowCount(); i++)
						{
							if (oTableSorted.getValueAt(i, 0).equals(oTable.getValueAt(oTable.getSelectedRow(), 0)))
							{
								DefaultTableModel oTableModel = (DefaultTableModel)oTable.getModel();
								oTableModel.removeRow(oTable.getSelectedRow());
								DefaultTableModel oTableModelSorted = (DefaultTableModel)oTableSorted.getModel();
								oTableModelSorted.removeRow(i);
								return;
							}
						}
					}
				}

 

[mki_germo]

Hi pr0pag4nda,

Sowas realisiert man mit einem gemeinsamen Datenmodel, auf das die Tabellen zugreifen.
Ich hab dir mal was ganz einfaches vorbereitet. In meinem Demo habe ich zwei Tabellen, die sich ihre Daten aus einer eigenen Modelklasse holen. Sobald ich einen Wert zum Model hinzufüge, werden beide Tabellen aktualisiert:

1. Tabdemo.java

package de.tutorials.tabdemo;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;

public class TabdemoView extends JFrame implements ActionListener {
	
	private JTable tabUnsorted = null;
	private JTable tabSorted = null;
	private JPanel pnlAdd = null;
	private JTextField tfName = null;
	private JTextField tfValue = null;
	private JButton btnAdd = null;
	private static final Dimension FRAMESIZE = new Dimension(800, 600);
	private TabdemoModel model = TabdemoModel.getModel();
	
	public TabdemoView() {
		super();
		init();
	}
	
	private void init() {
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setTitle("Tabdemo");
		this.setLayout(new BorderLayout());
		this.setSize(TabdemoView.FRAMESIZE);
		this.tabUnsorted = new JTable(UnsortedTableModel.getInstance());
		JScrollPane spUnsorted = new JScrollPane();
		spUnsorted.setViewportView(tabUnsorted);
		this.add(spUnsorted, BorderLayout.WEST);
		
		this.tabSorted = new JTable(SortedTableModel.getInstance());
		JScrollPane spSorted = new JScrollPane();
		spSorted.setViewportView(tabSorted);
		this.add(spSorted, BorderLayout.CENTER);
		this.add(getAddPanel(), BorderLayout.SOUTH);
		this.pack();
		this.setVisible(true);
	}
	
	private JPanel getAddPanel() {
		if (this.pnlAdd == null) {
			this.pnlAdd = new JPanel();
			tfName = new JTextField("neuer Name");
			tfValue = new JTextField("neuer Wert");
			btnAdd = new JButton("Wert hinzufügen");
			btnAdd.setActionCommand("add");
			btnAdd.addActionListener(this);
			
			this.pnlAdd.setLayout(new FlowLayout());
			JLabel lblName = new JLabel("Name:");
			JLabel lblValue = new JLabel("Wert:");
			this.pnlAdd.add(lblName);
			this.pnlAdd.add(this.tfName);
			this.pnlAdd.add(lblValue);
			this.pnlAdd.add(this.tfValue);
			this.pnlAdd.add(this.btnAdd);
		}
		return this.pnlAdd;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new TabdemoView();

	}

	@Override
	public void actionPerformed(ActionEvent e) {
		if (e.getActionCommand().equals("add")) {
			model.addDataToModel(tfName.getText(), tfValue.getText());
			tabSorted.updateUI();
			tabUnsorted.updateUI();
		}
		
	}

}

2. TabdemoModel.java

package de.tutorials.tabdemo;

import java.util.Vector;

public class TabdemoModel {

	private static TabdemoModel instance = new TabdemoModel();
	private Vector<Pair> data = null;
	
	private TabdemoModel() {
		data = new Vector<Pair>();
		data.add(new Pair("aaa", "bbb"));
		data.add(new Pair("xyz", "123"));
		data.add(new Pair("name1", "Wert1"));
		data.add(new Pair("foo", "bar"));
	}
	
	public static TabdemoModel getModel() {
		return TabdemoModel.instance;
	}

	/**
	 * @return the data
	 */
	public Vector<Pair> getData() {
		return data;
	}
	
	public void addDataToModel(String name, String value) {
		Pair pair = new Pair(name, value);
		data.add(pair);
	}
	
	
}

3. Pair.java

package de.tutorials.tabdemo;

public class Pair implements Comparable<Pair> {
	private String name = "";
	private String value = "";
	
	/**
	 * @param name
	 * @param value
	 */
	public Pair(String name, String value) {
		this.name = name;
		this.value = value;
	}

	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}

	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}

	/**
	 * @return the value
	 */
	public String getValue() {
		return value;
	}

	/**
	 * @param value the value to set
	 */
	public void setValue(String value) {
		this.value = value;
	}

	@Override
	public int compareTo(Pair other) {
		return this.getName().compareTo(other.getName());
	}
	

}

4. SortedTableModel.java

package de.tutorials.tabdemo;

import java.util.Collections;
import java.util.Vector;

import javax.swing.table.AbstractTableModel;

public class SortedTableModel extends AbstractTableModel {
	private static SortedTableModel instance = new SortedTableModel();
	private TabdemoModel model = TabdemoModel.getModel(); 
	private static final String[] COLNAMES = {"Name", "Wert"};

	
	private SortedTableModel() {
		
	}
	
	public static SortedTableModel getInstance() {
		return SortedTableModel.instance;
	}
	
	@Override
	public int getColumnCount() {
		return SortedTableModel.COLNAMES.length;
	}

	@Override
	public int getRowCount() {
		return model.getData().size();
	}

	@Override
	public Object getValueAt(int row, int col) {
		Vector<Pair> data = (Vector<Pair>) model.getData().clone();
		Collections.sort(data);
		if (col == 0) {
			return data.get(row).getName();
		} else if ( col == 1) {
			return data.get(row).getValue();
		}
		return "";
	}

	/* (non-Javadoc)
	 * @see javax.swing.table.AbstractTableModel#getColumnName(int)
	 */
	@Override
	public String getColumnName(int col) {
		return SortedTableModel.COLNAMES[col];
	}
}

5. UnsortedTableModel.java

package de.tutorials.tabdemo;

import javax.swing.table.AbstractTableModel;

public class UnsortedTableModel extends AbstractTableModel {
	
	private static UnsortedTableModel instance = new UnsortedTableModel();
	private TabdemoModel model = TabdemoModel.getModel(); 
	private static final String[] COLNAMES = {"Name", "Wert"};

	private UnsortedTableModel() {
		
	}
	
	public static UnsortedTableModel getInstance() {
		return UnsortedTableModel.instance;
	}
	
	@Override
	public int getColumnCount() {
		return UnsortedTableModel.COLNAMES.length;
	}

	@Override
	public int getRowCount() {
		return model.getData().size();
	}

	@Override
	public Object getValueAt(int row, int col) {
		
		if (col == 0) {
			return model.getData().get(row).getName();
		} else if ( col == 1) {
			return model.getData().get(row).getValue();
		}
		return "";
	}

	/* (non-Javadoc)
	 * @see javax.swing.table.AbstractTableModel#getColumnName(int)
	 */
	@Override
	public String getColumnName(int col) {
		return UnsortedTableModel.COLNAMES[col];
	}
		
	
}

Die beiden TableModels, über die ich die Darstellung realisiere, lesen jeweils ihre Daten aus dem TabdemoModel. Wenn ich also das TabdemoModel ändere, ändert sich jeweils auch der Datenbestand für die darunterliegenden TabelModels.
Über die UpdateUI Methoden der Tabellen aktualisiert sich die Darstellung.

Ich hoffe, das dir das Beispiel das Prinzip verdeutlicht.

Gruß,
Manuel