/*
    * BrowserTable.java
    *
    * Created on den 29 januari 2003, 10:25
    */
   
   package net.sourceforge.jsh3modtool.gui.imagetable;
   
   
  import java.awt.Color;
  import java.awt.Component;
  import java.awt.Dimension;
  import java.awt.Point;
  import java.awt.event.*;
  import java.util.*;
  
  import javax.swing.table.*;
  import javax.swing.*;
  
  import net.sourceforge.jsh3modtool.gui.imagetable.cache.ImageCache;
  import net.sourceforge.jsh3modtool.gui.imagetable.cellfilters.SelectedImagesFilter;
  import net.sourceforge.jsh3modtool.gui.imagetable.utils.JTableUtil;
   
  /***
   * A JTable that displays images and folders.
   * 
   * The image cells can have the following states:
   * <ul>
   * <li> Selected or not - if an image is selected then it has a blue border around it. 
   * Selected images can be add to the send list or other operations on them done.
   * <li> Tagged or not - if an image is tagged, then it has a check in the checkbox. A tagged
   * image is readonly.
   * <li> Active - Only one image can be active. The active image is displayed in the preview
   * pane and is Active for editing.
   * </ul>
   *
   * @author  erma
   */
  public class ImageTable extends JTable
  {
      /*** The spacing between the cells. */
      public static final int CELL_SPACING = 2;
      
      //private     ImageBrowser parentBrowser;
  
      // Cell renderers
      final private     ImageCellRenderer imageCellRenderer;
      final private     FolderCellRenderer folderCellRenderer;
      final private     EmptyCellRenderer emptyCellRenderer;
  
  
      final private     ImageTableModel model;
      final private     ImageCache imagesCache;
      
      private     ImageCell activeCell;
      /*** The last image that the user pressed CTRL + left mouse on */
      private     ImageCell lastControlImage;
  
      private     int rowHeight;
      private     int columnWidth;
  
  	private JPopupMenu popupMenu;
  
  	private int activeColumntCount;
  
  	public ImageTable()
  	{
  	    this(100,75);
  	}
  	
      /*** 
       * Creates a new instance of BrowseTable
       */
      public ImageTable(int width, int height )
      {
      	super();
          model = new ImageTableModel(1);
          imagesCache = new ImageCache( model );
          imageCellRenderer = new ImageCellRenderer( this, imagesCache );
          folderCellRenderer = new FolderCellRenderer();
          emptyCellRenderer = new EmptyCellRenderer();
  
          rowHeight = height;
          columnWidth = width;
          updateColumnRenderers();
          
          setModel( model );
          model.addTableModelListener( this );
  
          addMouseListener( new TableMouseListener() );
  
          setColumnSelectionAllowed(false);
          setRowSelectionAllowed(false);
          setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  
          //setRowHeight( getRowHeight() );
          setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  
  		this.setIntercellSpacing(new Dimension(CELL_SPACING, CELL_SPACING));
 
         super.setShowHorizontalLines( false );
         super.setShowVerticalLines( false );
 
         setBackground( Color.white );
         setTableHeader(null);
         
         activeColumntCount = 0;
     }
     
     /***
      * Returns this table's model.
      * This is a convenience method instead of the JTables own <code>getModel()</code>.
      * @return this table's model.
      */
     public ImageTableModel getBrowserTableModel()
     {
         return model;
     }
     
     /***
      * Revalidates the size of a cell.
      * If the cell size has changed then the whole table is revalidated.
      */
     public final void setImageSize(final int width,final int height)
     {
     	final Dimension thumbDim = new Dimension(width,height);
 
         if ( ( thumbDim.width != columnWidth ) || ( thumbDim.height != rowHeight ) )
         {
             imageCellRenderer.resetPanel();
             imagesCache.clear();
             rowHeight = thumbDim.height;
             columnWidth = thumbDim.width;
             revalidate();
         }
 
     }
 
 	/***
 	 * Returns the selected cell
 	 * @return selected cell, can be null if no cell is selected
 	 */
 	public ImageCell getActiveImage()
 	{
 		return activeCell;
 	}
     
     /*** Returns the number of images in the table
      * @return the number of items in the table
      */
     public int getModelSize()
     {
         return model.getSize();
     }
 
     /***
      * Resets the active cell to no active.
      */
 	/*private void resetActiveCell()
 	{
 		activeCell = null;
 	}*/
 
     /***
      * Removes all cells from the table
      */
     public void clearModel()
     {
         model.clear();
         lastControlImage = null;
     }
 
     /***
      * Updates the column renderers, sets the correct width and disables the
      *resizing
      */
     private final void updateColumnRenderers()
     {
         int colSize = getColumnModel().getColumnCount();
         for ( int i = 0; i < colSize; i++ )
         {
             getColumnModel().getColumn( i ).setMinWidth( getColumnWidth() );
             getColumnModel().getColumn( i ).setMaxWidth( getColumnWidth() );
             getColumnModel().getColumn( i ).setResizable( false );
         }
     }
 
     /***
      * Returns the width of the columns
      * @return width of one column
      */
     public int getColumnWidth()
     {
         return columnWidth;
     }
 
     /***
      * Returns the height of the row
      * @return height of one row
      */
     public int getRowHeight()
     {
         return rowHeight;
     }
 
     /*** 
      * Updates the model number of columns
      * @param cols new number of columns
      */
     public void setColumnCount( final int cols )
     {
         if ( activeColumntCount != cols )
         {
         	activeColumntCount = cols;
             JViewport viewport = (JViewport) getParent();
             int topRow = Math.round( (float) viewport.getViewPosition().y / (float) getRowHeight() );
             int imageIndex = topRow * model.getColumnCount();
 
             model.setColumnCount( cols );
             updateColumnRenderers();
 
             int newRow = imageIndex / model.getColumnCount();
 
             if ( activeCell == null )
             {
                 JTableUtil.scrollToVisible( this, newRow, 0 );
             } 
             else
             {
                 JTableUtil.scrollToCenter( this, model.getTableCell( activeCell ) );
             }
         }
     }
 
     /***
      * Returns the TableCellRenderer for the specified cell.
      * @param row the cell's row
      * @param column the cell's column
      * @return a TableCellRenderer, never null
      */
     public TableCellRenderer getCellRenderer(final int row, final int column)
     {
         TableCellRenderer cellRenderer = emptyCellRenderer;
         Object object = model.getValueAt(row, column);
         if ( object instanceof FolderCell )
         {
             cellRenderer = folderCellRenderer;
         } 
         else
         if ( object instanceof ImageCell )
         {
             cellRenderer = imageCellRenderer;
         }
         return cellRenderer;
     }
 
     /***
      * Returns the cell that is active for editing.
      * @return the cell that is active for editing., can be null if no image is selected
      */
     public ImageCell getActiveCell()
     {
         return activeCell;
     }
     
     /***
      * Finds the ImageCell matching the specified File and selects it for editing.
      * @param file the file to be selected for editing.
      */
     /*public void setActiveFile(java.io.File file)
     {
         selectionWatchCollection.add( file );
     }*/
     
     /***
      * Adds the following list to the selection watch list.
      * The list must contains filenames (String). 
      * @param watchList the filenames to add to the list.
      */    
   /*  public void addToSelectionWatchlist( List watchList )
     {
         for ( Iterator iterator = watchList.iterator(); iterator.hasNext(); )
         {
             File file = new File( (String) iterator.next() );          
             selectionWatchCollection.add( file );
         }
        // parentBrowser.resetActive();
     }*/
     
     /***
      * Sets the table selected for editing (ACTIVE) cell to the specified.
      * If the cell is not the same as the old selected then the cell is updated
      * and the table announces to the ImageBrowser that a new cell has been selected
      * @param cell the new selected cell
      */
     private void setActiveCell( final ImageCell cell )
     { 
         if ( ( activeCell == null ) || ( cell != activeCell ) )
         {
             ImageCell oldCell = activeCell;
             activeCell = cell;
             if ( oldCell != null )
             {
                 model.fireTableCellUpdate( oldCell );
             }
             selectCell( activeCell, true );
         }
     }
     
     /***
      * Toggle the selection of a cell. 
      * @param cell the cell to select.
      */
     private void toggleCellSelection( final ImageCell cell )
     {
         selectCell( cell, ! cell.isSelected() );
     }
     
     /***
      * Selects the cell. A selected cell can be added to the sendlist and has
      * a blue border around it.
      * @param cell the cell to select.
      * @param isSelected if the cell is to be selected or not.
      */
     private void selectCell( final ImageCell cell, final boolean isSelected )
     {
         if ( cell.isSelected() != isSelected )
         {
             cell.setSelected(isSelected);
             model.fireTableCellUpdate( cell );
           //  parentBrowser.setSelected( cell.getImageProperties(), isSelected );
         }
     }
     
     /***
      * Selects a list of image cells. The user can begin to select
      * one image and then select another cell further down. This method
      * selects all cells between the first and the last one.
      * @param cell the latest pressed image cell.
      * @param includeOldSelection if the previous selection should still be selected or not.
      */
     private void selectCellList(final ImageCell cell, final boolean includeOldSelection)
     {
         BaseCell startCell = lastControlImage;
         BaseCell endCell = cell;
         
         int startIndex = 0;
         if ( startCell != null )
         {
             startIndex = model.getImageIndex(startCell);
         }
         
         int endIndex = model.getImageIndex(endCell);
         
         if ( startIndex > endIndex )
         {
             int temp = endIndex;
             endIndex = startIndex;
             startIndex = temp;
         }
         
         if ( ! includeOldSelection )
         {
             deselectAllImages();
         }
                 
         for ( int i = startIndex; i <= endIndex; i++ )
         {
             BaseCell tempCell = model.getCell(i);
             if ( ( tempCell != null ) && ( tempCell.getClass().equals(ImageCell.class) ) )
             {
                 ((ImageCell)tempCell).setSelected(true);
                 //parentBrowser.setSelected( ((ImageCell)tempCell).getImageProperties(), true );
             }
         }  
         
         model.fireTableRowsUpdated( model.getTableCell(startIndex).row, model.getTableCell(endIndex).row );
     }
 
     /***
      * Fires an update event for the active cell, the active cell is the cell selected for editing.
      */
     public void updateActiveCell()
     {
         if ( activeCell != null )
         {
             model.fireTableCellUpdate( activeCell );
         }
     }
     
     /***
      * Tags the cell.
      * @param cell the image to tag.
      */
   /*  private void tagCell(ImageCell cell)
     {
         cell.toggleTagged(); 
         model.fireTableCellUpdate( cell );
     }*/
 
     /***
      * Selects all images, and repaints the component.
      * The ImageBrowser is notified of the selection
      */
     public void selectAllImages()
     {
     	final List images = model.getImageCells( new SelectedImagesFilter(false) );
         for ( ListIterator iterator = images.listIterator(); iterator.hasNext(); )
         {
             ImageCell image = (ImageCell) iterator.next();
             toggleCellSelection( image );
         }
         model.fireTableDataChanged();
     }
 
     /***
      * Deselects all images, and repaints the component.
      * The ImageBrowser is notified of the deselection
      */
     public void deselectAllImages()
     {
     	final List images = model.getImageCells(new SelectedImagesFilter(true));
         for ( ListIterator iterator = images.listIterator(); iterator.hasNext(); )
         {
             ImageCell image = (ImageCell) iterator.next();
             toggleCellSelection( image );
         }
         model.fireTableDataChanged();
     }
 
     /***
      * Selects tagged images and repaints the component.
      * The ImageBrowser is notified of the selection.
      */
    /* public void selectTaggedImages()
     {
         List images = model.getAllImageCells();
         for ( ListIterator iterator = images.listIterator(); iterator.hasNext(); )
         {
             ImageCell image = (ImageCell) iterator.next();
             selectCell( image, image.isTagged() );
         }
         model.fireTableDataChanged();
     }*/
 
     /***
      * All selected images get the supplied ipr.
      * @param ipr the new ipr properties.
      */
  /*   public void applyIprToAll(IprProperties ipr)
     {
         List images = model.getImageCells( new SelectedImagesFilter(true));
         for ( ListIterator iterator = images.listIterator(); iterator.hasNext(); )
         {
             ImageCell image = (ImageCell) iterator.next();
             image.updateIprProperties(ipr);
         }
     }*/
 
     /***
      * Updates the image cache so the selected cell needs to reload the thumbnail.
      */
     public void resetCachedImage()
     {
         if ( activeCell != null )
         {
             imagesCache.reloadCachedImage( activeCell );
             updateActiveCell();
         }
     }
 
     /***
      * The user has pressed on a Folder cell.
      * @param folder the foldercell
      * @param event the mouse event
      */
     private void leftMouseEventOnFolder( final FolderCell folder, final MouseEvent event )
     {
         if ( event.getClickCount() >= 2 )
         {
             //parentBrowser.openDirectory( folder.getTargetPath() );
         }
     }
 
     /***
      * The user has pressed on an Image cell
      * @param cell the table cell
      * @param image the image cell
      * @param event the mouse event
      */
     private void leftMouseEventOnImage( final JTableUtil.Cell cell, final ImageCell image, final MouseEvent event )
     {
         //relative Point in cell
     	final Point relativePoint = new Point();
         relativePoint.x = event.getX() - cell.column * getColumnWidth();
         relativePoint.y = event.getY() - cell.row * getRowHeight();
 
         // is in checkbox
        // Rectangle checkBox = imageCellRenderer.getCheckbox();
 //        Rectangle bottomBox = new Rectangle( 0, checkBox.y, getColumnWidth(), checkBox.height );
 
       /*  if ( bottomBox.contains( relativePoint ) )
         {
          //   tagCell(image);        
         } 
         else*/
         {
             if ( event.isShiftDown() && event.isMetaDown() )
             {
                 selectCellList( image, true );
             } 
             else
             if ( event.isShiftDown() )
             {
                 selectCellList( image, false );
             } 
             else
             if ( //( OSUtil.isMacintosh() && event.isMetaDown()) || 
                  ( event.isControlDown() ) )
             {
                 lastControlImage = image;
                 toggleCellSelection( image );
             } 
             else
             {
                 deselectAllImages();
                 lastControlImage = image;
                 setActiveCell( image );
             }
         }
         model.fireTableCellUpdated( cell.row, cell.column );
     }
 
     /***
      * The user has pressed in the table, determines if the cell under the mouse is
      * a folder or an image and dispatches the event to the correct handler,
      * @see mouseClickedOnFolder
      * @see mouseClickedOnImage
      * @param event the mouse event
      */
     protected void leftMouseButtonClickedInTable( final MouseEvent event )
     {
     	final JTableUtil.Cell cell = JTableUtil.getCell( this, event.getX(), event.getY() );
         if ( cell != null )
         {
         	final Object value = model.getValueAt( cell.row, cell.column );
             if ( value == null )
             {
                 return;
             }
 
             if ( value.getClass().equals( FolderCell.class ) )
             {
                 leftMouseEventOnFolder( (FolderCell) value, event );
             } 
             else
             {
                 leftMouseEventOnImage( cell, (ImageCell) value, event );
             }
         }
     }
 
 	/***
 	 * The user has pressed in the table, determines if the cell under the mouse is
 	 * a folder or an image and dispatches the event to the correct handler,
 	 * @see mouseClickedOnFolder
 	 * @see mouseClickedOnImage
 	 * @param event the mouse event
 	 */
 	protected void rightMouseButtonClickedInTable( final MouseEvent event )
 	{
 		final JTableUtil.Cell cell = JTableUtil.getCell( this, event.getX(), event.getY() );
 		if ( cell != null )
 		{
 			final Object value = model.getValueAt( cell.row, cell.column );
 			if ( value == null )
 			{
 				return;
 			}
 
 			if ( ( value.getClass().equals( ImageCell.class ) ) && 
                  ( event.isPopupTrigger() ) )
 			{
 				final ImageCell imageCell = (ImageCell) value;
                 //if ( ! model.getSelectedImageProperties().contains( imageCell.getImageProperties() ))
                 {
                     deselectAllImages();
                     setActiveCell( imageCell );
                 } 
 				popupMenu.show(event.getComponent(), event.getX(), event.getY());
 			}
 		}
 	}
 
     /***
      * Mouse listener class
      */
     private class TableMouseListener extends MouseAdapter
     {
         /*** If the left mouse button is clicked then it selects the image/folder 
          * {@inheritDoc}
          */
         public void mouseClicked(final MouseEvent event)
         {
             //if ( e.getButton() == MouseEvent.BUTTON1 )
             if ( ( event.getModifiers() & InputEvent.BUTTON1_MASK) != 0)
             {
                 leftMouseButtonClickedInTable( event );
             }
             
         }
         
 		// Need to test both for pressed and released events since it
 		// can be different for different platforms.
         /*** {@inheritDoc} */
 		public void mousePressed(final MouseEvent e)
 		{
 			if ( e.isPopupTrigger() )
 			{
 				rightMouseButtonClickedInTable( e );
 			}
 		}
 
         /*** {@inheritDoc} */
 		public void mouseReleased(final MouseEvent e)
 		{
 			if ( e.isPopupTrigger() )
 			{
 				rightMouseButtonClickedInTable( e );   	
 			}
 		}
     }
 
     /***
      * Dummy TableCellRenderer for empty cells, used for performace
      */
     private class EmptyCellRenderer implements TableCellRenderer
     {
         /*** {@inheritDoc} */
         public Component getTableCellRendererComponent(final JTable table, final Object value, 
         		final boolean isSelected, final boolean hasFocus, final int row, final int column)
         {
             return null;
         }
     }
 }