Java Code Examples for javax.swing.event.TableModelEvent#DELETE

/**
 * The underlying model has changed.
 */
public void tableChanged(TableModelEvent e) {
 if ((e.getType() == TableModelEvent.INSERT) ||
		 (e.getType() == TableModelEvent.DELETE)) {
	 loadCategories();
	 fireDatasetChanged();
 }
 else if (e.getColumn() == TableModelEvent.ALL_COLUMNS) fireDatasetChanged();
 else {
	 boolean dataChanged = false;
	 for (int column : columns) {
		 if (column == e.getColumn()) dataChanged = true;
	 }
	 if (dataChanged) {
		 long time = System.nanoTime() / 1000000L;
		 if ((time - lastUpdateTime) > MIN_TIME_BETWEEN_UPDATES) {
			 lastUpdateTime = time;
			 fireDatasetChanged();
		 }
	 }
 }
}
 

@Override
public void tableChanged(final TableModelEvent e) {
	//XXX - Workaround for Java 7
	if (getTable().isEditing()) {
		getTable().getCellEditor().cancelCellEditing();
	}
	if (e.getType() == TableModelEvent.DELETE) {
		rowsCount = rowsCount - (Math.abs(e.getFirstRow() - e.getLastRow()) + 1);
	}
	if (e.getType() == TableModelEvent.INSERT) {
		rowsCount = rowsCount + (Math.abs(e.getFirstRow() - e.getLastRow()) + 1);
	}
	if (Math.abs(rowsLastTime + rowsCount) == getRowCount() //Last Table Update
			&& (e.getType() != TableModelEvent.UPDATE
			|| (e.getType() == TableModelEvent.UPDATE && e.getFirstRow() >= 0))) {
		rowsLastTime = getRowCount();
		rowsCount = 0;
		autoResizeColumns();
	}
}
 

public void tableChanged(TableModelEvent e) {
    switch (e.getType()) {
        case TableModelEvent.DELETE: {

            fireAllChanged();
            break;
        }
        case TableModelEvent.INSERT: {

            fireAllChanged();
            break;
        }
        case TableModelEvent.UPDATE: {

            fireAllChanged();
            break;
        }
    }
}
 

private void onTableChange(@Nonnull TableModelEvent e) {
  final int signum;
  switch (e.getType()) {
    case TableModelEvent.INSERT:
      signum = 1;
      break;
    case TableModelEvent.DELETE:
      signum = -1;
      for (int i = e.getLastRow(); i >= e.getFirstRow(); i--) {
        myComponents.remove(i);
      }
      break;
    default:
      return;
  }
  int shift = Math.abs(e.getFirstRow() - e.getLastRow() + 1) * signum;
  myComponents.shiftKeys(e.getFirstRow(), shift);
  if (myRowUnderMouse >= e.getFirstRow()) {
    myRowUnderMouse = -1;
  }
  if (getModel().getSize() > 0) {
    repaintRows(0, getModel().getSize() - 1, false);
  }
}
 

@Override public void tableChanged(TableModelEvent e) {
  int vci = table.convertColumnIndexToView(targetColumnIndex);
  TableColumn column = table.getColumnModel().getColumn(vci);
  Object status = column.getHeaderValue();
  TableModel m = table.getModel();
  boolean repaint = false;
  if (e.getType() == TableModelEvent.DELETE) {
    // System.out.println("DELETE");
    // System.out.println(status + ":   " + Status.INDETERMINATE.equals(status));
    repaint = fireDeleteEvent(m, column, status);
  } else if (e.getType() == TableModelEvent.INSERT && status != Status.INDETERMINATE) {
    // System.out.println("INSERT");
    repaint = fireInsertEvent(m, column, status, e);
  } else if (e.getType() == TableModelEvent.UPDATE && e.getColumn() == targetColumnIndex) {
    // System.out.println("UPDATE");
    repaint = fireUpdateEvent(m, column, status);
  }
  if (repaint) {
    JTableHeader h = table.getTableHeader();
    h.repaint(h.getHeaderRect(vci));
  }
}
 

/**
 * Clear the message list
 */
public void clear() {
    
    if (messages.size() == 0) return;        
    int lastRow = messages.size() - 1;

    messages.clear();

    TableModelEvent e = new TableModelEvent(this, 0, lastRow, TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE);
    for (int i = 0, n = listeners.size(); i < n; i++) {
        listeners.get(i).tableChanged(e);
    }
}
 

void deleteRow(int rowIndex) {
    rows.remove(rowIndex);
    TableModelEvent event = new TableModelEvent(this, rowIndex, rowIndex, TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE);
    for (TableModelListener listener: listeners) {
        listener.tableChanged(event);
    }
}
 

public void removeLayer(int row) {
    Layer layer = layers.remove(row);
    settings.remove(layer);
    TableModelEvent event = new TableModelEvent(this, row, row, TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE);
    for (TableModelListener listener: listeners) {
        listener.tableChanged(event);
    }
}
 

public void deleteRow(int row) {
    System.arraycopy(levels, row + 1, levels, row, rows - 1 - row);
    System.arraycopy(terrains, row + 1, terrains, row, rows - 1 - row);
    rows--;
    TableModelEvent event = new TableModelEvent(this, row, row, TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE);
    for (TableModelListener listener: listeners) {
        listener.tableChanged(event);
    }
    notifyChangeListener();
}
 

protected void onTableChanged(@Nonnull TableModelEvent e) {
  if (!myRowHeightIsExplicitlySet) {
    myRowHeight = -1;
  }
  if (e.getType() == TableModelEvent.DELETE && isEmpty() || e.getType() == TableModelEvent.INSERT && !isEmpty()) {
    repaintViewport();
  }
}
 

/**
 * This fine grain notification tells listeners the exact range of cells, rows, or columns that changed.
 */
public void tableChanged( final TableModelEvent e ) {
  if ( e.getType() == TableModelEvent.UPDATE && e.getFirstRow() == TableModelEvent.HEADER_ROW ) {
    updateStructure();
  } else if ( e.getType() == TableModelEvent.INSERT || e.getType() == TableModelEvent.DELETE ) {
    updateRowCount();
  } else {
    updateData();
  }
}
 

/**
 * Clear the message list
 */
public void clear() {
    
    if (messages.size() == 0) return;
    int lastRow = messages.size() - 1;

    messages.clear();

    TableModelEvent e = new TableModelEvent(this, 0, lastRow, TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE);
    for (int i = 0, n = listeners.size(); i < n; i++) {
        listeners.get(i).tableChanged(e);
    }
}
 

public void tableChanged(TableModelEvent e) {
	if (e.getType() == TableModelEvent.DELETE || e.getType() == TableModelEvent.INSERT) {
		invalidate();
	}
	else {
		redraw();
	}
}
 

private static String tableModelEventToString (TableModelEvent e) {
    StringBuilder sb = new StringBuilder();
    sb.append ("TableModelEvent ");
    switch (e.getType()) {
        case TableModelEvent.INSERT : sb.append ("insert ");
             break;
        case TableModelEvent.DELETE : sb.append ("delete ");
             break;
        case TableModelEvent.UPDATE : sb.append ("update ");
             break;
        default : sb.append("Unknown type ").append(e.getType());
    }
    sb.append ("from ");
    switch (e.getFirstRow()) {
        case TableModelEvent.HEADER_ROW : sb.append ("header row ");
            break;
        default : sb.append (e.getFirstRow());
                  sb.append (' ');
    }
    sb.append ("to ");
    sb.append (e.getLastRow());
    sb.append (" column ");
    switch (e.getColumn()) {
        case TableModelEvent.ALL_COLUMNS :
            sb.append ("ALL_COLUMNS");
            break;
        default : sb.append (e.getColumn());
    }
    return sb.toString();
}
 

/** Translates tree expansion event into an appropriate TableModelEvent
 * indicating the number of rows added/removed at the appropriate index */
private TableModelEvent translateEvent (TreeExpansionEvent e, boolean expand) {
    //PENDING:  This code should be profiled - the descendent paths search
    //is not cheap, and it might be less expensive (at least if the table
    //does not have expensive painting logic) to simply fire a generic
    //"something changed" table model event and be done with it.
    
    TreePath path = e.getPath();
    
    //Add one because it is a child of the row.
    int firstRow = getLayout().getRowForPath(path) + 1;
    if (firstRow == -1) {
        //This does not mean nothing happened, it may just be that we are
        //a large model tree, and the FixedHeightLayoutCache says the
        //change happened in a row that is not showing.
        
        //TODO:  Just to make the table scrollbar adjust itself appropriately,
        //we may want to look up the number of children in the model and
        //fire an event that says that that many rows were added.  Waiting
        //to see if anybody actually will use this (i.e. fires changes in
        //offscreen nodes as a normal part of usage
        return null;
    }
    
    //Get all the expanded descendants of the path that was expanded/collapsed
    TreePath[] paths = getTreePathSupport().getExpandedDescendants(path);
    
    //Start with the number of children of whatever was expanded/collapsed
    int count = getTreeModel().getChildCount(path.getLastPathComponent());
    
    if (count == 0) {
        return null;
    }
    
    //Iterate any of the expanded children, adding in their child counts
    for (int i=0; i < paths.length; i++) {
        count += getTreeModel().getChildCount(paths[i].getLastPathComponent());
    }
    
    //Now we can calculate the last row affected for real
    int lastRow = firstRow + count -1;
    
    //Construct a table model event reflecting this data
    TableModelEvent result = new TableModelEvent (getModel(), firstRow, lastRow, 
        TableModelEvent.ALL_COLUMNS, expand ? TableModelEvent.INSERT : 
        TableModelEvent.DELETE);
        
    return result;
}
 

public void deleteRow(int row) {
    layers.remove(row);
    filters.remove(row);
    TableModelEvent event = new TableModelEvent(this, row, row, TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE);
    listeners.forEach(listener -> listener.tableChanged(event));
}
 

/**
 * This gets events from the source model and forwards them to the UI
 */
@Override
public void tableChanged(TableModelEvent e){
  int type = e.getType();
  int firstRow = e.getFirstRow();
  int lastRow = e.getLastRow();
  int column = e.getColumn();
  
  //deal with the changes in the data
  //we have no way to "repair" the sorting on data updates so we will need
  //to rebuild the order every time
  
  switch(type){
    case TableModelEvent.UPDATE:
      if(firstRow == TableModelEvent.HEADER_ROW){
        //complete structure change -> reallocate the data
        init(sourceModel);
        newColumns();
        fireTableStructureChanged();
        if(isSortable()) sort();
      }else if(lastRow == Integer.MAX_VALUE){
        //all data changed (including the number of rows)
        init(sourceModel);
        if(isSortable()){
          sort();
        } else {
          //this will re-create all rows (which deletes the rowModel in JTable)
          componentSizedProperly = false;
          fireTableDataChanged();
        }
      }else{
        //the rows should have normal values
        //if the sortedColumn is not affected we don't care
        if(isSortable() &&
           (column == sortedColumn || 
            column == TableModelEvent.ALL_COLUMNS)){
            //re-sorting will also fire the event upwards
            sort();
        }else{
          componentSizedProperly = false;
          fireTableChanged(new TableModelEvent(this,  
                  sourceToTarget(firstRow), 
                  sourceToTarget(lastRow), column, type));
          
        }
      }
      break;
    case TableModelEvent.INSERT:
      //rows were inserted -> we need to rebuild
      init(sourceModel);
      if(firstRow != TableModelEvent.HEADER_ROW && firstRow == lastRow){
        //single row insertion
        if(isSortable()) sort();
        else{
          componentSizedProperly = false;
          fireTableChanged(new TableModelEvent(this,  
                sourceToTarget(firstRow), 
                sourceToTarget(lastRow), column, type));
        }
      }else{
        //the real rows are not in sequence
        if(isSortable()) sort();
        else {
          //this will re-create all rows (which deletes the rowModel in JTable)
          componentSizedProperly = false;
          fireTableDataChanged();
        }
      }
      break;
    case TableModelEvent.DELETE:
      //rows were deleted -> we need to rebuild
      init(sourceModel);
      if(isSortable()) sort();
      else {
        //this will re-create all rows (which deletes the rowModel in JTable)
        componentSizedProperly = false;
        fireTableDataChanged();
      }
  }
}