import  javax.swing.*;
 import  javax.swing.table.TableCellEditor;
 import  javax.swing.table.TableCellRenderer;
 import  java.awt.*;

 public   class  TableUtils
{
     public   static   void  scrollSelectionToVisible(JTable table)
    {
         if  (table ==  null )
        {
             return ;
        }

         int  minIndex = table.getSelectionModel().getMinSelectionIndex();
         if  ((minIndex <  0 ) || (minIndex >= table.getRowCount()))
        {
             return ;
        }

         int  maxIndex = table.getSelectionModel().getMaxSelectionIndex();
         if  ((maxIndex <  0 ) || (maxIndex >= table.getRowCount()))
        {
             return ;
        }

        scrollRowToVisible(table, maxIndex);
         if  (minIndex != maxIndex)
        {
            scrollRowToVisible(table, minIndex);
        }
    }

     public   static   void  scrollRowToVisible(JTable table,  int  row)
    {
        scrollTableColumnToVisible(table, row,  0 );
    }

     public   static   void  scrollModelColumnToVisible(JTable table,  int  row,  int  column)
    {
         if  (table ==  null )
        {
             return ;
        }
        scrollTableColumnToVisible(table, row, table.convertColumnIndexToView(column));
    }

     public   static   void  scrollTableColumnToVisible(JTable table,  int  row,  int  column)
    {
         if  (table ==  null )
        {
             return ;
        }
         if  ((row <  0 ) || (row >= table.getRowCount()))
        {
             return ;
        }
         if  ((column <  0 ) || (column >= table.getColumnCount()))
        {
             return ;
        }

        Rectangle cellRect = table.getCellRect(row, column, true);
        table.scrollRectToVisible(cellRect);
    }

     public   static   void  selectRow(JTable table,  int  row)
    {
        selectRow(table, row, true);
    }

     public   static   void  selectRow(JTable table,  int  row,  boolean  grabFocus)
    {
         if  (table ==  null )
        {
             return ;
        }
         int  rowCount = table.getRowCount();
         if  (rowCount <=  0 )
        {
             return ;
        }

        stopCellEditing(table);
         if  ((row <  0 ) || (row >= rowCount))
        {
            table.clearSelection();
        }
         else 
        {
            table.setRowSelectionInterval(row, row);
            scrollRowToVisible(table, row);
        }
         if  (grabFocus && !table.hasFocus())
        {
            table.grabFocus();
        }
    }

     public   static   void  selectModelCell(JTable table,  int  row,  int  column)
    {
        selectTableCell(table, row, table.convertColumnIndexToView(column));
    }

     public   static   void  selectModelCell(JTable table,  int  row,  int  column,  boolean  grabFocus)
    {
        selectTableCell(table, row, table.convertColumnIndexToView(column), grabFocus);
    }

     public   static   void  selectTableCell(JTable table,  int  row,  int  column)
    {
        selectTableCell(table, row, column, true);
    }

     public   static   void  selectTableCell(JTable table,  int  row,  int  column,  boolean  grabFocus)
    {
         if  (table ==  null )
        {
             return ;
        }
         int  rowCount = table.getRowCount();
         if  (rowCount <=  0 )
        {
             return ;
        }
         int  columnCount = table.getColumnCount();
         if  (columnCount <=  0 )
        {
             return ;
        }

        stopCellEditing(table);
         if  ((row <  0 ) || (row >= rowCount) || (column <  0 ) || (column >= columnCount))
        {
            table.clearSelection();
        }
         else 
        {
            table.setRowSelectionInterval(row, row);
            table.getSelectionModel().setAnchorSelectionIndex(row);
             if  (table.getColumnSelectionAllowed())
            {
                table.getColumnModel().getSelectionModel().setSelectionInterval(column, column);
            }
            table.getColumnModel().getSelectionModel().setAnchorSelectionIndex(column);
            scrollTableColumnToVisible(table, row, column);
        }
         if  (grabFocus && !table.hasFocus())
        {
            table.grabFocus();
        }
    }

     public   static   void  selectFirst(JTable table)
    {
        selectFirst(table, true);
    }

     public   static   void  selectFirst(JTable table,  boolean  grabFocus)
    {
         if  (table ==  null )
        {
             return ;
        }
         if  (table.getRowCount() >  0 )
        {
            selectRow(table,  0 , grabFocus);
        }
    }

     public   static   void  selectLast(JTable table)
    {
        selectLast(table, true);
    }

     public   static   void  selectLast(JTable table,  boolean  grabFocus)
    {
         if  (table ==  null )
        {
             return ;
        }
         int  rowCount = table.getRowCount();
         if  (rowCount >  0 )
        {
            selectRow(table, rowCount -  1 , grabFocus);
        }
    }

     public   static   void  selectPrevious(JTable table)
    {
        selectPrevious(table, true);
    }

     public   static   void  selectPrevious(JTable table,  boolean  grabFocus)
    {
         if  (table ==  null )
        {
             return ;
        }
        ListSelectionModel selModel = table.getSelectionModel();
         if  (selModel ==  null )
        {
             return ;
        }
         int  rowCount = table.getRowCount();
         if  (rowCount <=  0 )
        {
             return ;
        }

         int  index = selModel.getAnchorSelectionIndex() -  1 ;
         if  (index <  0 )
        {
            index =  0 ;
        }
        selectRow(table, index, grabFocus);
    }

     public   static   void  selectNext(JTable table)
    {
        selectNext(table, true);
    }

     public   static   void  selectNext(JTable table,  boolean  grabFocus)
    {
         if  (table ==  null )
        {
             return ;
        }
        ListSelectionModel selModel = table.getSelectionModel();
         if  (selModel ==  null )
        {
             return ;
        }
         int  rowCount = table.getRowCount();
         if  (rowCount <=  0 )
        {
             return ;
        }

         int  index = selModel.getAnchorSelectionIndex();
         if  (index <  0 )
        {
            index =  0 ;
        }
         else 
        {
            index++;
             if  (index >= rowCount)
            {
                index = rowCount -  1 ;
            }
        }
        selectRow(table, index, grabFocus);
    }

     public   static   void  stopCellEditing(JTable table)
    {
         if  (table ==  null )
        {
             return ;
        }
        TableCellEditor editor = table.getCellEditor();
         if  (editor ==  null )
        {
             return ;
        }
         if  (!editor.stopCellEditing())
        {
            editor.cancelCellEditing();
        }
    }

     public   static   void  cancelCellEditing(JTable table)
    {
         if  (table ==  null )
        {
             return ;
        }
        TableCellEditor editor = table.getCellEditor();
         if  (editor ==  null )
        {
             return ;
        }
        editor.cancelCellEditing();
    }

     public   static   void  startModelCellEditing(JTable table,  int  row,  int  column)
    {
         if  (table ==  null )
        {
             return ;
        }

        startTableCellEditing(table, row, table.convertColumnIndexToView(column));
    }

     public   static   void  startTableCellEditing(JTable table,  int  row,  int  column)
    {
         if  (table ==  null )
        {
             return ;
        }

         if  ((row <  0 ) || (row >= table.getRowCount()))
        {
             return ;
        }
         if  ((column <  0 ) || (column >= table.getColumnCount()))
        {
             return ;
        }

        stopCellEditing(table);
         if  (table.getCellEditor() !=  null )
        {
             return ;
        }
        selectTableCell(table, row, column);
        table.editCellAt(row, column);

        TableCellEditor editor = table.getCellEditor();
         if  (editor  instanceof  NCGAbstractTableCellEditor)
        {
            ((NCGAbstractTableCellEditor)editor).editingWasStartedArtificially(table);
        }
    }

    /**
     * This methid calculate the minimum width of table column, that needed for correct
     * display of all cell in this column. Method does not consider the distance between
     * columns in the table. To calculate this value it is necessary to increase result
     * of the method on table.getColumnModel().getColumnMargin() value.
     * @param table the table
     * @param column index of column in the table
     * @return column width
     */
     public   static   int  calculateBestColumnWidth(JTable table,  int  column)
    {
         if  (table ==  null )
        {
             return   0 ;
        }
         if  ((column <  0 ) || (column >= table.getColumnCount()))
        {
             return   0 ;
        }

         int  res =  0 ;
        TableCellRenderer renderer;
        Component rendererComponent;
        Dimension prefferdSize;
         int  maxInd = table.getRowCount();
         for  ( int  row =  0 ; row < maxInd; row++)
        {
            renderer = table.getCellRenderer(row, column);
             if  (renderer ==  null )
            {
                 continue ;
            }
            rendererComponent = table.prepareRenderer(renderer, row, column);
             if  (rendererComponent ==  null )
            {
                 continue ;
            }
            prefferdSize = rendererComponent.getPreferredSize();
             if  (prefferdSize ==  null )
            {
                 continue ;
            }
             if  (prefferdSize.width > res)
            {
                res = prefferdSize.width;
            }
        }
         return  res;
    }
}

        TableCellEditor editor = table.getCellEditor();
         if  (editor  instanceof  NCGAbstractTableCellEditor)
        {
            ((NCGAbstractTableCellEditor)editor).editingWasStartedArtificially(table);
        }