sortedtablemodel.java

ULCeclipse的插件集成的swing的框架

package com.canoo.ulc.onlineshop.model;

import com.ulcjava.base.application.event.TableModelEvent;
import com.ulcjava.base.application.table.ITableModel;
import com.canoo.ulc.onlineshop.model.DecoratedTableModel;

import java.io.Serializable;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * This class provides the data of the decorated table model in a sorted way.
 *
 * @author [e-mail]
 */
public class SortedTableModel extends DecoratedTableModel
{
  private TableModelRowComparator fComparator;
  private int[] fSortedColumns;
  private boolean fAscending;


  public SortedTableModel(ITableModel sourceModel)
  {
    this(sourceModel, new Comparator[0]);
  }


  public SortedTableModel(ITableModel sourceModel, Comparator[] comparators)
  {
    super(sourceModel);
    fComparator = new TableModelRowComparator(comparators);
    fSortedColumns = new int[0];
    fAscending = true;
    dataChanged();
  }


  private void dataChanged()
  {
    updateIndicesIfNeeded();
    Collections.sort(getIndices(), fComparator);
    fireTableDataChanged();
  }


  private void structureChanged()
  {
    updateIndicesIfNeeded();
    Collections.sort(getIndices(), fComparator);
    fireTableStructureChanged();
  }


  private List updateIndicesIfNeeded()
  {
    List indices = getIndices();
    if(indices.size() != getModel().getRowCount())
    {
      indices.clear();
      for(int row = 0; row < getModel().getRowCount(); row++)
      {
        indices.add(new Integer(row));
      }
    }
    return indices;
  }


  public void sort(int[] sortedColumns, boolean ascending)
  {
    if(!Arrays.equals(fSortedColumns, sortedColumns) || fAscending != ascending)
    {
      fSortedColumns = sortedColumns;
      fAscending = ascending;
      dataChanged();
    }
  }


  public void sort(int[] sortedColumns)
  {
    if(!Arrays.equals(fSortedColumns, sortedColumns))
    {
      fSortedColumns = sortedColumns;
      dataChanged();
    }
  }


  public void sort(boolean ascending)
  {
    if(fAscending != ascending)
    {
      fAscending = ascending;
      dataChanged();
    }
  }


  public int[] getSortedColumns()
  {
    return fSortedColumns;
  }


  public boolean isAscending()
  {
    return fAscending;
  }


  public void tableChanged(TableModelEvent event)
  {
    switch(event.getType())
    {
      case TableModelEvent.UPDATE:
        handleRowsUpdated(event);
        break;
      case TableModelEvent.INSERT:
        handleRowsInserted(event);
        break;
      case TableModelEvent.DELETE:
        handleRowsDeleted(event);
        break;
      default:
        throw new IllegalArgumentException("Unknown event type: " + event.getType());
    }
  }


  private void handleRowsUpdated(TableModelEvent event)
  {
    if(event.getFirstRow() == TableModelEvent.HEADER_ROW)
    {
      structureChanged();
      return;
    }

    if((event.getFirstRow() == 0) && (event.getLastRow() == Integer.MAX_VALUE))
    {
      dataChanged();
      return;
    }

    int firstRow = event.getFirstRow();
    if(firstRow == event.getLastRow())
    {
      int sortedRow = getMappedRow(firstRow);
      getIndices().remove(sortedRow);
      int newSortedRow = getSortedInsertionRow(firstRow);
      if(sortedRow == newSortedRow)
      {
        getIndices().add(sortedRow, new Integer(firstRow));
        fireTableRowsUpdated(sortedRow, sortedRow);
      }
      else
      {
        fireTableRowsDeleted(sortedRow, sortedRow);
        getIndices().add(newSortedRow, new Integer(firstRow));
        fireTableRowsInserted(newSortedRow, newSortedRow);
      }
      return;
    }

    dataChanged();
  }


  private void handleRowsInserted(TableModelEvent event)
  {
    int firstRow = event.getFirstRow();
    if(firstRow == event.getLastRow())
    {
      moveIndices(firstRow, 1);
      int sortedRow = getSortedInsertionRow(firstRow);
      getIndices().add(sortedRow, new Integer(firstRow));
      fireTableRowsInserted(sortedRow, sortedRow);
      return;
    }

    dataChanged();
  }


  private void handleRowsDeleted(TableModelEvent event)
  {
    int firstRow = event.getFirstRow();
    if(firstRow == event.getLastRow())
    {
      int sortedRow = getMappedRow(firstRow);
      moveIndices(firstRow, -1);
      getIndices().remove(sortedRow);
      fireTableRowsDeleted(sortedRow, sortedRow);
      return;
    }

    dataChanged();
  }


  private int getSortedInsertionRow(int realRow)
  {
    int sortedRow = Collections.binarySearch(getIndices(), new Integer(realRow), fComparator);
    return sortedRow >= 0 ? sortedRow : -sortedRow - 1;
  }


  private class TableModelRowComparator implements Comparator, Serializable
  {
    private Comparator[] fComparators;


    public TableModelRowComparator(Comparator[] comparators)
    {
      fComparators = comparators;
    }


    public int compare(Object rowIndex1, Object rowIndex2)
    {
      return compare(((Integer) rowIndex1).intValue(), ((Integer) rowIndex2).intValue());
    }


    private int compare(int rowIndex1, int rowIndex2)
    {
      for(int i = 0; i < fSortedColumns.length; i++)
      {
        int result = compareRowsByColumn(rowIndex1, rowIndex2, fSortedColumns[i], getComparator(i));
        if(result != 0)
        {
          return result;
        }
      }
      return 0;
    }


    private int compareRowsByColumn(int rowIndex1, int rowIndex2, int column, Comparator comparator)
    {
      Object o1 = getModel().getValueAt(rowIndex1, column);
      Object o2 = getModel().getValueAt(rowIndex2, column);
      return fAscending ? comparator.compare(o1, o2) : comparator.compare(o2, o1);
    }


    private Comparator getComparator(int i)
    {
      return i < fComparators.length ? fComparators[i] : DefaultComparator.INSTANCE;
    }
  }

  private static class DefaultComparator implements Comparator
  {
    private static final Comparator INSTANCE = new DefaultComparator();


    private DefaultComparator()
    {
    }


    public int compare(Object first, Object second)
    {
      Comparable firstComparable = (Comparable) first;
      return (firstComparable).compareTo(second);
    }
  }
}