package forum;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import javax.swing.BoxLayout;
import javax.swing.DefaultCellEditor;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFormattedTextField;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.JToolBar;
import javax.swing.SwingUtilities;
import javax.swing.border.TitledBorder;
import javax.swing.table.AbstractTableModel;
import javax.swing.text.DefaultFormatterFactory;
import javax.swing.text.NumberFormatter;
public class FehlerAnalyse {
public static void main(String[] args) {
Editor.main( args );
}
}
class MyTableModel extends AbstractTableModel {
static final long serialVersionUID = 123456780;
/*******************************************/
private List names = new ArrayList(); // Liste mit Strings
private List values = new ArrayList(); // Liste mit Floats
private boolean cellUpdated;
protected int nextEmptyRow = 0;
protected int numRows = 0;
public MyTableModel() {
}
public int getColumnCount() {
return 2;
}
public int getRowCount() {
return names.size();
}
public String getColumnName(int col) {
switch (col) {
case 0:
return "Fehlerart";
case 1:
return "Fehlerwahrscheinlichkeit";
}
return "non valid column index";
}
public Object getValueAt(int row, int col) {
if( col == 0 )
return names.get( row );
else
return values.get( row );
}
public Class getColumnClass(int c) {
/*****************************************************/
switch( c ){
case 0: return String.class;
case 1: return Float.class;
default: return null;
}
}
public void addValue( String name, float probability ){
names.add( name );
values.add( Float.valueOf( probability ));
// bzw. "new Float( probability )" falls du eine ältere Java Version benützt.
int row = getRowCount()-1;
fireTableRowsInserted( row, row );
}
public void setValueAt(Object value, int row, int col) {
if( col == 0 )
names.set( row, value );
else
values.set( row, value );
/*
if (col == 0) {
if (notInDataVector((String) value)) {
String[] tempStringArray = new String[2];
tempStringArray[0] = value.toString();
tempStringArray[1] = "";
data.addElement(tempStringArray);
this.fireTableDataChanged();
}
}
if (col == 1) {
String[] tempRowData = (String[]) data.elementAt(row);
tempRowData[1] = (String) value;
data.setElementAt(tempRowData, row);
this.fireTableDataChanged();
}*/
}
public boolean isCellEditable(int row, int col) {
if (col == 0) {
return false;
} else {
return true;
}
}
public void clearELement(int index) {
names.remove( index );
values.remove( index );
this.fireTableDataChanged();
}
public void clearAll() {
names.clear();
values.clear();
fireTableDataChanged();
}
public void setCellUpdated(boolean value) {
cellUpdated = value;
}
public boolean getCellUpdated() {
return cellUpdated;
}
/*private boolean notInDataVector(Object value) {
for (int i = 0; i < data.size(); i++) {
Object[] tempArr = (Object[]) data.elementAt(i);
if (tempArr[0].equals(value))
return false;
}
return true;
}*/
}
class MyCellEditor extends DefaultCellEditor implements KeyListener {
JFormattedTextField ftf;
NumberFormat numberFormat;
private Float minimum, maximum;
private boolean DEBUG = false;
public MyCellEditor(float min, float max) {
super(new JFormattedTextField());
ftf = (JFormattedTextField) getComponent();
minimum = new Float(min);
maximum = new Float(max);
/*************************************************************/
// Set up the editor for the integer cells.
numberFormat = NumberFormat.getNumberInstance();
NumberFormatter intFormatter = new NumberFormatter(numberFormat);
intFormatter.setFormat(numberFormat);
intFormatter.setMinimum(minimum);
intFormatter.setMaximum(maximum);
ftf.setFormatterFactory(new DefaultFormatterFactory(intFormatter));
ftf.setValue(minimum);
ftf.setHorizontalAlignment(JTextField.TRAILING);
ftf.setFocusLostBehavior(JFormattedTextField.PERSIST);
ftf.addKeyListener(this);
}
// 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);
ftf.setValue(value);
return ftf;
}
// Override to ensure that the value remains an Integer.
public Object getCellEditorValue() {
JFormattedTextField ftf = (JFormattedTextField) getComponent();
Object o = ftf.getValue();
if (o instanceof Float) {
return o;
} else if (o instanceof Number) {
return new Float(((Number) o).floatValue());
} else {
if (DEBUG) {
System.out.println("getCellEditorValue: o isn't a Number");
}
try {
return numberFormat.parseObject(o.toString());
} catch (ParseException exc) {
System.err.println("getCellEditorValue: can't parse o: " + o);
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
if (!userSaysRevert()) { // user wants to edit
return false; // don't let the editor go away
}
}
return super.stopCellEditing();
}
/**
* Lets the user know that the text they entered is bad. Returns true if the
* user elects to revert to the last good value. Otherwise, returns false,
* indicating that the user wants to continue editing.
*/
protected boolean userSaysRevert() {
Toolkit.getDefaultToolkit().beep();
ftf.selectAll();
Object[] options = { "Edit", "Revert" };
int answer = JOptionPane.showOptionDialog(SwingUtilities
.getWindowAncestor(ftf), "Der Wert soll zwischen " + minimum
+ " und " + maximum, "Falscher Wert",
JOptionPane.YES_NO_OPTION, JOptionPane.ERROR_MESSAGE, null,
options, options[1]);
if (answer == 1) { // Revert!
ftf.setValue(ftf.getValue());
return true;
}
return false;
}
public void keyPressed(KeyEvent e) {
int id = e.getID();
if (id == KeyEvent.VK_ENTER)
if (!ftf.isEditValid()) { // The text is invalid.
if (userSaysRevert()) { // reverted
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) {
}
}
public void keyReleased(KeyEvent arg0) {
// TODO Auto-generated method stub
}
public void keyTyped(KeyEvent arg0) {
// TODO Auto-generated method stub
}
}
class Ecu extends JPanel implements ActionListener {
private int nextEmptyRow;
JTextField ecuFehlertf = new JTextField();
JButton ecuAddFehler;
JButton ecuDeleteRow;
JButton ecuDeleteFehler;
JComboBox fehlercb = new JComboBox();
JPanel ecuFehlerPanel = new JPanel();
JTextField ecutf = new JTextField();
JButton ecuAddEcu;
JButton ecuDeleteEcu;
JButton save;
JComboBox ecucb = new JComboBox();
JPanel ecuEcuPanel = new JPanel();
JPanel panel = new JPanel();
JPanel hauptPanel = new JPanel();
JTable ecutable;
TitledBorder titledBorder1;
TitledBorder titledBorder2;
private MyTableModel tablemodel;
public Ecu() {
init();
}
public void init() {
tablemodel = new MyTableModel();
ecutable = new JTable(tablemodel);
JToolBar tb1 = new JToolBar();
tb1.setRollover(true);
tb1.setBorderPainted(false);
JToolBar tb2 = new JToolBar();
tb2.setRollover(true);
tb2.setBorderPainted(false);
// ecutable.getColumnModel().getColumn(1).setCellEditor(new
// MyCellEditor(0, 1));
/**************************************************************/
ecutable.setDefaultEditor(Float.class, new MyCellEditor(0, 1));
titledBorder1 = new TitledBorder("Ecu_Item");
titledBorder2 = new TitledBorder("Ecu_Fehler");
ecuAddFehler = new JButton("Add");
ecuDeleteFehler = new JButton("Delete");
ecuDeleteRow = new JButton();
Image imgDelete = getToolkit().getImage("./img/Delete.gif");
ImageIcon deleteIcon = new ImageIcon(imgDelete);
ecuDeleteRow.setIcon(deleteIcon);
tb2.add(ecuDeleteRow);
ecuDeleteRow.setPreferredSize(new Dimension(30, 30));
ecuAddFehler.setActionCommand("Add Fehler");
ecuDeleteFehler.setActionCommand("Delete Fehler");
ecuDeleteRow.addActionListener(this);
ecuDeleteRow.setActionCommand("delete");
ecuAddFehler.addActionListener(this);
ecuDeleteFehler.addActionListener(this);
save = new JButton();
save.setActionCommand("save");
save.addActionListener(this);
Image imgSave = getToolkit().getImage("./img/Save.gif");
ImageIcon saveIcon = new ImageIcon(imgSave);
save.setIcon(saveIcon);
tb1.add(save);
save.setPreferredSize(new Dimension(30, 30));
ecuAddEcu = new JButton("Add");
ecuDeleteEcu = new JButton("Delete");
ecuAddEcu.setActionCommand("Add Ecu");
ecuDeleteEcu.setActionCommand("Delete Ecu");
ecuAddEcu.addActionListener(this);
ecuDeleteEcu.addActionListener(this);
hauptPanel.setLayout(new BoxLayout(hauptPanel, BoxLayout.Y_AXIS));
ecuFehlertf.setPreferredSize(new Dimension(280, 20));
fehlercb.setPreferredSize(new Dimension(280, 20));
fehlercb.addItem("--Alle Fehler--");
fehlercb.addItem("Kurzschluss");
fehlercb.addItem("Stromausfall");
fehlercb.addItem("Taktfehler");
fehlercb.addItem("Reset");
fehlercb.addActionListener(this);
fehlercb.setActionCommand("fehlercb");
// fehlercb.addItemListener(this);
ecucb.setActionCommand("ecucb");
ecucb.addActionListener(this);
ecucb.setPreferredSize(new Dimension(280, 20));
ecutf.setPreferredSize(new Dimension(280, 20));
ecucb.addItem("--Alle ECUs--");
ecuEcuPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
ecuEcuPanel.add(ecuAddEcu);
ecuEcuPanel.add(ecuDeleteEcu);
ecuEcuPanel.add(ecutf);
ecuEcuPanel.setBorder(titledBorder1);
// ecuEcuPanel.se
ecuEcuPanel.add(ecucb);
ecuFehlerPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
ecuFehlerPanel.add(ecuAddFehler);
ecuFehlerPanel.add(ecuDeleteFehler);
ecuFehlerPanel.add(ecuFehlertf);
ecuFehlerPanel.setBorder(titledBorder2);
ecuFehlerPanel.add(fehlercb);
panel.setLayout(new BorderLayout());
panel.setLayout(new BoxLayout(panel, BoxLayout.X_AXIS));
panel.add(tb2);
this.add(new JScrollPane(ecutable));
this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
hauptPanel.add(tb1);
hauptPanel.add(ecuEcuPanel);
hauptPanel.add(ecuFehlerPanel);
hauptPanel.add(panel);
hauptPanel.add(this);
} /*
* (non-Javadoc)
*
* @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
*/
public void actionPerformed(ActionEvent e) {
String fehlerName = ecuFehlertf.getText();
String ecuName = ecutf.getText();
if (e.getActionCommand().equalsIgnoreCase("Add Fehler")) {
if (!fehlerName.equals("") && !fehlerName.equals(null)) {
boolean exist = false;
for (int i = 0; i < fehlercb.getItemCount(); i++) {
String item = fehlercb.getItemAt(i).toString();
if (item.equalsIgnoreCase(fehlerName))
exist = true;
}
if (!exist) {
fehlercb.addItem(fehlerName);
ecuFehlertf.removeAll();
}
ecuFehlertf.setText("");
}
}
else if (e.getActionCommand().equalsIgnoreCase("Add Ecu")) {
if (!ecuName.equals("") && !ecuName.equals(null)) {
boolean exist = false;
for (int i = 0; i < ecucb.getItemCount(); i++) {
String item = ecucb.getItemAt(i).toString();
if (item.equalsIgnoreCase(ecuName))
exist = true;
}
if (!exist) {
ecucb.addItem(ecuName);
ecutf.removeAll();
}
ecutf.setText("");
}
} else if (e.getActionCommand().equalsIgnoreCase("save")) {
String selectedItem = ecucb.getSelectedItem().toString();
if (selectedItem == null
|| selectedItem.equalsIgnoreCase("--Alle Ecus--")) {
JOptionPane.showMessageDialog(new JFrame(),
"Bitte wählen Sie eine ECU");
} else {
// TO DO
JOptionPane.showMessageDialog(new JFrame(),
"Die Schnittstelle wir noch implementiert...");
}
} else if (e.getActionCommand().equalsIgnoreCase("delete")) {
int selectedRowIndex = ecutable.getSelectedRow();
if (selectedRowIndex >= 0) {
String value = tablemodel.getValueAt(selectedRowIndex, 0)
.toString();
int YES_NO = JOptionPane.showConfirmDialog(new JFrame(),
"Möchten Sie " + "\"" + value + "\""
+ " wircklich löschen?", "Delete Dialog",
JOptionPane.YES_NO_OPTION);
if (YES_NO == 0) {
tablemodel.clearELement(selectedRowIndex);
}
} else {
JOptionPane.showMessageDialog(new JFrame(),
"Bitte selektieren Sie ein Element");
}
}
else if (e.getActionCommand().equalsIgnoreCase("Delete Fehler")) {
String selectedItem = fehlercb.getSelectedItem().toString();
if (selectedItem != null
&& !selectedItem.equalsIgnoreCase("--Alle Fehler--")) {
fehlercb.removeItem(selectedItem);
fehlercb.setSelectedItem("--Alle Fehler--");
ecuFehlertf.removeAll();
// tablemodel.clearELement(selectedItem);
}
} else if (e.getActionCommand().equalsIgnoreCase("Delete Ecu")) {
String selectedItem = ecucb.getSelectedItem().toString();
if (selectedItem != null
&& !selectedItem.equalsIgnoreCase("--Alle Ecus--")) {
ecucb.removeItem(selectedItem);
ecucb.setSelectedItem("--Alle ECUs--");
ecutf.removeAll();
}
} else if (e.getActionCommand().equalsIgnoreCase("ecucb")) {
String selected = ecucb.getSelectedItem().toString();
if (!selected.equalsIgnoreCase("--Alle Ecus--")) {
tablemodel.clearAll();
tablemodel.fireTableDataChanged();
}
} else if (e.getActionCommand().equalsIgnoreCase("fehlercb")) {
String selectedInfehlercb = fehlercb.getSelectedItem().toString();
String selectedInecucb = ecucb.getSelectedItem().toString();
if (selectedInfehlercb != null && selectedInecucb != null
&& !selectedInfehlercb.equalsIgnoreCase("--Alle Fehler--")
&& !selectedInecucb.equalsIgnoreCase("--Alle Ecus--")) {
nextEmptyRow = tablemodel.getRowCount();
/****************************************/
tablemodel.addValue( selectedInfehlercb, 0f );
//tablemodel.setValueAt(selectedInfehlercb, nextEmptyRow++, 0);
}
}
}
public JPanel getHauptPanel() {
return hauptPanel;
}
}
class Editor extends JFrame {
private Ecu ecu;
JButton save;
public Editor() {
methode();
}
public void methode() {
ecu = new Ecu();
JTabbedPane tp = new JTabbedPane();
tp.add("ECU", ecu.getHauptPanel());
this.getContentPane().setLayout(new BorderLayout());
this.getContentPane().add(tp);
}
public static void main(String[] args) {
Editor editor = new Editor();
editor.setTitle("FehlermodellierungsEditor");
editor.setSize(1000, 500);
editor.setVisible(true);
}
}