Application: gvSIG desktop

package org.gvsig.gui.beans.swing.jComboBoxItemsSeeker;

/* DefaultComboBoxModel.java --

   Copyright (C) 2002, 2004, 2005, 2006, Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath 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, or (at your option)

any later version.

GNU Classpath 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 GNU Classpath; see the file COPYING.  If not, write to the

Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301 USA.

Linking this library statically or dynamically with other modules is

making a combined work based on this library.  Thus, the terms and

conditions of the GNU General Public License cover the whole

combination.

As a special exception, the copyright holders of this library give you

permission to link this library with independent modules to produce an

executable, regardless of the license terms of these independent

modules, and to copy and distribute the resulting executable under

terms of your choice, provided that you also meet, for each linked

independent module, the terms and conditions of the license of that

module.  An independent module is a module which is not derived from

or based on this library.  If you modify this library, you may extend

this exception to your version of the library, but you are not

obligated to do so.  If you do not wish to do so, delete this

exception statement from your version. */

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

import java.io.Serializable;

import java.text.Collator;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import java.util.Locale;

import java.util.Vector;

import javax.swing.AbstractListModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.MutableComboBoxModel;

/**

 * Reimplementation of {@link DefaultComboBoxModel} adapted for the behavior needed for seek items which start with a text. This model also has behaviour configurable using flags.<br>

 * Represents the model used by {@link org.gvsig.gui.beans.swing.jComboBoxItemsSeeker.JComboBoxItemsSeekerConfigurable}, according the MVC (Model-View-Controller) pattern.

 * <ul>

 *  <li><b>ItemsOrder:</b> order in which items will be showed: maintain position (according the items were introduced); alphabetical order (according the local rules); or disordered.<br>

 *   * <b><i>MAINTAIN_POSITION</i></b>: in the same position as they are stored.<br>

 *   * <b><i>ALPHABETICAL_ORDERED</i></b>: in alphabetical order (according a local language rules).<br>

 *   * <b><i>DISORDERED</i></b>: disordered.

 *  </li>   

 *  <li><b>ShowAllItemsInListBox:</b> show all items in list box always, or only items that their start match with the text written.<br>

 *   * <b><i>SHOW_ALL_ITEMS</i></b>: shows all items of the model always.<br>

 *   * <b><i>SHOW_ONLY_MATCHES</i></b>: shows only the items that start with text written.

 *  </li>

 *  <li><b>LanguageRules:</b> language rules (es_ES, en_US, fr_FR, ...)</li>  

 *  <li><b>CaseSensitive:</b> consider or ignore the case sensitive seeking the items that start with the text written.<br>

 *   * <b><i>CASE_SENSITIVE</i></b>: discriminates between lower and upper cases.<br>

 *   * <b><i>CASE_INSENSITIVE</i></b>: doesn't discriminate between lower and upper cases.

 *  </li>  

 * </ul>

 * 

 * @see javax.swing.DefaultComboBoxModel

 *  

 * @author Pablo Piqueras Bartolom? (p_queras@hotmail.com)

 */

public class DefaultComboBoxItemsSeekerConfigurableModel extends AbstractListModel

    implements MutableComboBoxModel, Serializable, ISearchUsingFirstCharacters

    {

                private static final long serialVersionUID = 9200879660096233842L;

                /**

             * Storage for the elements in the model's vector. <br>

             * 

             * All items will be stored according they are introduced.

             */

            private Vector vector;

            /**

             * Stores the elements of 'vector' in alphabetical order. <br>

             * 

             * This attribute will be used in the searches.

             */

            private Vector alphabeticallyOrdered;

            /**

             * The selected item (<code>null</code> indicates no selection).

             */

            private Object selectedItem = null;

            ///// NEW ATTRIBUTES /////

                /**

                 * Object that allows compare strings

                 */

                private StringComparator stringComparator;

                /**

                 * Items that will be visible (displayed)

                 */

                private List visibleList;

                /**

                 * Text written

                 */

                private String textWritten;

            ///// END NEW ATTRIBUTES /////

                // CONSTANTS FOR CONFIGURE THE BEHAVIOR

                public static final int MAINTAIN_POSITION = 0;

                public static final int ALPHABETICAL_ORDERED = 1;

                public static final int DISORDERED = 2;

                public static final boolean SHOW_ALL_ITEMS = true;

                public static final boolean SHOW_ONLY_MATCHES = false;

                public static final boolean CASE_SENSITIVE = true;

                public static final boolean CASE_INSENSITIVE = false;

                public static final int DEFAULT_ITEMS_ORDER_CONFIGURATION = ALPHABETICAL_ORDERED;

                public static final boolean DEFAULT_SHOW_ALL_ITEMS_IN_LIST_BOX_CONFIGURATION = SHOW_ONLY_MATCHES;

                public static final String DEFAULT_LANGUAGE_RULES_CONFIGURATION = "es_ES";

                public static final boolean DEFAULT_CASE_SENSITIVE_CONFIGURATION = CASE_SENSITIVE;

                // END CONSTANTS FOR CONFIGURE THE BEHAVIOR

                // CONFIGURATION FLAGS

                /**

                 * Flag: order in which items will be showed: maintain position (according the items were introduced); alphabetical order (according the local rules); or disordered

                 */

                private int itemsOrder_Flag;

                /**

                 * Flag: show all items in list box always, or only items that their start match with the text written

                 */

                private boolean showAllItemsInListBox_Flag;

                /**

                 * Flag: language rules (es_ES, en_US, fr_FR, ...)

                 */

                private String languageRules_Flag;

                /**

                 * Flag: consider or ignore the case sensitive seeking the items that start with the text written.

                 */

                private boolean caseSensitive_Flag;

                // END FLAGS

                ///// REIMPLEMENTATION OF METHODS /////

            /**

             * @see javax.swing.DefaultComboBoxModel#DefaultComboBoxModel()

             */

            public DefaultComboBoxItemsSeekerConfigurableModel()

            {

                    vector = new Vector();

                    initialize();

            }

            /**

             * @see javax.swing.DefaultComboBoxModel#DefaultComboBoxModel(java.lang.Object[])

             */

            public DefaultComboBoxItemsSeekerConfigurableModel(Object[] items)

            {

                    vector = new Vector(Arrays.asList(items));

                    initialize();

            }

            /**

             * @see javax.swing.DefaultComboBoxModel#DefaultComboBoxModel(java.util.Vector)

             */

            public DefaultComboBoxItemsSeekerConfigurableModel(Vector vector)

            {

                    this.vector = new Vector(vector);

                    initialize();

            }

            /**

             * @see javax.swing.DefaultComboBoxModel#addElement(java.lang.Object)

             */

        public void addElement(Object object)

        {

                vector.addElement(object);

                VectorUtilities.addAlphabeticallyOrdered(alphabeticallyOrdered, object, stringComparator);

                int index = vector.size() - 1;

                fireIntervalAdded(this, index, index);

                updateVisibleList();

                 if ((itemsOrder_Flag == DISORDERED) && (visibleList != null))

                         Collections.shuffle(visibleList);

         }

        /**

         * @see javax.swing.DefaultComboBoxModel#removeElementAt(int)

         */

        public void removeElementAt(int index)

        {

                int selected = getIndexOf(selectedItem);

                if (selected == index) // choose a new selected item

                {

                        if (selected > 0)

                                setSelectedItem(getElementAt(selected - 1));

                        else 

                                setSelectedItem(getElementAt(selected + 1));

                }

                Object obj = vector.get(index);

                alphabeticallyOrdered.remove(obj);

                vector.removeElementAt(index);

                fireIntervalRemoved(this, index, index);

                updateVisibleList();

                 if ((itemsOrder_Flag == DISORDERED) && (visibleList != null))

                         Collections.shuffle(visibleList);

        }

        /**

         * @see javax.swing.DefaultComboBoxModel#insertElementAt(java.lang.Object, int)

         */                

        public void insertElementAt(Object object, int index)

        {

                vector.insertElementAt(object, index);

                VectorUtilities.addAlphabeticallyOrdered(alphabeticallyOrdered, object, stringComparator);

                fireIntervalAdded(this, index, index);

                updateVisibleList();

                 if ((itemsOrder_Flag == DISORDERED) && (visibleList != null))

                         Collections.shuffle(visibleList);

        }

        /**

         * @see javax.swing.DefaultComboBoxModel#removeElement(java.lang.Object)

         */

        public void removeElement(Object object)

        {

                int index = getIndexOf(object);

                if (index != -1) {

                        removeElementAt(index);

                }

        }

        /**

         * @see javax.swing.DefaultComboBoxModel#removeAllElements()

         */

        public void removeAllElements()

        {

                selectedItem = null;

                //int size = getSize();

                int size = vector.size();

                System.out.println("SIZE: " + size);

                if (size > 0)

                {

                        vector.clear();

                        alphabeticallyOrdered.clear();

                        fireIntervalRemoved(this, 0, size - 1);

                        updateVisibleList();

                         if ((itemsOrder_Flag == DISORDERED) && (visibleList != null))

                                 Collections.shuffle(visibleList);

                }

        }

        /**

         * @see javax.swing.DefaultComboBoxModel#getSize()

         */

        public int getSize()

        {

                if (visibleList == null)

                        return 0;

                else

                        return visibleList.size();

        }

        /**

         * @see javax.swing.DefaultComboBoxModel#setSelectedItem(java.lang.Object)

         */

        public void setSelectedItem(Object object)

        {

                // No item is selected and object is null, so no change required.

                if (selectedItem == null && object == null)

                        return;

                // object is already selected so no change required.

                if (selectedItem != null && selectedItem.equals(object))

                        return;

                // Simply return if object is not in the vector.

                if (object != null && getIndexOf(object) == -1)

                        return;

                // Here we know that object is either an item in the vector or null.

                // Handle the three change cases: selectedItem is null, object is

                // non-null; selectedItem is non-null, object is null;

                // selectedItem is non-null, object is non-null and they're not

                // equal.

                selectedItem = object;

                textWritten = object.toString();

                fireContentsChanged(this, -1, -1);

                updateVisibleList();

        }

        /**

         * @see javax.swing.DefaultComboBoxModel#getSelectedItem()

         */

        public Object getSelectedItem()

        {

                return selectedItem;

        }

        /**

         * @see javax.swing.DefaultComboBoxModel#getElementAt(int)

         */

        public Object getElementAt(int index)

        {

                if (index < 0 || index >= visibleList.size())

                        return null;

                return visibleList.get(index);

        }

        /**

         * @see javax.swing.DefaultComboBoxModel#getIndexOf(java.lang.Object)

         */

        public int getIndexOf(Object object)

        {

                if (visibleList == null)

                        return -1;

                return visibleList.indexOf(object);

        }

        ///// END REIMPLEMENTATION OF METHODS /////    

        ///// METHODS FOR THE BEHAVIOR FLAGS  /////

        /**

         * Returns the 'itemsOrder_Flag' configuration value of this component. Configuration values are: <br>

         *   + MAINTAIN_POSITION: all items will be shown in the order programmer did. <br>

         *   + ALPHABETICAL_ORDERED: all items will be shown in alphabetical order. <br>

         *   + DISORDERED: all items will be shown disordered.

         * 

         * @return 'itemsOrder_Flag' configuration

         */

        public int getItemsOrder_Flag() {

                return itemsOrder_Flag;

        }

        /**

         * Sets the 'itemsOrder_Flag' configuration value for this component. Configuration values are: <br>

         *   + MAINTAIN_POSITION: all items will be shown in the order programmer did. <br>

         *   + ALPHABETICAL_ORDERED: all items will be shown in alphabetical order. <br>

         *   + DISORDERED: all items will be shown disordered.

         * 

         * @param An int value for 'itemsOrder_Flag' configuration flag

         */

        public void setItemsOrder_Flag(int itemsOrder) {

                this.itemsOrder_Flag = itemsOrder;

        }

        /**

         * Returns the 'showAllItemsInListBox_Flag' configuration value of this component. Configuration values are: <br>

         *   + SHOW_ALL_ITEMS: shows all items in the list box. <br>

         *   + SHOW_ONLY_MATCHES: shows only the items that match with the text written.

         * 

         * @return 'showAllItemsInListBox_Flag' configuration

         */

        public boolean isShowAllItemsInListBox_Flag() {

                return showAllItemsInListBox_Flag;

        }

        /**

         * Sets the 'showAllItemsInListBox_Flag' configuration value for this component. Configuration values are: <br>

         *   + SHOW_ALL_ITEMS: shows all items in the list box. <br>

         *   + SHOW_ONLY_MATCHES: shows only the items that match with the text written.

         * 

         * @param A boolean value for 'showAllItemsInListBox_Flag' configuration flag

         */

        public void setShowAllItemsInListBox_Flag(boolean itemsShownInListBox) {

                this.showAllItemsInListBox_Flag = itemsShownInListBox;

        }

        /**

         * Returns the 'languageRules_Flag' configuration value of this component. The language code values could be consulted at: <br>

         * <i>http://www.ics.uci.edu/pub/ietf/http/related/iso639.txt </i><br>

         * <i>http://www.chemie.fu-berlin.de/diverse/doc/ISO_3166.html </i><br>

         * 

         * @see {@Locale}

         * 

         * @return 'languageRules_Flag' configuration

         */

        public String getLanguageRules_Flag() {

                return languageRules_Flag;

        }

        /**

         * Sets the 'languageRules_Flag' configuration value for this component. Configuration values are: <br>

         * <i>http://www.ics.uci.edu/pub/ietf/http/related/iso639.txt </i><br>

         * <i>http://www.chemie.fu-berlin.de/diverse/doc/ISO_3166.html </i><br>

         * 

         * @see {@Locale}

         * 

         * @param An String value for 'languageRules_Flag' configuration flag

         */

        public void setLanguageRules_Flag(String languageRules) {

                this.languageRules_Flag = languageRules;

                stringComparator.setLocaleRules(stringComparator.new LocaleRules(true, Collator.getInstance(new Locale(this.languageRules_Flag))));

                Collections.sort(alphabeticallyOrdered.subList(0, alphabeticallyOrdered.size()), stringComparator); 

                updateVisibleList();

        }

        /**

         * Returns the 'caseSensitive_Flag' configuration value of this component. Configuration values are: <br>

         *    + CASE_SENSITIVE: discriminates between small letters and capital letters. <br>

         *    + CASE_INSENSITIVE: doesn't discriminates between small letters and capital letters.

         * 

         * @return 'caseSensitive_Flag' configuration

         */

        public boolean isCaseSensitive_Flag() {

                return caseSensitive_Flag;

        }

        /**

         * Sets the 'caseSensitive_Flag' configuration value for this component. Configuration values are: <br>

         *    + CASE_SENSITIVE: discriminates between small letters and capital letters. <br>

         *    + CASE_INSENSITIVE: doesn't discriminates between small letters and capital letters.

         * 

         * @param A boolean value for 'caseSensitive_Flag' configuration flag

         */

        public void setCaseSensitive_Flag(boolean caseSensitive) {

                this.caseSensitive_Flag = caseSensitive;

                stringComparator.setCaseSensitive(this.caseSensitive_Flag);

                Collections.sort(alphabeticallyOrdered.subList(0, alphabeticallyOrdered.size()), stringComparator); 

                updateVisibleList();

        }

        ///// END METHODS FOR THE BEHAVIOR FLAGS  /////

   ///// NEW METHODS /////

        /**

         * Initializes some attributes of this class

         */

        private void initialize() {

                textWritten = "";

                // Set default flags configuration

                this.setDefaultBehaviorFlagsConfiguration();

                // Initialize the StringComparator -> use spanish alphabetical rules, and case sensitive

                stringComparator = new StringComparator();

                stringComparator.setCaseSensitive(DEFAULT_CASE_SENSITIVE_CONFIGURATION);

                stringComparator.setLocaleRules(stringComparator.new LocaleRules(true, Collator.getInstance(new Locale(DEFAULT_LANGUAGE_RULES_CONFIGURATION))));

                alphabeticallyOrdered = new Vector(vector.subList(0, vector.size()));

                Collections.sort(alphabeticallyOrdered.subList(0, alphabeticallyOrdered.size()), stringComparator); // Use an algorithm of comparision which implements the rules of the language.

                visibleList = new ArrayList();

        }

        /**

         *  Sets the default values of the flags

         */

        private void setDefaultBehaviorFlagsConfiguration() {

                this.itemsOrder_Flag = DEFAULT_ITEMS_ORDER_CONFIGURATION;

                this.showAllItemsInListBox_Flag = DEFAULT_SHOW_ALL_ITEMS_IN_LIST_BOX_CONFIGURATION;

                this.languageRules_Flag = DEFAULT_LANGUAGE_RULES_CONFIGURATION;

                this.caseSensitive_Flag = DEFAULT_CASE_SENSITIVE_CONFIGURATION;

        }

        /**

         * This method is necessary to fix a bug

         * 

         * @return Data stored in this model. Elements will be alphabetical sort ordered.

         */

        public Vector getData() {

                return vector;

        }

        /**

         * This method is necessary to fix a bug

         * 

         * @return Data stored in this model according the alphabetical order in the 'itemsOrder_Flag' flag. Elements will be alphabetical sort ordered.

         */

        public Vector getDataAccordingItemsOrderFlag() {

                switch(itemsOrder_Flag) {

                        case MAINTAIN_POSITION:

                                return vector;

                     case ALPHABETICAL_ORDERED:

                             // Do nothing because items are already alphabetically ordered

                             return alphabeticallyOrdered;

                     case DISORDERED:

                             updateVisibleList();                             

                             return new Vector(visibleList.subList(0, visibleList.size()));

                     default:

                             // Default case: ALPHABETICAL_ORDERED

                             // Do nothing because items are already alphabetically ordered

                             return alphabeticallyOrdered;

                }

        }

        /**

         * Updates the list with the results of the search of all items that thei first characters start with the text written.<br>

         * Updates its the configuration.

         */

        private void updateVisibleList() {

                if (vector.size() == 0) {

                        visibleList = alphabeticallyOrdered.subList(0, 0);

                        return;

                }

                if (showAllItemsInListBox_Flag) {

                        switch (itemsOrder_Flag) {

                                case MAINTAIN_POSITION:

                                        visibleList = vector.subList(0, vector.size());

                                     break;

                             case ALPHABETICAL_ORDERED:

                                     visibleList = alphabeticallyOrdered.subList(0, alphabeticallyOrdered.size());

                                 break;

                             case DISORDERED:

                                     visibleList = vector.subList(0, vector.size());

                                     break;

                             default:

                                     // Default case: ALPHABETICAL_ORDERED

                                     visibleList = alphabeticallyOrdered.subList(0, alphabeticallyOrdered.size());

                        }

                        if ((visibleList.size() > 0) && (textWritten.compareTo("") != 0)) {

                                List list = binarySearch(); //BinarySearchUsingFirstCharacters.doSearchConsideringCaseSensitive(textWritten, alphabeticallyOrdered, stringComparator);

                                if ((list != null) && (list.size() > 0)) {

                                        selectedItem = list.get(0);

                                        textWritten = selectedItem.toString();

                                }

                                else {

                                        selectedItem = null;

                                }

                        }

                }

                else {

                        visibleList = binarySearch(); //BinarySearchUsingFirstCharacters.doSearchConsideringCaseSensitive(textWritten, alphabeticallyOrdered, stringComparator);

                        switch (itemsOrder_Flag) {

                                case MAINTAIN_POSITION: case DISORDERED:

                                        if (visibleList != null) {

                                                Vector aux = new Vector(vector.subList(0, vector.size()));

                                                int size = aux.size();

                                                Object obj = new Object();

                                                for (int i = (size - 1); i >= 0; i--) {

                                                        obj = aux.get(i);

                                                        if (visibleList.contains(obj)) {

                                                                visibleList.remove(obj);

                                                        }

                                                        else {

                                                                aux.remove(i);

                                                        }

                                                }

                                                visibleList = aux.subList(0, aux.size());

                                        }

                                     break;

                             case ALPHABETICAL_ORDERED:

                                     // Do nothing because items are already alphabetically ordered

                                     break;

                             default:

                                     // Default case: ALPHABETICAL_ORDERED

                                     // Do nothing because items are already alphabetically ordered

                        }

                }

        }

        /**

         * Fetches a binary search with the text written, the items alphabetically ordered, and an string comparator.

         * 

         * @return java.util.List

         */

        private List binarySearch() {

                if (stringComparator.isCaseSensitive()) {

                        return BinarySearchUsingFirstCharacters.doSearchConsideringCaseSensitive(textWritten, alphabeticallyOrdered, stringComparator);

                }

                else  {

                        return BinarySearchUsingFirstCharacters.doSearchIgnoringCaseSensitive(textWritten, alphabeticallyOrdered, stringComparator);

                }

        }

        ///// END NEW METHODS /////

        ///// REIMPLEMENTATION OF METHODS OF THE INTERFACE ISearchUsingFirstCharacters /////

        /*

         *  (non-Javadoc)

         * @see org.gvsig.gui.beans.swing.jComboBoxItemsSeeker.ISearchUsingFirstCharacters#setWrittenText(java.lang.String)

         */

        public void setTextWritten(String text) {

                textWritten = text;

                updateVisibleList();

        }

        ///// END REIMPLEMENTATION OF METHODS OF THE INTERFACE ISearchUsingFirstCharacters /////

}