/* ----------------------------------------------------------------------------
   The Kiwi Toolkit - A Java Class Library
   Copyright (C) 1998-2004 Mark A. Lindner

   This library 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 library 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 library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.
 
   The author may be contacted at: mark_a_lindner@yahoo.com
   ----------------------------------------------------------------------------
   $Log: OrderedListModel.java,v $
   Revision 1.3  2004/05/13 21:40:59  markl
   javadoc updates

   Revision 1.2  2004/05/05 22:40:38  markl
   comment block updates

   Revision 1.1  2004/03/16 06:15:15  markl
   new class
   ----------------------------------------------------------------------------
*/

package kiwi.ui.model;

import kiwi.util.*;

import java.text.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;

/** An implementation of <i>ListModel</i> that keeps its elements ordered.
 *
 * @author Mark Lindner
 * @since Kiwi 2.0
 */

public class OrderedListModel implements ListModel
  {
  private Vector data = new Vector();
  private Vector listeners = new Vector();
  private Collator collator;

  /** Construct a new, empty <code>OrderedListModel</code>.
   */
  
  public OrderedListModel()
    {
    collator = Collator.getInstance();
    collator.setStrength(Collator.SECONDARY); // ignore case
    }

  /** Construct a new <code>OrderedListModel</code> with the given data.
   *
   * @param data A collection of elements to insert into the model. The
   * elements are inserted in sorted order.
   */

  public OrderedListModel(Vector data)
    {
    this();

    this.data.addAll(data);

    Collections.sort(this.data);
    }

  /** Set the collator to be used by this model.
   *
   * @param collator The collator.
   */

  public void setCollator(Collator collator)
    {
    this.collator = collator;
    }

  /** Add a list data listener to this model's list of listeners.
   *
   * @param listener The listener to add.
   */
  
  public void addListDataListener(ListDataListener listener)
    {
    listeners.addElement(listener);
    }

  /** Remove a list data listener from this model's list of listeners.
   *
   * @param listener The listener to remove.
   */
  
  public void removeListDataListener(ListDataListener listener)
    {
    listeners.removeElement(listener);
    }

  /** Get the size of the model.
   *
   * @return The number of items in the model.
   */
  
  public int getSize()
    {
    return(data.size());
    }

  /** Get the object at the given index in the model.
   *
   * @param index The index of the object to retrieve.
   * @return The object at the given index, or <code>null</code> if the index
   * is out of range.
   */
  
  public Object getElementAt(int index)
    {
    return(data.elementAt(index));
    }

  /** Add an object to the model. The object is inserted at the proper index
   * to maintain a sorted model.
   *
   * @param elem The new object to add.
   */
  
  public void addElement(Object elem)
    {
    int index = Collections.binarySearch(data, elem, collator);
    if(index < 0)
      {
      index = -index - 1;
      
      data.insertElementAt(elem, index);
      fireIntervalAdded(index, index);
      }
    }

  /** Remove all elements from the model. */
  
  public void clear()
    {
    if(! data.isEmpty())
      {
      int sz = data.size();
      data.clear();
      fireIntervalRemoved(0, sz - 1);
      }
    }

  /** Determine if the model contains an object.
   *
   * @param elem The object to search for.
   * @return <code>true</code> if the object is in the model,
   * <code>false</code> otherwise.
   */

  public boolean contains(Object elem)
    {
    return(data.contains(elem));
    }

  /** Get an enumeration of the elements in the model. */
  
  public Enumeration elements()
    {
    return(data.elements());
    }

  /** Get the index of an element in the model. */
  
  public int indexOf(Object elem)
    {
    return(data.indexOf(elem));
    }

  /** Determine if the model is empty.
   *
   * @return <code>true</code> if there are no elements in the model,
   * <code>false</code> otherwise.
   */
  
  public boolean isEmpty()
    {
    return(data.isEmpty());
    }

  /** Remove an element at the given index in the model.
   *
   * @param index The index of the element to remove.
   */
  
  public void removeElementAt(int index)
    {
    if((index >= 0) && (index < data.size()))
      {
      data.removeElementAt(index);
      fireIntervalRemoved(index, index);
      }
    }

  /** Remove a range of elements form the model.
   *
   * @param fromIndex The starting index of the range.
   * @param toIndex The ending index of the range.
   */
  
  public void removeRange(int fromIndex, int toIndex)
    {
    if((fromIndex >= 0) && (toIndex < data.size()) && (fromIndex <= toIndex))
      {
      int ct = toIndex - fromIndex;

      for(int i = 0; i < ct; i++)
        data.removeElementAt(fromIndex);

      fireIntervalRemoved(fromIndex, toIndex);
      }
    }
  
  /** Fire an <i>interval added</i> event.
   *
   * @param start The starting index of the interval.
   * @param end The ending index of the interval.
   */

  protected void fireIntervalAdded(int start, int end)
    {
    ListDataEvent evt = null;

    Enumeration e = listeners.elements();
    while(e.hasMoreElements())
      {
      ListDataListener l = (ListDataListener)e.nextElement();
      if(evt == null)
        evt = new ListDataEvent(this, ListDataEvent.INTERVAL_ADDED, start,
                                end);

      l.intervalAdded(evt);
      }
    }

  /** Fire an <i>interval removed</i> event.
   *
   * @param start The starting index of the interval.
   * @param end The ending index of the interval.
   */
  
  protected void fireIntervalRemoved(int start, int end)
    {
    ListDataEvent evt = null;

    Enumeration e = listeners.elements();
    while(e.hasMoreElements())
      {
      ListDataListener l = (ListDataListener)e.nextElement();
      if(evt == null)
        evt = new ListDataEvent(this, ListDataEvent.INTERVAL_REMOVED, start,
                                end);

      l.intervalRemoved(evt);
      }
    }

  /** Fire a <i>contents changed</i> event. */

  protected void fireContentsChanged()
    {
    ListDataEvent evt = null;

    Enumeration e = listeners.elements();
    while(e.hasMoreElements())
      {
      ListDataListener l = (ListDataListener)e.nextElement();
      if(evt == null)
        evt = new ListDataEvent(this, ListDataEvent.CONTENTS_CHANGED, 0,
                                data.size() - 1);

      l.contentsChanged(evt);
      }
    }  
  
  }

/* end of source file */