EdgeTableModel.java

/*
 *     YAV (Yet another Visualiser)
 *     (c) 2004 by Robin Quast
 *    Version 1.0 (04.03.2004)
 *    
 *  erstellt im Rahmen der Diplomarbeit
 * "Theorie und Java- Realisierung
 *  ausgewählter Algorithmen zur
 *  Bestimmung kürzester Wege in Graphen"
 *
 *  betreut durch Prof. Dr. Lenze
 *  an der Fachhochschule Dortmund
 *  im SS 2003/ WS 2003/2004
 *
 */

import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableModel;
import java.util.Vector;
import java.util.Collections;
import java.util.Enumeration;

/** Das EdgeTableModel verwaltet Kanten in Bezug zu einer Tabelle. Diese Kanten
 * werden in einem Vector data gespeichert. Visualisiert werden sie in der Klasse
 <I>EdgeTable</I>, die ein Kind der Klasse <I>JTable</I> ist. Unterklasse von
 * EdgeTableModel ist z.B. DijkstaEdgeTableModel, in der u.a. die Methode 'addRow()'
 * &uuml;beschrieben wird.
 */
class EdgeTableModel 
extends AbstractTableModel {

    /** Spalten&uuml;berschriften festlegen.
     */
        final String[] columnNames = {"Tail"
                                      "Head",
                                      "Cost" };
                                      
        /** Der Vector data h&auml;lt die Kanten (=Reihen) der Tabelle.
         */                                      
        Vector data = new Vector();

         /** Gibt die Anzahl der Spalten zur&uuml;ck.
     */
        public int getColumnCount() {
            return columnNames.length;
        }
        
    /** R&uuml;ckgabe ist die Anzahl der Zeilen.
     */        
        public int getRowCount() {
            return data.size();
        }

    /** R&uuml;ckgabe ist der Name der Spalte <i>col</I>
     */
        public String getColumnName(int col) {
            return columnNames[col];
        }

    /** Gibt das Object an der Stelle <i>(row,col)</I> zur&uuml;ck. 
     * Ist die Spalte 0, wird der Tail Knoten der Kante zur&uuml;ckgegeben.
     * Ist die Spalte 1, wird der Head Knoten der Kante zur&uuml;ckgegeben.
     * ist die Spalte 2, werden die Kosten zur&uuml;ckgegeben.
     */
        public Object getValueAt(int row, int col) {
          Edge edge=(Edgedata.elementAt(row);
          switch (col)
          {
            case 0return (Objectnew Integer(edge.getTailValue());
            case 1return (Objectnew Integer(edge.getHeadValue());
            case 2return (Objectnew Integer(edge.getCost());
            
          }
          return null;
        }

    /** F&uuml;ge eine Kante als Zeile in das Tabellenmodel ein.
     */
    public void addRow(Edge edge) {
         
       Enumeration kanten_enum = data.elements();
       boolean kante_gefunden=false;                 
       while ((kanten_enum.hasMoreElements()) && (kante_gefunden==false)) { 
         Edge tmp_element=(Edgekanten_enum.nextElement();
         if (edge.equal(tmp_element)) {
           kante_gefunden=true;
         }
       }        
      
      if (!(kante_gefunden)) {
        data.add(edge);
        Collections.sort(data);           
      }
      fireTableRowsInserted(0,data.size()-1;
    }
    
    /** Alle Datenzeilen l&ouml;schen. Alle Elemente des Vectors data werden
     * gel&ouml;scht und die Gr&ouml;ße des Vectors wird auf 0 gesetzt.
     */
    public void removeRows() {
      int index=data.size();
      data.removeAllElements();
      fireTableRowsDeleted(0,index);
    }
    
    /** L&ouml;schen einer Kante mit dem Index <i>index</i>.
     */    
        public void removeRow(int index) {
      Edge kante = (Edgedata.remove(index);
      fireTableRowsDeleted(index,index);
        }
  
    /** Methode zum ermitteln des Indizes einer Kante.
     */
    public int indexOf(Edge kante) {
      int zeilenanzahl=getRowCount();
      int i=0;
      boolean gefunden=false;
      while ((i<zeilenanzahl&& (gefunden==false))  {
        int tailint=((Integer)getValueAt(i, 0)).intValue();
        int headint=((Integer)getValueAt(i, 1)).intValue();
        
        if ((kante.getTailValue()==tailint&& (kante.getHeadValue()==headint)) {
          gefunden=true;
        else {
          i++;  
        }
      }
      if (gefunden==falsei=-1;
      return i;
    }
    
    /** Gibt f&uuml;r alle Spalten >= 2 true zur&uuml;ck, d.h. die Kosten sind
     * als einzige Spalte editierbar.
     */
        public boolean isCellEditable(int row, int col) {
            if (col < 2) { // tail und head sind nicht editierbar
                return false;
            else {
                return true;
            }
        }

    /** Setzen eines Wertes an der Stelle (row,col).
     */
        public void setValueAt (Object value, int row, int col) {
          Edge kante = (Edgedata.elementAt(row);
          if (col==2) {
            boolean ok = data.remove(kante);
        String s = value.toString();
        try {
          kante.setCostInteger.parseInt(s) );
        catch (Exception e) {
          YAV.status.setText("Sie d&uuml;rfen nur eine ganze Zahl vorgeben.");
        }
          
            data.add((Objectkante);
            Collections.sort(data);
              fireTableCellUpdated(0,data.size()-1);
            else {
              YAV.status.setText("Sie k&ouml;nnen nur die Kosten einer Kante &auml;ndern.");
            }
        }
        
        /** Tabelle mit dem Adjazenzlisteninhalt initialisieren.
         */
        public void initialiseTable(Adjazenzliste al) {
      data = new Vector();
          for (int i=0;i<=al.getMaxNodeNumber();i++) {
            Vector nlist=al.getEdgesWithTail(i);
            if (!(nlist==null)) {
              Enumeration kanten_enum = nlist.elements();
           while (kanten_enum.hasMoreElements()) { 
             Edge tmp_edge=(Edgekanten_enum.nextElement();
             addRow(tmp_edge);
           }
        }
          }
          fireTableRowsUpdated(0,data.size());
        }
            
}