HeapTableModel.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
 *
 *  @(#)HeapTableModel.java  1.0 04/03/09
 */

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

/** Klasse die in Verbindung mit der HeapTable Klasse einen Heap in einer JTable
 * darstellt/anzeigt.
 */
class HeapTableModel 
extends AbstractTableModel {

    /** Spaltenüberschriften festlegen.
     */
        final String[] columnNames = {"Knoten"
                                      "Wert"
                                       };
                                      
        /** Der Vector data hält die Knoten mit den Vorgängern der Tabelle.
         * Diese werden als Kante in dem Vector gehalten, wobei die Kosten 
         * nicht angezeigt werden und auch für die Anzeige nicht wichtig sind.
         */                                      
        Heap data = new Heap();
        
         /** Gibt die Anzahl der Spalten zurück.
     */
        public int getColumnCount() {
            return columnNames.length;
        }
        
    /** Gibt die Anzahl der Zeilen zurück.
     */        
        public int getRowCount() {
            return data.size();
        }

    /** Gibt den Spaltennamen f&uuml;r Spalte <i>col</I> zur&uuml;ck.
     */
        public String getColumnName(int col) {
            return columnNames[col];
        }

    /** Gibt den Wert in Zeile <i>row</I> und Spalte <i>col</I> zur&uuml;ck.
     */
        public Object getValueAt(int row, int col) {
          HeapElement he=(HeapElementdata.elementAt(row);
          switch (col)
          {
            case 0return (Objectnew Integer(he.getNodeValue());
            case 1
              if (!(he.getKey()==Integer.MAX_VALUE)) return (Objectnew Integer(he.getKey());
              else return (Objectnew String("~");
            
            
          }
          return null;
        }

    /** F&uuml;gt ein Heap Element als Zeile in das Tabellenmodel ein.
     */
    public void addRow(HeapElement he) {
      if (!data.contains(he)) {
        data.add(he);
      }
      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 elements = data.size();
      data.removeAllElements();
      fireTableRowsDeleted(0,elements);
    }
    
    /** Eine Zeile mit dem Index <I>index</I> l&ouml;schen.
     */
        public void removeRow(int index) {
      HeapElement he = (HeapElementdata.remove(index);
      fireTableRowsDeleted(index,index);
        }

    /** Keine Zelle ist editierbar.
     */
        public boolean isCellEditable(int row, int col) {
            return false;
        }

    /** Alle Elemente aus dem Heap einf&uuml;gen.
     */
    public void addRows(Heap h) {
       Enumeration heap_enum = h.elements();
      while (heap_enum.hasMoreElements() ) { 
         HeapElement tmp_element=(HeapElementheap_enum.nextElement();
        data.add(tmp_element);
      }
      fireTableRowsInserted(0,data.size()-1);
    }

    /** Alle Zeilen l&ouml;schen und die Zeilen aus dem Heap einf&uuml;gen.
     */
    public void setRows(Heap h) {
      removeRows();
      addRows(h);
    }
      
}