package org.devaki.nextobjects.ui.workspace.models;
   /*
   
   nextobjects Copyright (C) 2001-2005 Emmanuel Florent
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2 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 General Public License along
  with this program; if not, write to the Free Software Foundation, Inc., 59
  Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  
  */
  import java.util.Vector;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.event.KeyAdapter;
  import java.awt.event.KeyEvent;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  import javax.swing.BorderFactory;
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  import javax.swing.table.AbstractTableModel;
  import javax.swing.DefaultListSelectionModel;
  import javax.swing.table.JTableHeader;
  import javax.swing.table.TableColumnModel;
  import org.apache.maven.project.Build;
  import org.devaki.nextobjects.ui.components.CustomTable;
  /***
   * This class provide the build panel of the Model Editor
   * @author <a href="mailto:eflorent@devaki.org">Emmanuel Florent</a>
   */
  public class BuildEdit extends JPanel
  {
      /***
       * Selected row in the jTable
       */
      private int selectedRow = 0;
      /***
       * The table for columns
       * the project do not yet offer the ability of managing
       * ( DefaultListSelectionModel.SINGLE_SELECTION )
       * multiples build as maven do.
       */
      private CustomTable jTableBuilds =
          new CustomTable(
              false,
              DefaultListSelectionModel.SINGLE_SELECTION,
              false,
              false);
      /***
      * The table model
      */
      private ObjectBuildTableModel model = new ObjectBuildTableModel();
      /***
       * Constructor
       *
       */
      public BuildEdit()
      {
          super(new GridBagLayout());
          // Define table model
          this.jTableBuilds.setModel(this.model);
          // Set tool tips for the table header
          this.jTableBuilds.setTableHeader(
              new ToolTipHeader(this.jTableBuilds.getColumnModel()));
          // Fix columns width
          this.setColumnsWidth();
          // 'jPanelGeneralFields'
          this.add(
              new JScrollPane(this.jTableBuilds),
              new GridBagConstraints(
                  0,
                  0,
                  5,
                  1,
                  1.0,
                  1.0,
                  GridBagConstraints.CENTER,
                  GridBagConstraints.BOTH,
                  new Insets(5, 5, 0, 5),
                  0,
                  0));
          // Define table model
          this.jTableBuilds.setModel(this.model);
          // Set tool tips for the table header
          this.jTableBuilds.setTableHeader(
              new ToolTipHeader(this.jTableBuilds.getColumnModel()));
          // Fix columns width
          this.setColumnsWidth();
         // MOUSE
         this.jTableBuilds.addMouseListener(new MouseAdapter()
         {
             // When clicking on 'jTableField'...
             public final void mouseClicked(final MouseEvent e)
             {
                 // Set 'selectedRow'
                 selectedRow = jTableBuilds.getSelectedRow();
                 // Enable 'jButtonRemove'
             }
         });
         // KEY
         this.jTableBuilds.addKeyListener(new KeyAdapter()
         {
             // When selecting a row of 'jTableField' using the keyboard...
             public final void keyReleased(final KeyEvent e)
             {
                 // Set 'selectedRow'
                 selectedRow = jTableBuilds.getSelectedRow();
                 // Enable 'jButtonRemove'
             }
         });
         this.setBorder(BorderFactory.createTitledBorder("Build"));
         // Fix columns width
         this.setColumnsWidth();
     }
     /***
      * Unused: Cancel edition if 'DataDictionaryEdit' was
      * edited in its previous call
      */
     public final void cancelCellEditing()
     {
         if (this.jTableBuilds.isEditing())
         {
             int tmpInt1 = this.jTableBuilds.getEditingRow();
             int tmpInt2 = this.jTableBuilds.getEditingColumn();
             this
                 .jTableBuilds
                 .getCellEditor(tmpInt1, tmpInt2)
                 .cancelCellEditing();
         }
     }
     /***
      * Reset 'jTableField' columns width
      */
     private void setColumnsWidth()
     {
         for (int i = 0; i < this.model.getColumnCount(); i++)
         {
             this.jTableBuilds.getColumnModel().getColumn(i).setPreferredWidth(
                 this.model.getColumnSize(i));
         }
     }
     /***
      * This class define a model to edit the object columns
      */
     public class ObjectBuildTableModel extends AbstractTableModel
     {
         /*** The data stored to be restored with cancel button */
         private Vector oldData = new Vector();
         /***
          * The column name
          */
         private final String[] columnNames =
             {
                 "nag email adress",
                 "source directory",
                 "unit test source directory",
                 "aspectSource directory" };
         /***
          * The column class/types
          */
         private final Class[] columnClasses =
             { String.class, String.class, String.class, String.class };
         /***
          * The column size
          */
         private final int[] columnSizes = { 165, 165, 165, 160 };
         /***
          * The columns
          */
         private Vector builds = new Vector(1);
         /***
          * Return the data contained in the JTable
          * @return colums
          */
         public final Vector getBuilds()
         {
             return builds;
         }
         /***
          * Reset the TableModel to its old values
          */
         public final void resetBuilds()
         {
             cancelCellEditing();
             this.builds = new Vector(oldData);
         }
         /***
          * Set data in the JTable
          * @param pData the columns
          */
         public final void setBuild(final Vector pData)
         {
             // store the old data
             oldData.removeAllElements();
             for (int i = 0; i < pData.size(); i++)
             {
                 oldData.addElement(new Build());
             }
             //fix the new data.
             this.builds = new Vector(pData);
         }
         /***
          * Return the number of columns
          * @return count
          */
         public final int getColumnCount()
         {
             return this.columnNames.length;
         }
         /***
          * Return the number of lines
          * @return the count of row, number of columns.
          */
         public final int getRowCount()
         {
             return 1;
         }
         /***
          * Return the name of the column at the specified index
          * @param i index
          * @return column
          */
         public final String getColumnName(final int i)
         {
             return this.columnNames[i];
         }
         /***
          * Return the class of the column at the specified index
          * @param i index
          * @return class
          */
         public final Class getColumnClass(final int i)
         {
             return this.columnClasses[i];
         }
         /***
          * Return the size of the column at the specified index
          * @param i index
          * @return the size
          */
         public final int getColumnSize(final int i)
         {
             return this.columnSizes[i];
         }
         /***
          * Return the value at the specified row and column
          * @param row row index
          * @param col column index
          * @return the value
          */
         public final Object getValueAt(final int row, final int col)
         {
             Build newBuild = (Build) builds.elementAt(0);
             switch (col)
             {
                 case 0 :
                     return newBuild.getNagEmailAddress();
                 case 1 :
                     return newBuild.getSourceDirectory();
                 case 2 :
                     return newBuild.getUnitTestSourceDirectory();
                 case 3 :
                     return newBuild.getAspectSourceDirectory();
                 default :
                     return null;
             }
         }
         /***
          * Set the specified value at the specified row and column
          * @param value value
          * @param row row index
          * @param col column index
          */
         public final void setValueAt(
             final Object value,
             final int row,
             final int col)
         {
             Build newBuild = (Build) builds.elementAt(row);
             switch (col)
             {
                 case 0 :
                     newBuild.setNagEmailAddress(value.toString());
                     break;
                 case 1 :
                     newBuild.setSourceDirectory(value.toString());
                     break;
                 case 2 :
                     newBuild.setUnitTestSourceDirectory(value.toString());
                     break;
                 case 3 :
                     newBuild.setAspectSourceDirectory(value.toString());
                     break;
                 default :
                     break;
             }
             // Replace the previous element
             this.builds.setElementAt(newBuild, 0);
             this.fireTableDataChanged();
             // Set the selected row for the jTableField
             jTableBuilds.setSelectedRow(0);
         }
         /***
          * Return that every cell is editable
          * @param row row index
          * @param col column index
          * @return is editable
          */
         public final boolean isCellEditable(final int row, final int col)
         {
             return row == 0;
         }
     } // End of class 'EntityFieldTableModel'
     /***
      * Define the tooltips of the 'jTableField' header
      */
     private class ToolTipHeader extends JTableHeader
     {
         /***
          * The tooltips
          * This tooltips are caught from the maven docs.
          * Thus it was at time of coding this constructor may be
          * out of date as it was wrotten on the basis of Maven v. 1.0-rc1
          */
         private String[] toolTips =
             {
                 " An address to which notifications regarding the status"
                     + " of builds for this project can be sent. This is"
                     + " intended for use by tools which do unattended"
                     + " builds, for example those providing for continuous"
                     + " integration. Currently this is used by the"
                     + " maven:gump-descriptor  target.",
                 "This element specifies a directory containing the source"
                     + " of the project. The generated build system will"
                     + " compile the source in this directory when the project"
                     + " is built",
                 " This element specifies a directory containing the unit test"
                     + " source of the project. The generated build system will"
                     + " compile these directories when the project is being"
                     + " tested. The unit tests must use the JUnit framework",
                 " This element specifies a directory containing Aspect sources"
                     + " of the project. The generated build system will compile"
                     + " the Aspects in this directory when the project is built"
                     + " if Aspects have been enabled (see the Aspectj goals"
                     + " document)." };
         /***
         * Construct a new 'ToolTipHeader' object
         * @param pModel the TableColumnModel
         */
         public ToolTipHeader(final TableColumnModel pModel)
         {
             super(pModel);
         }
         /***
          * Return the tool tip depending on the mouse cursor position
          * @param e the event
          * @return the tooltip
          */
         public final String getToolTipText(final MouseEvent e)
         {
             int col = this.columnAtPoint(e.getPoint());
             int modelCol = this.getTable().convertColumnIndexToModel(col);
             return toolTips[modelCol];
         }
     }
     /***
      * Accessor to the ObjectBuildTableModel
      * @return the ObjectBuildTableModel
      */
     public final ObjectBuildTableModel getModel()
     {
         return model;
     }
     /***
      * Accessor to the ObjectBuildTableModel
      * @param pModel the ObjectBuildTableModel
      */
     public final void setModel(final ObjectBuildTableModel pModel)
     {
         this.model = pModel;
     }
 }