@Override
public void moveColumn(int fromIndex, int toIndex) {
    TableColumn from = columnList.get(fromIndex);
    TableColumn to = columnList.get(toIndex);

    columnList.set(fromIndex, to);
    to.setModelIndex(fromIndex);

    columnList.set(toIndex, from);
    from.setModelIndex(toIndex);

    orderUpdate();

    for (TableColumnModelListener w : new ArrayList<>(watchers)) {
        w.columnMoved(new TableColumnModelEvent(this, fromIndex, toIndex));
    }
}
 

public void columnMoved(TableColumnModelEvent e)
{
	if (e.getFromIndex() == e.getToIndex()) return;

	//  A table column has been moved one position to the left or right
	//  in the view of the table so we need to update the manager to
	//  track the new location

	int index = e.getToIndex();
	TableColumn column = tcm.getColumn( index );
	allColumns.remove( column );

	if (index == 0)
	{
		allColumns.add(0, column);
	}
	else
	{
		index--;
		TableColumn visibleColumn = tcm.getColumn( index );
		int insertionColumn = allColumns.indexOf( visibleColumn );
		allColumns.add(insertionColumn + 1, column);
	}
}
 

@Override
    public void moveColumn(int viewFrom, int viewTo) {
//		viewToModelMap
        super.moveColumn(viewFrom, viewTo);
        if(viewFrom == viewTo) return;

        int leftIndex = Math.min(viewFrom, viewTo);
        int rightIndex = Math.max(viewFrom, viewTo);

        for (int index = leftIndex; index <= rightIndex; index++) {
            LogTableColumn col = (LogTableColumn) getColumn(index);
            col.setOrder(index);
            col.setModelIndex(index);
        }

        saveLayout();
        this.fireColumnMoved(new TableColumnModelEvent(this, viewFrom, viewTo));
    }
 

@Override
public void removeColumn(TableColumn column) {
    int columnIndex = tableColumns.indexOf(column);

    if (columnIndex != -1) {
        // Adjust for the selection
        if (selectionModel != null) {
            selectionModel.removeIndexInterval(columnIndex,columnIndex);
        }

        column.removePropertyChangeListener(this);
        tableColumns.removeElementAt(columnIndex);

        //Update model index for subsequent columns
        for (int index = columnIndex; index < tableColumns.size(); index++) {
            tableColumns.get(index).setModelIndex(index);
        }

        // Post columnAdded event notification.  (JTable and JTableHeader
        // listens so they can adjust size and redraw)
        fireColumnRemoved(new TableColumnModelEvent(this,
                columnIndex, 0));
    }
}
 

@Override
public void columnAdded(TableColumnModelEvent e) {
    int minWidth;
    final int index = e.getToIndex();
    switch (index) {
        case 0:
        case 1:
            minWidth = 60;
            break;
        default:
            minWidth = 80;
    }
    TableColumnModel columnModel = (TableColumnModel) e.getSource();
    columnModel.getColumn(index).setPreferredWidth(minWidth);
    columnModel.getColumn(index).setCellRenderer(new RightAlignmentTableCellRenderer());
}
 

/** Copy of addColumn(TableColumn) with an index specifying where to add the new column */
   private void addColumn(TableColumn aColumn, int index) {
if (aColumn == null) {
    throw new IllegalArgumentException("Object is null");
}

tableColumns.insertElementAt(aColumn, index);
aColumn.addPropertyChangeListener(this);
//invalidateWidthCache();
       totalColumnWidth = -1;

// Post columnAdded event notification
fireColumnAdded(new TableColumnModelEvent(this, 0, index));
   }
 

@Override
public void columnMoved(TableColumnModelEvent e) {
    int from = e.getFromIndex();
    int to = e.getToIndex();
    if(from == to) {
        return;
    }
    table.getTableHeader().getColumnModel().getColumn(from).setModelIndex(from);
    table.getTableHeader().getColumnModel().getColumn(to).setModelIndex(to);
    tableModel.moveColumn(from, to);
}
 

/**
 * Overridden to fix 
 * //http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4330950:
 */ 
@Override
public void columnMoved(TableColumnModelEvent e) {
  if (isEditing()) {
      cellEditor.stopCellEditing();
  }
  super.columnMoved(e);
}
 

/**
 * Maps {@code JTable.columnAdded(TableColumnModelEvent)} through queue
 */
public void columnAdded(final TableColumnModelEvent tableColumnModelEvent) {
    runMapping(new MapVoidAction("columnAdded") {
        @Override
        public void map() {
            ((JTable) getSource()).columnAdded(tableColumnModelEvent);
        }
    });
}
 

/**
 * Maps {@code JTable.columnMoved(TableColumnModelEvent)} through queue
 */
public void columnMoved(final TableColumnModelEvent tableColumnModelEvent) {
    runMapping(new MapVoidAction("columnMoved") {
        @Override
        public void map() {
            ((JTable) getSource()).columnMoved(tableColumnModelEvent);
        }
    });
}
 

/**
 * Maps {@code JTable.columnRemoved(TableColumnModelEvent)} through queue
 */
public void columnRemoved(final TableColumnModelEvent tableColumnModelEvent) {
    runMapping(new MapVoidAction("columnRemoved") {
        @Override
        public void map() {
            ((JTable) getSource()).columnRemoved(tableColumnModelEvent);
        }
    });
}
 

/**
 * Maps {@code JTableHeader.columnAdded(TableColumnModelEvent)} through queue
 */
public void columnAdded(final TableColumnModelEvent tableColumnModelEvent) {
    runMapping(new MapVoidAction("columnAdded") {
        @Override
        public void map() {
            ((JTableHeader) getSource()).columnAdded(tableColumnModelEvent);
        }
    });
}
 

/**
 * Maps {@code JTableHeader.columnRemoved(TableColumnModelEvent)}
 * through queue
 */
public void columnRemoved(final TableColumnModelEvent tableColumnModelEvent) {
    runMapping(new MapVoidAction("columnRemoved") {
        @Override
        public void map() {
            ((JTableHeader) getSource()).columnRemoved(tableColumnModelEvent);
        }
    });
}
 

/**
 * Maps {@code JTableHeader.columnMoved(TableColumnModelEvent)} through queue
 */
public void columnMoved(final TableColumnModelEvent tableColumnModelEvent) {
    runMapping(new MapVoidAction("columnMoved") {
        @Override
        public void map() {
            ((JTableHeader) getSource()).columnMoved(tableColumnModelEvent);
        }
    });
}
 

@Override
public void columnMoved(TableColumnModelEvent e) {
	if (table == null) {
		return;
	}

	onColsConfigChanged();
}
 

public void testFunctionsNotFaulty() {
    TableColumnModelEvent event = new TableColumnModelEvent(fileEditor.getTable().getColumnModel(), 0, 1);
    fileEditor.tableEditorListener.columnAdded(event);
    fileEditor.tableEditorListener.columnRemoved(event);
    fileEditor.tableEditorListener.columnMoved(event);

    fileEditor.tableEditorListener.columnMarginChanged(new ChangeEvent(fileEditor.getTable().getColumnModel()));
    fileEditor.tableEditorListener.columnSelectionChanged(new ListSelectionEvent(fileEditor.getTable().getColumnModel(), 0, 1, true));
    fileEditor.tableEditorListener.tableChanged(new TableModelEvent(fileEditor.getTableModel()));
    assertTrue(true);
}
 

@Override
public void columnMoved(final TableColumnModelEvent evt) {
    if (evt.getFromIndex() == evt.getToIndex()) {
        return;
    }
    sortOrderChanged = true;
    // rebuild();
}
 

@Override
public void columnAdded(TableColumnModelEvent e) {
	super.columnAdded(e);
	// bigger default size
	TableColumn column = getColumnModel().getColumn(getColumnModel().getColumnCount() - 1);
	column.setPreferredWidth(COLUMN_WIDTH);
}
 

/** Necessary to properly stopping the editing when a column is moved (dragged). */
@Override
public void columnMoved(final TableColumnModelEvent e) {
	if (isEditing()) {
		cellEditor.stopCellEditing();
	}
	super.columnMoved(e);
}
 

public void columnAdded(TableColumnModelEvent e)
  {
  	//  A table column was added to the TableColumnModel so we need
  	//  to update the manager to track this column

  	TableColumn column = tcm.getColumn( e.getToIndex() );

if (allColumns.contains( column ))
	return;
else
	allColumns.add( column );
  }
 

@Override
public void columnMoved(final TableColumnModelEvent e) {
	if (e.getFromIndex() != e.getToIndex()) {
		if (!columnMoved) {
			from = e.getFromIndex();
		}
		to = e.getToIndex();
		columnMoved = true;
	}
}
 

@Override
public void availableColumnAdded(TableColumnModelEvent event)
{
	int index = event.getToIndex();
	TableColumn column = dynamicColumnModel.getAvailableColumns().get(index);
	menu.getItems().add(index, createMenuItem(column));
	cornerButton.setVisible(true);
}
 

@Override
public void availableColumnRemove(TableColumnModelEvent event)
{

	menu.getItems().remove(event.getFromIndex());
	if (menu.getItems().isEmpty())
	{
		cornerButton.setVisible(false);
	}
}
 

/**
 * Notifies all listeners that have registered interest for
 * notification on this event type.  The event instance
 * is lazily created using the parameters passed into
 * the fire method.
 * @param  e  the event received
 */
protected void fireAvailableColumnAdded(TableColumnModelEvent e)
{
	// Guaranteed to return a non-null array
	Object[] listeners = listenerList.getListenerList();
	// Process the listeners last to first, notifying
	// those that are interested in this event
	for (int i = listeners.length - 2; i >= 0; i -= 2)
	{
		if (listeners[i] == DynamicTableColumnModelListener.class)
		{
			((DynamicTableColumnModelListener) listeners[i + 1]).availableColumnAdded(e);
		}
	}
}
 

/**
 * Notifies all listeners that have registered interest for
 * notification on this event type.  The event instance
 * is lazily created using the parameters passed into
 * the fire method.
 * @param  e  the event received
 */
protected void fireAvailableColumnRemoved(TableColumnModelEvent e)
{
	// Guaranteed to return a non-null array
	Object[] listeners = listenerList.getListenerList();
	// Process the listeners last to first, notifying
	// those that are interested in this event
	for (int i = listeners.length - 2; i >= 0; i -= 2)
	{
		if (listeners[i] == DynamicTableColumnModelListener.class)
		{
			((DynamicTableColumnModelListener) listeners[i + 1]).availableColumnRemove(e);
		}
	}
}
 

@Override
public void addColumn(TableColumn column)
{
	if (getColumnCount() < offset)
	{
		super.addColumn(column);
	}
	else
	{
		int index = availableColumns.size();
		availableColumns.add(column);
		fireAvailableColumnAdded(new TableColumnModelEvent(this, -1, index));
	}
}
 

@Override
public void removeColumn(TableColumn column)
{
	super.removeColumn(column);
	if (availableColumns.contains(column))
	{
		int index = availableColumns.indexOf(column);
		availableColumns.remove(column);
		fireAvailableColumnRemoved(new TableColumnModelEvent(this, index, -1));
	}
}
 

@Override
public void availableColumnAdded(TableColumnModelEvent event)
{
	int index = event.getToIndex();
	TableColumn column = dynamicColumnModel.getAvailableColumns().get(index);
	menu.getItems().add(index, createMenuItem(column));
	cornerButton.setVisible(true);
}
 

@Override
public void availableColumnRemove(TableColumnModelEvent event)
{

	menu.getItems().remove(event.getFromIndex());
	if (menu.getItems().isEmpty())
	{
		cornerButton.setVisible(false);
	}
}
 

/**
 * Notifies all listeners that have registered interest for
 * notification on this event type.  The event instance
 * is lazily created using the parameters passed into
 * the fire method.
 * @param  e  the event received
 */
protected void fireAvailableColumnAdded(TableColumnModelEvent e)
{
	// Guaranteed to return a non-null array
	Object[] listeners = listenerList.getListenerList();
	// Process the listeners last to first, notifying
	// those that are interested in this event
	for (int i = listeners.length - 2; i >= 0; i -= 2)
	{
		if (listeners[i] == DynamicTableColumnModelListener.class)
		{
			((DynamicTableColumnModelListener) listeners[i + 1]).availableColumnAdded(e);
		}
	}
}