// START LICENSE
   // JSet - a Java JSet card board game implementation
   // Copyright (C) 2004 Jerome Lacoste
   //
   // 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.
  // END LICENSE
  
  package org.cb.jset.client.ui;
  
  /***
   * Created by IntelliJ IDEA.
   * User: jerome
   * Date: Jan 27, 2003
   * Time: 12:09:22 AM
   * To change this template use Options | File Templates.
   */
  
  import org.cb.cardboard.AbstractCardBoardModel;
  import org.cb.cardboard.BoardSelectionEvent;
  import org.cb.cardboard.BoardSelectionListener;
  import org.cb.cardboard.BoardSelectionModel;
  import org.cb.cardboard.Card;
  import org.cb.cardboard.CardBoardModel;
  import org.cb.cardboard.DefaultBoardSelectionModel;
  
  import javax.swing.JPanel;
  import javax.swing.ToolTipManager;
  import java.io.Serializable;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.List;
  
  /***
   * The component representing the set board in the graphical client.
   *
   * FIXME think about using Accessible
   *
   * @author jerome@coffeebreaks.org - last modified by $LastChangedBy: jerome $
   * @version $Id: JSetBoardComponent.java 130 2004-04-15 05:18:07Z jerome $
   */
  public class JSetBoardComponent extends JPanel
  {
  //  private Logger _logger = Logger.getLogger(this.getClass().getName());
  
  //  private final EventHandler _eventHandler = new EventHandler();
  //  private CardBoardModel _model = new JSetClientBoardModel();
  
    // private final List _cards = new ArrayList();
  
  //  private final java.util.Map _cardComponents = new java.util.HashMap();
  
    private CardBoardModel _dataModel;
    private BoardSelectionModel _selectionModel;
    // private BoardCardRenderer _cardRenderer;
    private BoardSelectionListener _selectionListener;
  
    /***
     * Constructs a Board component using the specified dataModel.
     * @param dataModel the model for that component
     */
    public JSetBoardComponent(final CardBoardModel dataModel)
    {
      if (dataModel == null)
      {
        throw new IllegalArgumentException("dataModel must be non null");
      }
  
      // Register with the ToolTipManager so that tooltips from the
      // renderer show through.
      final ToolTipManager toolTipManager = ToolTipManager.sharedInstance();
      toolTipManager.registerComponent(this);
  
  //    layoutOrientation = VERTICAL;
  
      this._dataModel = dataModel;
      _selectionModel = createSelectionModel();
  
  //    setAutoscrolls(true);
  //    setOpaque(true);
      updateUI();
    }
  
    /***
     * Constructs a <code>JCardBoardComponent</code> that displays the elements in
     * the specified array.  This constructor just delegates to the
     * <code>ListModel</code> constructor.
     *
    * @param listData the array of Objects to be loaded into the data model
    */
   public JSetBoardComponent(final Card[] listData)
   {
     this(new AbstractCardBoardModel()
     {
       public int getSize()
       {
         return listData.length;
       }
 
       public Card getElementAt(final int i)
       {
         return listData[i];
       }
 
       public List getElements()
       {
         return Collections.unmodifiableList(Arrays.asList(listData));
       }
     });
   }
 
   private BoardSelectionModel createSelectionModel()
   {
     return new DefaultBoardSelectionModel();
   }
 
   /***
    * @return the model for that board.
    */
   public CardBoardModel getModel()
   {
     return _dataModel;
   }
 
   /***
    * @return the selection model for that board.
    */
   public BoardSelectionModel getSelectionModel()
   {
     return _selectionModel;
   }
 
   /***
    * Sets a new model for that board.
    * A property change event with name "model" will be fired. 
    * @param model the new model
    */
   public void setModel(final CardBoardModel model)
   {
     if (model != _dataModel)
     {
 //      model.removeBoardDataListener(_eventHandler);
       final CardBoardModel oldModel = _dataModel;
       _dataModel = model;
 //      _dataModel.addBoardDataListener(_eventHandler);
       clearSelection();
       firePropertyChange("model", oldModel, _dataModel);
     }
   }
 
   /***
    * Determines whether single-item or multiple-item
    * selections are allowed.
    * The following <code>selectionMode</code> values are allowed:
    * <ul>
    * <li> <code>BoardSelectionModel.SINGLE_SELECTION</code>
    * Only one list index can be selected at a time.  In this
    * mode the <code>setSelectionInterval</code> and
    * <code>addSelectionInterval</code>
    * methods are equivalent, and only the second index
    * argument is used.
    * <li> <code>BoardSelectionModel.SINGLE_INTERVAL_SELECTION</code>
    * One contiguous index interval can be selected at a time.
    * In this mode <code>setSelectionInterval</code> and
    * <code>addSelectionInterval</code>
    * are equivalent.
    * <li> <code>BoardSelectionModel.MULTIPLE_INTERVAL_SELECTION</code>
    * In this mode, there's no restriction on what can be selected.
    * This is the default.
    * </ul>
    *
    * @param selectionMode an integer specifying the type of selections
    *                      that are permissible
    * @beaninfo description: The selection mode.
    * enum: SINGLE_SELECTION            BoardSelectionModel.SINGLE_SELECTION
    * SINGLE_INTERVAL_SELECTION   BoardSelectionModel.SINGLE_INTERVAL_SELECTION
    * MULTIPLE_INTERVAL_SELECTION BoardSelectionModel.MULTIPLE_INTERVAL_SELECTION
    * @see #getSelectionMode
    */
   public void setSelectionMode(final int selectionMode)
   {
     getSelectionModel().setSelectionMode(selectionMode);
   }
 
   /***
    * Returns whether single-item or multiple-item selections are allowed.
    *
    * @return the value of the <code>selectionMode</code> property
    * @see #setSelectionMode
    */
   public int getSelectionMode()
   {
     return getSelectionModel().getSelectionMode();
   }
 
 
   /***
    * Returns the first index argument from the most recent
    * <code>addSelectionModel</code> or <code>setSelectionInterval</code> call.
    * This is a convenience method that just delegates to the
    * <code>selectionModel</code>.
    *
    * @return the index that most recently anchored an interval selection
    * @see BoardSelectionModel#getAnchorSelectionIndex
    * @see #addSelectionInterval
    * @see #setSelectionInterval
    * @see #addBoardSelectionListener
    */
   public int getAnchorSelectionIndex()
   {
     return getSelectionModel().getAnchorSelectionIndex();
   }
 
 
   /***
    * Returns the second index argument from the most recent
    * <code>addSelectionInterval</code> or <code>setSelectionInterval</code>
    * call.
    * This is a convenience method that just  delegates to the
    * <code>selectionModel</code>.
    *
    * @return the index that most recently ended a interval selection
    * @beaninfo description: The lead selection index.
    * @see BoardSelectionModel#getLeadSelectionIndex
    * @see #addSelectionInterval
    * @see #setSelectionInterval
    * @see #addBoardSelectionListener
    */
   public int getLeadSelectionIndex()
   {
     return getSelectionModel().getLeadSelectionIndex();
   }
 
 
   /***
    * Returns the smallest selected cell index.
    * This is a convenience method that just delegates to the
    * <code>selectionModel</code>.
    *
    * @return the smallest selected cell index
    * @see BoardSelectionModel#getMinSelectionIndex
    * @see #addBoardSelectionListener
    */
   public int getMinSelectionIndex()
   {
     return getSelectionModel().getMinSelectionIndex();
   }
 
 
   /***
    * Returns the largest selected cell index.
    * This is a convenience method that just delegates to the
    * <code>selectionModel</code>.
    *
    * @return the largest selected cell index
    * @see BoardSelectionModel#getMaxSelectionIndex
    * @see #addBoardSelectionListener
    */
   public int getMaxSelectionIndex()
   {
     return getSelectionModel().getMaxSelectionIndex();
   }
 
   /***
    * Returns true if the specified index is selected.
    * This is a convenience method that just delegates to the
    * <code>selectionModel</code>.
    *
    * @param index index to be queried for selection state
    * @return true if the specified index is selected
    * @see BoardSelectionModel#isSelectedIndex
    * @see #setSelectedIndex
    * @see #addBoardSelectionListener
    */
   public boolean isSelectedIndex(final int index)
   {
     return getSelectionModel().isSelectedIndex(index);
   }
 
   /***
    * Returns true if nothing is selected.
    * This is a convenience method that just delegates to the
    * <code>selectionModel</code>.
    *
    * @return true if nothing is selected
    * @see BoardSelectionModel#isSelectionEmpty
    * @see #clearSelection
    * @see #addBoardSelectionListener
    */
   public boolean isSelectionEmpty()
   {
     return getSelectionModel().isSelectionEmpty();
   }
 
   /***
    * Returns an array of all of the selected indices in increasing
    * order.
    *
    * @return all of the selected indices, in increasing order
    * @see #removeSelectionInterval
    * @see #addBoardSelectionListener
    */
   public int[] getSelectedIndices()
   {
     final BoardSelectionModel sm = getSelectionModel();
     final int iMin = sm.getMinSelectionIndex();
     final int iMax = sm.getMaxSelectionIndex();
 
     if ((iMin < 0) || (iMax < 0))
     {
       return new int[0];
     }
 
     final int[] rvTmp = new int[1 + (iMax - iMin)];
     int n = 0;
     for (int i = iMin; i <= iMax; i++)
     {
       if (sm.isSelectedIndex(i))
       {
         rvTmp[n++] = i;
       }
     }
     final int[] rv = new int[n];
     System.arraycopy(rvTmp, 0, rv, 0, n);
     return rv;
   }
 
   /***
    * Selects a single cell.
    *
    * @param index the index of the one cell to select
    * @beaninfo description: The index of the selected cell.
    * @see BoardSelectionModel#setSelectionInterval
    * @see #isSelectedIndex
    * @see #addBoardSelectionListener
    */
   public void setSelectedIndex(final int index)
   {
     getSelectionModel().setSelectionInterval(index, index);
   }
 
 
   /***
    * Selects a set of cells.
    *
    * @param indices an array of the indices of the cells to select
    * @see BoardSelectionModel#addSelectionInterval
    * @see #isSelectedIndex
    * @see #addBoardSelectionListener
    */
   public void setSelectedIndices(final int[] indices)
   {
     final BoardSelectionModel sm = getSelectionModel();
     sm.clearSelection();
     for (int i = 0; i < indices.length; i++)
     {
       sm.addSelectionInterval(indices[i], indices[i]);
     }
   }
 
   /***
    * Returns an array of the values for the selected cells.
    * The returned values are sorted in increasing index order.
    *
    * @return the selected values or an empty list if
    *         nothing is selected
    * @see #isSelectedIndex
    * @see #getModel
    * @see #addBoardSelectionListener
    */
   public Object[] getSelectedValues()
   {
     final BoardSelectionModel sm = getSelectionModel();
     final CardBoardModel dm = getModel();
 
     final int iMin = sm.getMinSelectionIndex();
     final int iMax = sm.getMaxSelectionIndex();
 
     if ((iMin < 0) || (iMax < 0))
     {
       return new Object[0];
     }
 
     final Object[] rvTmp = new Object[1 + (iMax - iMin)];
     int n = 0;
     for (int i = iMin; i <= iMax; i++)
     {
       if (sm.isSelectedIndex(i))
       {
         rvTmp[n++] = dm.getElementAt(i);
       }
     }
     final Object[] rv = new Object[n];
     System.arraycopy(rvTmp, 0, rv, 0, n);
     return rv;
   }
 
   /***
    * Adds a listener to the cardBoard that's notified each time a change
    * to the selection occurs.  Listeners added directly to the
    * <code>JCardBoardComponent</code>
    * will have their <code>ListSelectionEvent.getSource() ==
    * this JCardBoardComponent</code>
    * (instead of the <code>BoardSelectionModel</code>).
    *
    * @param listener the <code>ListSelectionListener</code> to add
    * @see #getSelectionModel
    * @see #getBoardSelectionListeners()
    */
   public void addBoardSelectionListener(final BoardSelectionListener listener)
   {
     if (_selectionListener == null)
     {
       _selectionListener = new BoardSelectionHandler();
       getSelectionModel().addBoardSelectionListener(_selectionListener);
     }
 
     listenerList.add(BoardSelectionListener.class, listener);
   }
 
 
   /***
    * Removes a listener from the list that's notified each time a
    * change to the selection occurs.
    *
    * @param listener the <code>BoardSelectionListener</code> to remove
    * @see #addBoardSelectionListener
    * @see #getSelectionModel
    */
   public void removeBoardSelectionListener(final BoardSelectionListener listener)
   {
     listenerList.remove(BoardSelectionListener.class, listener);
   }
 
   /***
    * Returns an array of all the <code>BoardSelectionListener</code>s added
    * to this JCardBoardComponent with addBoardSelectionListener().
    *
    * @return all of the <code>BoardSelectionListener</code>s added or an empty
    *         array if no listeners have been added
    * @see #addBoardSelectionListener
    * @since 1.4
    */
   public BoardSelectionListener[] getBoardSelectionListeners()
   {
     return (BoardSelectionListener[]) listenerList.getListeners(BoardSelectionListener.class);
   }
 
 //  public void cardsAdded(CardProperties[] cards)
 //  {
 //    for (int i = 0; i < cards.length; i++)
 //    {
 //      CardProperties card = cards[i];
 //      _cardComponents.put(card, getCardFor(card));
 //    }
 //    _model.addCards(cards);
 //  }
 //
 //  public void setRemoved(CardSet set)
 //  {
 //    try
 //    {
 //      _model.removeSet(set);
 //    }
 //    catch (BoardException e)
 //    {
 //      throw new IllegalStateException("Set should be matching: " + e.getMessage());
 //    }
 //  }
 //
 //
 //  JSetCard getCardFor(CardProperties cardProperties)
 //  {
 //    return new JSetCard(cardProperties);
 //  }
 
   /* A ListSelectionListener that forwards ListSelectionEvents from
    * the selectionModel to the JCardBoardComponent ListSelectionListeners.  The
    * forwarded events only differ from the originals in that their
    * source is the JCardBoardComponent instead of the selectionModel itself.
    */
   private class BoardSelectionHandler implements BoardSelectionListener, Serializable
   {
     public void valueChanged(final BoardSelectionEvent e)
     {
       fireSelectionValueChanged(e.getFirstIndex(), e.getLastIndex(), e.getValueIsAdjusting());
     }
   }
 
 
   /***
    * Notifies <code>JCardBoardComponent</code> <code>BoardSelectionListener</code>s that
    * the selection model has changed.  It's used to forward
    * <code>BoardSelectionEvents</code> from the <code>selectionModel</code>
    * to the <code>BoardSelectionListener</code>s added directly to the
    * <code>JCardBoardComponent</code>.
    *
    * @param firstIndex  the first selected index
    * @param lastIndex   the last selected index
    * @param isAdjusting true if multiple changes are being made
    * @see #addBoardSelectionListener(org.cb.cardboard.BoardSelectionListener)
    * @see #removeBoardSelectionListener(BoardSelectionListener)
    * @see javax.swing.event.EventListenerList
    */
   protected void fireSelectionValueChanged(final int firstIndex, final int lastIndex,
                                            final boolean isAdjusting)
   {
     final Object[] listeners = listenerList.getListenerList();
     BoardSelectionEvent e = null;
 
     for (int i = listeners.length - 2; i >= 0; i -= 2)
     {
       if (listeners[i] == BoardSelectionListener.class)
       {
         if (e == null)
         {
           e = new BoardSelectionEvent(this, firstIndex, isAdjusting);
         }
         ((BoardSelectionListener) listeners[i + 1]).valueChanged(e);
       }
     }
   }
 
 
   /***
    * Clears the selection - after calling this method
    * <code>isSelectionEmpty</code> will return true.
    * This is a convenience method that just delegates to the
    * <code>selectionModel</code>.
    *
    * @see BoardSelectionModel#clearSelection
    * @see #isSelectionEmpty
    * @see #addBoardSelectionListener
    */
   public void clearSelection()
   {
     getSelectionModel().clearSelection();
   }
 
 
   /***
    * Selects the specified interval.  Both the <code>anchor</code>
    * and <code>lead</code> indices are included.  It's not
    * necessary for <code>anchor</code> to be less than <code>lead</code>.
    * This is a convenience method that just delegates to the
    * <code>selectionModel</code>.
    * The <code>DefaultBoardSelectionModel</code> implementation
    * will do nothing if either <code>anchor</code> or
    * <code>lead</code> are -1.
    * If <code>anchor</code> or <code>lead</code> are less than -1,
    * <code>IndexOutOfBoundsException</code> is thrown.
    *
    * @param anchor the first index to select
    * @param lead   the last index to select
    * @throws IndexOutOfBoundsException if either <code>anchor</code>
    *                                   or <code>lead</code> are less than -1
    * @see BoardSelectionModel#setSelectionInterval
    * @see #addSelectionInterval
    * @see #removeSelectionInterval
    * @see #addBoardSelectionListener
    */
   public void setSelectionInterval(final int anchor, final int lead)
   {
     getSelectionModel().setSelectionInterval(anchor, lead);
   }
 
   /***
    * Sets the selection to be the union of the specified interval with current
    * selection.  Both the anchor and lead indices are
    * included.  It's not necessary for anchor to be less than lead.
    * This is a convenience method that just delegates to the
    * <code>selectionModel</code>.  The
    * <code>DefaultBoardSelectionModel</code> implementation
    * will do nothing if either <code>anchor</code> or
    * <code>lead</code> are -1.
    * If <code>anchor</code> or <code>lead</code> are less than -1,
    * <code>IndexOutOfBoundsException</code> is thrown.
    *
    * @param anchor the first index to add to the selection
    * @param lead   the last index to add to the selection
    * @throws IndexOutOfBoundsException if either <code>anchor</code>
    *                                   or <code>lead</code> are less than -1
    * @see BoardSelectionModel#addSelectionInterval
    * @see #setSelectionInterval
    * @see #removeSelectionInterval
    * @see #addBoardSelectionListener
    */
   public void addSelectionInterval(final int anchor, final int lead)
   {
     getSelectionModel().addSelectionInterval(anchor, lead);
   }
 
 
   /***
    * Sets the selection to be the set difference of the specified interval
    * and the current selection.  Both the <code>index0</code> and
    * <code>index1</code> indices are removed.  It's not necessary for
    * <code>index0</code> to be less than <code>index1</code>.
    * This is a convenience method that just delegates to the
    * <code>selectionModel</code>.
    * The <code>DefaultBoardSelectionModel</code> implementation
    * will do nothing if either <code>index0</code> or
    * <code>index1</code> are -1.
    * If <code>index0</code> or <code>index1</code> are less than -1,
    * <code>IndexOutOfBoundsException</code> is thrown.
    *
    * @param index0 the first index to remove from the selection
    * @param index1 the last index to remove from the selection
    * @throws IndexOutOfBoundsException if either <code>index0</code>
    *                                   or <code>index1</code> are less than -1
    * @see BoardSelectionModel#removeSelectionInterval
    * @see #setSelectionInterval
    * @see #addSelectionInterval
    * @see #addBoardSelectionListener
    */
   public void removeSelectionInterval(final int index0, final int index1)
   {
     getSelectionModel().removeSelectionInterval(index0, index1);
   }
 
 //  class EventHandler implements CardBoardModelListener
 //  {
 //    public void intervalAdded(CardBoardEvent e)
 //    {
 //      //To change body of implemented methods use File | Settings | File Templates.
 //    }
 //
 //    public void intervalRemoved(CardBoardEvent e)
 //    {
 //      //To change body of implemented methods use File | Settings | File Templates.
 //    }
 //
 //    public void contentsChanged(CardBoardEvent event)
 //    {
 //
 //    }
 //  }
 }