package fr.ifremer.quadrige2.ui.swing.common.table.action;
   
   /*
    * #%L
    * Reef DB :: UI
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2014 - 2015 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   * 
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   * 
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  import fr.ifremer.quadrige2.ui.swing.common.table.AbstractTableModel;
  import fr.ifremer.quadrige2.ui.swing.common.table.AbstractTableUIHandler;
  import fr.ifremer.quadrige2.ui.swing.common.table.CheckTableColumn;
  import org.jdesktop.swingx.JXTable;
  
  import javax.swing.AbstractAction;
  import javax.swing.table.TableCellEditor;
  import java.awt.Component;
  
  /**
   * Abstract Action performed on a table responsive on key bindings
   * <p/>
   * Created by Ludovic on 01/06/2015.
   */
  public abstract class AbstractCellSelectionAction extends AbstractAction {
  
      private final AbstractTableUIHandler handler;
  
      /**
       * <p>Constructor for AbstractCellSelectionAction.</p>
       *
       * @param name a {@link String} object.
       * @param handler a {@link fr.ifremer.quadrige2.ui.swing.common.table.AbstractTableUIHandler} object.
       */
      public AbstractCellSelectionAction(String name, AbstractTableUIHandler handler) {
          super(name);
          this.handler = handler;
      }
  
      private AbstractTableModel getTableModel() {
          return handler.getTableModel();
      }
  
      private JXTable getTable() {
          return handler.getTable();
      }
  
      /**
       * <p>isTableEditing.</p>
       *
       * @return a boolean.
       */
      protected boolean isTableEditing() {
          return getTable().isEditing();
      }
  
      /**
       * <p>isCreateNewRow.</p>
       *
       * @return a boolean.
       */
      protected boolean isCreateNewRow() {
          return getTableModel().isCreateNewRow();
      }
  
      /**
       * <p>addNewRow.</p>
       */
      protected void addNewRow() {
          // stop previous cell editing first
          if (stopActiveEdition()) {
              // add a new row in model
              getTableModel().addNewRow();
          }
      }
  
      /**
       * <p>getRowCount.</p>
       *
       * @return a int.
       */
      protected int getRowCount() {
          return getTable().getRowCount();
      }
 
     /**
      * <p>getColumnCount.</p>
      *
      * @return a int.
      */
     protected int getColumnCount() {
         return getTable().getColumnCount();
     }
 
     /**
      * <p>getSelectedRow.</p>
      *
      * @return a int.
      */
     protected int getSelectedRow() {
         return getTable().getSelectedRow();
     }
 
     /**
      * <p>getSelectedColumn.</p>
      *
      * @return a int.
      */
     protected int getSelectedColumn() {
         return getTable().getSelectedColumn();
     }
 
     /**
      * <p>getNextColumn.</p>
      *
      * @param column a int.
      * @return a int.
      */
     protected int getNextColumn(int column) {
         int nextColumn = column;
         do {
             nextColumn++;
         } while (nextColumn < getColumnCount() && getTable().getColumn(nextColumn) instanceof CheckTableColumn);
         return nextColumn;
     }
 
     /**
      * <p>getPreviousColumn.</p>
      *
      * @param column a int.
      * @return a int.
      */
     protected int getPreviousColumn(int column) {
         int nextColumn = column;
         do {
             nextColumn--;
         } while (nextColumn >= 0 && getTable().getColumn(nextColumn) instanceof CheckTableColumn);
         return nextColumn;
     }
 
     /**
      * <p>isCellValid.</p>
      *
      * @param row a int.
      * @param column a int.
      * @return a boolean.
      */
     protected boolean isCellValid(int row, int column) {
         return row > -1 && column > -1 && row < getRowCount() && column < getColumnCount();
     }
 
     /**
      * <p>isCellEditable.</p>
      *
      * @param row a int.
      * @param column a int.
      * @return a boolean.
      */
     protected boolean isCellEditable(int row, int column) {
         return isCellValid(row, column) && getTable().isCellEditable(row, column) && !(getTable().getColumn(column) instanceof CheckTableColumn);
     }
 
     /**
      * <p>selectCell.</p>
      *
      * @param row a int.
      * @param column a int.
      * @return a boolean.
      */
     protected boolean selectCell(int row, int column) {
 
         if (!isCellValid(row, column)) return false;
 
         // stop previous cell editing first
         if (!stopActiveEdition()) {
             return false;
         }
 
         getTable().setColumnSelectionInterval(column, column);
         getTable().setRowSelectionInterval(row, row);
         getTable().scrollCellToVisible(row, column);
         return true;
     }
 
     /**
      * <p>editCell.</p>
      *
      * @param row a int.
      * @param column a int.
      */
     protected void editCell(int row, int column) {
         if (selectCell(row, column)) getTable().editCellAt(row, column);
     }
 
     /**
      * <p>stopActiveEdition.</p>
      *
      * @return a boolean.
      */
     protected boolean stopActiveEdition() {
         TableCellEditor editor = getTable().getCellEditor();
         return editor == null || editor.stopCellEditing();
     }
 
     /**
      * <p>selectNextComponent.</p>
      */
     protected void selectNextComponent() {
         Component next = handler.getNextComponentToFocus();
         if (next != null) {
             next.requestFocus();
         }
     }
 
     /**
      * <p>selectPreviousComponent.</p>
      */
     protected void selectPreviousComponent() {
         Component previous = handler.getPreviousComponentToFocus();
         if (previous != null) {
             previous.requestFocus();
         }
     }
 
     public enum Direction {
         NEXT_CELL, PREVIOUS_CELL, NEXT_ROW, PREVIOUS_ROW
     }
 }