| gvSIG desktop 1

package org.gvsig.gui.beans.comboBoxItemsSeeker;

import java.awt.Color;

import java.awt.Point;

import java.awt.datatransfer.Clipboard;

import java.awt.datatransfer.Transferable;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.awt.event.KeyListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.util.Enumeration;

import java.util.Vector;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.ComboBoxEditor;

import javax.swing.ComboBoxModel;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.KeyStroke;

import javax.swing.event.AncestorEvent;

import javax.swing.event.AncestorListener;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.event.ListDataEvent;

import javax.swing.event.ListDataListener;

import javax.swing.event.PopupMenuEvent;

import javax.swing.event.PopupMenuListener;

import javax.swing.event.UndoableEditEvent;

import javax.swing.event.UndoableEditListener;

import javax.swing.text.AttributeSet;

import javax.swing.text.BadLocationException;

import javax.swing.text.JTextComponent;

import javax.swing.text.PlainDocument;

import javax.swing.undo.AbstractUndoableEdit;

import javax.swing.undo.CannotRedoException;

import javax.swing.undo.CannotUndoException;

import javax.swing.undo.UndoManager;

import javax.swing.undo.UndoableEdit;

import org.apache.log4j.Logger;

import org.gvsig.gui.beans.optionsEditionByMousePopupMenu.JOptionsEditionByMousePopupMenu;

import com.iver.andami.PluginServices;

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

 */

/**  VERSI?N EN DESARROLLO

 *  REVISAR COMENTARIOS Y C?DIGO QUE PUEDA SOBRAR

 *  

 *  POR DEFECTO USA UN MODELO QUE NO FUNCIONA BIEN SI HAY ITEMS REPETIDOS

 *  

* This class allows users to insert a chain of characters and show all the sentences of the JComboBox that match its first ones characters with it.

* This class is also a Java Bean, and is made according the MVC (Model - View - Controller) pattern.

* This class has the View, the Control and can access to the Model.

* The behavior of this componet can be configurated by 7 flags: (Esto lo cambio!!!!!)

*  + The appearence of the items showed at the beginning and when the user presses the ESCAPE key: (This is configured with 2 flags -> 3 different states are possible) 

*             -> maintainPositionItems -> When we see the list of all items, this are showed in the ordenation as they have been introduced (if true); (if false) each new item 

*           when we write on the TextField of this Component will be showed at the end (esto ?ltimo creo q. no -> revisarlo)

*      -> all_Alphanumeric_Sorted -> All items we can see in this Component will be showed in alphanumeric ordenation (if true)

*  + The list of the items showed when the user makes a search writting or pressing the BACK-SPACE key (This is configured with 1 flag -> 2 different states are possible)

*      -> alphanumericSortedSearches -> When we write on the TextField of this Component all results (items) are showed in alphanumeric ordenation (if true)

*  + case Sensitive or not when the user writes 

*      -> case_Sensitive -> When we write on the TextField it can discriminate upper cases from down cases (if true) or not (if false) (This is configured with 1 flag -> 2 different states are possible)

*  + Show all items always

*      -> showAllItems -> If true -> this component shows all items always; if false -> this component only shows items that their first characters match with the string written by the user

*  + Use one color (black) or 2 colors (black by default and red if the string written doesn't match with the beginning of all items)

*      -> only_One_Color -> The text on the textField only will be showed on black color (if true); false -> if the text on the textField doesn't match with any current item of this component -> the text

*            will be showed on red color

*  +            * @param boolean (completeMatchedItem (explicar))

*  + @param boolean (useBeep (explicar))

* 

* Default Values of the Flags:

*  -> maintainPositionItems -> true

*  -> all_Alphanumeric_Sorted -> true

*  -> alphanumericSortedSearches -> false 

*  -> case_Sensitive -> false

*  -> showAllItems -> false

*  -> only_One_Color -> false

*  

*  The flags are distributed in two classes:

*  -> ComboBoxSearcheableDynamicModel -> maintainPositionItems, all_Alphanumeric_Sorted, alphanumericSortedSearches, case_Sensitive, showAllItems 

*  -> JComboBoxSearcheableDynamic -> only_One_Color

* 

* Combinations of flags not allowed:

*         ->        maintainPositionItems == allAlphanumericSorted == true

*        ->        ((maintain_Position_Items == false) && (all_Alphanumeric_Sorted == true) && (alphanumeric_Sorted_Searches == false))

*   ->  showAllItems == true && maintainPositionItems == false (Creo que esta mal)

* 

* Limitations:

* -> When we add more than one item with the same name (string value) -> the behavior of this component only considers one item in most of the cases when it does a search

* -> If this component has Hundreds,Thousands or even Million/s of items is probably that had quite delay to respond the evens of the user; this also depends of the machine where it's executed and other factors

* 

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

*/

public class JComboBoxItemsSeekerConfigurable extends JComboBox implements java.io.Serializable {

        //private static final long serialVersionUID = -1853812970336818959L;

        // PONER SERIALIZACI?N

        // eSTAS HAY QUE BORRARLAS!

/*        private Vector defaultItems;

        private Set notRemovedItems;

        private Set removedItems;*/

        private final int BEGINNING_VIEW_STATE = 0;

        private final int START_VIEW_STATE = 1;

        private final int SEARCH_VIEW_STATE = 2;

        private int currentShowState; // 0 -> at the beginning; 1 -> when is showing the start list of items; 2 -> when is showing a search list of items

        // CONFIGURATION FLAGS

        private boolean onlyOneColor;

        private boolean completeMatchedItem;

        private boolean beepEnabled;

        // END FLAGS

        // PUEDE QUE TB. sOBren

//        private boolean allItemsAreSorted;

        // Last selected item

        private Object selectedItem;

        private Object lastSelectedItem; // This is used for only update (refresh) de popup when a different item is selected

        private String lastDocumentText;

        // pueDE QUE TB. SOBRE

        private int num = 0;

//        private JTextField txtField;

        private final int POPUP_LIST_ITEMS_HEIGHT = 8;

        // Reference to the ui

        //private MetalComboBoxItemsSeekerUI ui;

        // Reference to the model

        private AbstractDefaultComboBoxItemsSeekerConfigurableModel model;

        // Some listeners for the Control between the View and de Model

        private KeyListener editorKeyListener;

        private MouseAdapter editorMouseListener;

        private FocusListener editorFocusListener;

        private DocumentListener documentListener;

        private ListDataListener modelListDataListener;

        private PopupMenuListener popupMenuListener;

        private PropertyChangeListener editionMenuListener;

        // Reference to the document of the Editor of this component for optimize the seeks

        private PlainDocumentSeeker document;

//        private String writtenString;

        private boolean continueOnStartViewState;

//        private boolean specialKeys; // ESC and TAB keys

        private boolean textKeyPressed;

        private boolean lastWasTheBeginningState;

        private boolean lastWasPressedAKeyModifier;

        private boolean popupWillBeVisible;

        private boolean optionsEditorWasVisible;

//        private boolean keyPressed;

//        private boolean updatePopUp;

//        private boolean upOrDownKeyPressed;

//        private boolean deleteKeyPressed;

//        private boolean escapeKeyPressed;

        // OTRAS FLAGS que puede que sobren alguNAS

        private boolean selecting=false;

        private boolean hidePopupOnFocusLoss;

        private boolean hitBackspace;

        private boolean hitBackspaceOnSelection;

        private boolean allowedRepeatedItems;

        // TRACE - DEBUG

        private Logger logger = Logger.getLogger(JComboBoxItemsSeekerConfigurable.class.getClass());

        // END TRACE - DEBUG

//        OptionsEditionByMouse optionsEditionByMouse = new OptionsEditionByMouse();

        private JOptionsEditionByMousePopupMenu optionsEditionByMouse;

//        OptionsEditionByMouseV2 pme = new OptionsEditionByMouseV2();

        // UNDO-REDO

//        protected UndoManager undo = new UndoManager();

        private UndoManager undoManager;

        private Action undoAction;

        private Action redoAction;

        private final String undoActionKey = "Undo";

        private final String redoActionKey = "Redo";

        private int undoRedoLimitActions;

        // END UNDO-REDO        

        /**

         * Default Constructor

         */

        public JComboBoxItemsSeekerConfigurable() {

                // Invokes to the parent class constructor                

                super();

                // Create attributes and set initial values

                this.initialize();

                // Set the default values of the flags

                this.onlyOneColor = false;

                this.completeMatchedItem = false; //true;

                this.beepEnabled = false; //true;

                // Other configuration tasks

                this.createDefaultListeners();

                this.configure();

                //this.configure();

        }

        /**

         * Default Constructor with four parameters: configure the 4 flags

         * 

         * @param boolean (true -> maintains the position of the items; false -> don't maintains the position of the items)

         * @param boolean (true -> all items showed when we write on the textfield will be showed in alphanumeric ordenation; false -> they don't have to be in alphanumeric ordenation)

         * @param boolean (true -> all items showed will be in alphanumeric ordenation; false -> they don't have to be in alphanumeric ordenation)

         * @param boolean (true -> discriminates capital letters from small letters; false -> don't discriminates capital letters from small letters)

         */

        public JComboBoxItemsSeekerConfigurable(int start_Behavior, int search_Behavior, boolean case_Sensitive)        {

                // Invokes to the parent class constructor                

                super();        

                // Create attributes and set initial values

                this.initialize();

                // Sets the options selected by the user

//                this.model.setMaintainPositionItems(maintain_Position_Items);

//                this.model.setAllAlphanumericSorted(all_Alphanumeric_Sorted);

//                this.model.setAlphanumericSortedSearches(alphanumeric_Sorted_Searches);

                this.model.setStartBehavior(start_Behavior);

                this.model.setStartBehavior(search_Behavior);

                this.model.setCaseSensitive(case_Sensitive);

//                this.model.setShowAllItems(false);

                this.onlyOneColor = false;

                this.completeMatchedItem = false; //true;

                this.beepEnabled = true;

                if (!testFlagsConfigurationOK())

                        JOptionPane.showMessageDialog(this, PluginServices.getText(this, "errorMessageJComboBoxItemsSeekerConfigurable"), PluginServices.getText(this, "exportJOP2Title"), JOptionPane.ERROR_MESSAGE);

                else

                        this.configure();

        }

        /**

         * Default Constructor with six parameters: configure the 6 flags

         * 

         * @param boolean (true -> maintains the position of the items; false -> don't maintains the position of the items)

         * @param boolean (true -> all items showed when we write on the textfield will be showed in alphanumeric ordenation; false -> they don't have to be in alphanumeric ordenation)

         * @param boolean (true -> all items showed will be in alphanumeric ordenation; false -> they don't have to be in alphanumeric ordenation)

         * @param boolean (true -> discriminates capital letters from small letters; false -> don't discriminates capital letters from small letters)

         * @param boolean (true -> the text on the textField only will be showed on black color (if true); false -> if the text on the textField doesn't match with any current item of this component -> the text

         *                           will be showed on red color)

           * @param boolean (true -> this component shows all items always; false -> this component only shows items that their first characters match with the string written by the user)

           * @param boolean (completeMatchedItem (explicar))

           * @param boolean (beepEnabled (explicar))

           * @param boolean (allowedRepeatedItems (explicar))

         */

        public JComboBoxItemsSeekerConfigurable(int start_Behavior, int search_Behavior, boolean case_Sensitive, boolean only_One_Color, boolean show_All_Items, boolean complete_Matched_Item, boolean use_Beep, boolean allowed_Repeated_Items) {

                // Invokes to the parent class constructor                

                super();        

                // Create attributes and set initial values

                this.initialize();

                // Sets the options selected by the user

//                this.model.setMaintainPositionItems(maintain_Position_Items);

//                this.model.setAllAlphanumericSorted(all_Alphanumeric_Sorted);

//                this.model.setAlphanumericSortedSearches(alphanumeric_Sorted_Searches);

                this.model.setStartBehavior(start_Behavior);

                this.model.setStartBehavior(search_Behavior);

                this.model.setCaseSensitive(case_Sensitive);

//                this.model.setShowAllItems(show_All_Items);

                this.onlyOneColor = only_One_Color;

                this.completeMatchedItem = complete_Matched_Item;

                this.beepEnabled = use_Beep;

                this.allowedRepeatedItems = allowed_Repeated_Items;

                if (!testFlagsConfigurationOK())

                        JOptionPane.showMessageDialog(this, PluginServices.getText(this, "errorMessageJComboBoxItemsSeekerConfigurable"), PluginServices.getText(this, "exportJOP2Title"), JOptionPane.ERROR_MESSAGE);

                else

                        this.configure();

        }

        /**

         * 

         */

        private void initialize() {

//                // Creates the ui for this component and gets it reference

//                super.setUI(new MetalComboBoxItemsSeekerUI());

//                this.ui = (MetalComboBoxItemsSeekerUI) super.getUI();

//                super.setUI(new MetalComboBoxItemsSeekerUI());

                // Creates the model for this component and gets it reference

                if (this.isAllowedRepeatedItems())

                {

                        super.setModel(new ComboBoxItemsSeekerConfigurableModel());

                        this.model = (ComboBoxItemsSeekerConfigurableModel) super.getModel();

                }

                else

                {

                        super.setModel(new ComboBoxSingularItemsSeekerConfigurableModel());

                        this.model = (ComboBoxSingularItemsSeekerConfigurableModel) super.getModel();

                }

        // Allows user to edit on the combobox

                super.setEditable(true);

                // By default the last state of showign items was showing all the items (at the beginning of this component)

                currentShowState = BEGINNING_VIEW_STATE;

                // Set the last selected item -> if there isn't any item -> -1; else -> this will be 0

                super.setSelectedIndex(-1);

                this.selectedItem = null;

//                logger.debug("selectedItem: " + this.getSelectedIndex());

                // By default the keys Up and Down aren't pressed

//                this.upOrDownKeyPressed = false;

                // By default the keys Delete aren't pressed

//                this.escapeKeyPressed = false;

                // By default any text key has been pressed

                textKeyPressed = false;

                allowedRepeatedItems = false;

                lastWasPressedAKeyModifier = false;

                // By default popup won't be visible when gained the focus the editor associated

                popupWillBeVisible = false;

                hitBackspace=false;

                optionsEditionByMouse = new JOptionsEditionByMousePopupMenu();

                optionsEditorWasVisible = false;

                undoManager = new UndoManager();

                undoRedoLimitActions = 10; // By default is 1

                undoManager.setLimit(undoRedoLimitActions);

//                // By default any key has been pressed

//                keyPressed = false;

//                specialKeys = false;

//                updatePopUp = false;

                // Remove the default mouse listener

//                super.removeMouseListener(super.getMouseListeners()[0]);

        }

        /**

         * 

         */

        private void createDefaultListeners() {

                // TODO Auto-generated method stub                

                this.defineEditionMenuPropertyChangeListener(this);

        // Define the key listener for the editor of this component

        this.defineEditorKeyListener(this);

        // Define the focus listener for the editor of this component

        this.defineEditorFocusListener(this);

        this.defineEditorMouseListener(this);

        // Define a document listener for changes of text

        this.defineDocumentListener();

                // Define the list data listener for the model of this component

        this.defineModelListDataListener();

        // Define a popup menu listener for the popup of this component

        this.definePopUpMenuListener(this);

        this.defineUndoAndRedoActions();

        }

        /**

         * 

         */

        private void defineUndoAndRedoActions() {

                // TODO Auto-generated method stub

                // Create an undo action

                undoAction = new AbstractAction("Undo") {

            public void actionPerformed(ActionEvent evt) {

                try {

                    if (undoManager.canUndo()) {

                            undoManager.undo();

                    }

                } catch (CannotUndoException e) {

                }

            }

       };

       // Create a redo action

       redoAction = new AbstractAction("Redo") {

           public void actionPerformed(ActionEvent evt) {

               try {

                   if (undoManager.canRedo()) {

                           undoManager.redo();

                   }

               } catch (CannotRedoException e) {

               }

           }

       };

        }

        private void defineEditionMenuPropertyChangeListener(JComboBoxItemsSeekerConfigurable combo_Box) {

                final JComboBoxItemsSeekerConfigurable comboBoxReference = combo_Box;

                editionMenuListener = new PropertyChangeListener() {

                        public void propertyChange(PropertyChangeEvent arg0) {

                                // TODO Auto-generated method stub

                                if (arg0.getPropertyName().equals(JOptionsEditionByMousePopupMenu.SELECTEDOPTION)) {

                            JTextComponent editor = (JTextComponent) comboBoxReference.getEditor().getEditorComponent();

                            logger.debug("PropertyChanged: " + arg0.getNewValue().toString());

                                  switch(Integer.parseInt(arg0.getNewValue().toString()))

                                  {//HACER!!

                                          case JOptionsEditionByMousePopupMenu.UNDO:

                                                  undoManager.undo();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.REDO:

                                                  undoManager.redo();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.CUT:

                                                  editor.cut();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.COPY:

                                                  editor.copy();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.PASTE:

                                                  editor.paste();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.DELETE:

                                                  deleteTextLogic(editor);

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.SELECT_ALL:

                                                  editor.selectAll();

                                                  break;

                                          default: // do anything

                                  }

                                }

                                else

                                {

                                        if (arg0.getPropertyName().equals(JOptionsEditionByMousePopupMenu.VISIBILITYCHANGED))

                                        {

                                                logger.debug("PropertyChanged: " + arg0.getNewValue().toString());

                                                // First True, after False (when false -> optionsEditorWasVisible = true)

                                                if (!optionsEditionByMouse.isVisible())

                                                        optionsEditorWasVisible = true;

                                                else

                                                        optionsEditorWasVisible = false;

                                        }

                                }

                        }                        

                };

        }

        /**

         *  Define a document listener for changes of text

         */

        private void defineDocumentListener() {

                // TODO Auto-generated method stub

               documentListener = new DocumentListener() {

                        public void changedUpdate(DocumentEvent arg0) {

                                // TODO Auto-generated method stub

                        }

                        public void insertUpdate(DocumentEvent arg0) {

                                // TODO Auto-generated method stub

                                logger.debug("NUM: " + num + " DocumentListener->insertUpdate");

                                try {

//                                        lastDocumentText = document.getText(0, document.getLength())

                                        logger.debug("Texto insertado: ->" + document.getText(0, document.getLength()) + "<-");

                                } catch (BadLocationException e) {

                                        // TODO Auto-generated catch block

                                        e.printStackTrace();

                                }

                                num++;                                

                                // Indicate to the model that now is disabled the start view

                                 // This is used for the first text inserted to the document when the component is loaded and it does setSelectedIndex(0), to avoid use a search view

                                if (currentShowState == BEGINNING_VIEW_STATE)

                                {

                                        currentShowState = START_VIEW_STATE;

                                        lastWasTheBeginningState = true;

                                        continueOnStartViewState = true;

                                        logger.debug("Pasa al estado 1 (de vista inicial)");

                                }        

                        }

                        public void removeUpdate(DocumentEvent arg0) {

                                // TODO Auto-generated method stub

                                logger.debug("NUM: " + num + " DocumentListener->removeUpdate");

                                num++;

                        }                        

                };

        }

        private void updateLastSelectionItem() {

                setSelectedItem(selectedItem);

        }

        /**

         * 

         */

        private void configure() {

                // TODO Auto-generated method stub

                // Configure the document of the editor of this component

                this.configureDocument();

                // Configure the editor (ComboBoxEditor) of this component

                this.configureEditor(this.getEditor());        

                // Configure the model of this component

                this.configureModel();

                // Configure the popup of this component

                this.configurePopUp();

                // Configure the ...

                this.configureOptionsEditionByMouse();

        }

        private void configureOptionsEditionByMouse() {

                this.optionsEditionByMouse.addPropertyChangeListener(editionMenuListener);

//                optionsEditionByMouse.addPropertyChangeListener(OptionsEditionByMouse.PROPERTYNAME, editionMenuListener);

        }

        /**

         * 

         *

         */

        private void configurePopUp() {

                // TODO Auto-generated method stub

                this.addPopupMenuListener(this.popupMenuListener);

        }

//        /**

//         * 

//         */

//        private void uninstallDefaultListeners() {

//        

//

//        }

        /**

         * 

         */

        private void configureModel() {

                // TODO Auto-generated method stub

                this.model.addListDataListener(this.modelListDataListener);

        }        

        /**

         * 

         */

        private void configureDocument() {

                // TODO Auto-generated method stub

                // Creates the document of the editor of this component

        document = new PlainDocumentSeeker();

        document.setJComboBoxItemsSeekerDynamicReference(this);

                // Set the written String

//                writtenString = "";

                // Remove all Previous document Listeners

//                DocumentListener documentListener[] = document.getDocumentListeners();

//                for (int i=0; i < documentListener.length; i++)

//                        document.removeDocumentListener(documentListener[i]);

                // Defines and add a Document listener for changes on the document of the editor of this component

                document.addDocumentListener(this.documentListener);

        }

        /**

         * Define the list data listener for the model of this component

         */

    public void defineModelListDataListener() {

                this.modelListDataListener = new ListDataListener()        {

                        public void contentsChanged(ListDataEvent e) {

                                // TODO Auto-generated method stub

//                                logger.debug("ContentsChanged");

                                // This flag indicates to the 'insertString' and 'remove' methods of the PlainDocumentSeeker that the text of the item selected or written by the user

                                //  hasn't been written on the TextEditor of ths component

                                selecting = false;

                        }

                        public void intervalAdded(ListDataEvent e) {

                                // TODO Auto-generated method stub

        //                        logger.debug("intervalAdded");

                        }

                        public void intervalRemoved(ListDataEvent e) {

                                // TODO Auto-generated method stub

        //                        logger.debug("intervalRemoved");

                        }

                };

    }

        /**

         * ?Sobra? Contiene c?digo interesante

         */

        private void defineAndAddPropertyChangeListener() {

                // Define and add a Listener for changes on the editor or the model of the JComboBox

        super.addPropertyChangeListener(new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent ev) {

                if (ev.getPropertyName().equals("editor"))

                        configureEditor((ComboBoxEditor) ev.getNewValue());

                if (ev.getPropertyName().equals("model"))

                {

                        if (isAllowedRepeatedItems())

                                model = (ComboBoxItemsSeekerConfigurableModel) ev.getNewValue();

                        else

                                model = (ComboBoxSingularItemsSeekerConfigurableModel) ev.getNewValue();

                }

            }

        });

        }

        /**

         * (S? SE EST? USANDO)

         */

        private void defineEditorFocusListener(JComboBoxItemsSeekerConfigurable combo_Box) {

                final JComboBoxItemsSeekerConfigurable comboBoxReference = combo_Box;

//                 Bug 5100422 on Java 1.5: Editable JComboBox won't hide popup when tabbing out                

                hidePopupOnFocusLoss=System.getProperty("java.version").startsWith("1.5");

                // TODO Auto-generated method stub

                // Highlight whole text when gaining focus

                editorFocusListener = new FocusAdapter() {

                        public void focusGained(FocusEvent e) {

                                if (!optionsEditorWasVisible)

                                {

                                        highlightCompletedText(0);

                                        logger.debug("currentShowState: " + currentShowState);

                                        logger.debug("EDITOR FOCUS GAINED");

                                        // This is used when the component has lost the focus, the popup whas in show state and is restored the focus -> update the popup

                                        //if (() && (currentShowState != BEGINNING_VIEW_STATE))

                                        if (popupWillBeVisible)

                                        {

                                                logger.debug("UPDATE POPUP DESDE EL FOCUSGAINED");

                                                comboBoxReference.updatePopUpView();

                                        }

                                }

                        }

                        public void focusLost(FocusEvent e) {

                                logger.debug("EDITOR FOCUS LOST");

                                if (isPopupVisible())

                                        popupWillBeVisible = true;

                                else

                                        popupWillBeVisible = false;

                                // Workaround for Bug 5100422 - Hide Popup on focus loss

                                if (hidePopupOnFocusLoss) comboBoxReference.setPopupVisible(false);

                        }

                };

        }

        private void defineEditorMouseListener(JComboBoxItemsSeekerConfigurable combo_Box) {

                final JComboBoxItemsSeekerConfigurable comboBoxReference = combo_Box;

                editorMouseListener = new MouseAdapter() {

//                        public void mousePressed(MouseEvent e) {

//

//                    if (e.isPopupTrigger()) {

//                            logger.debug("MousePopupTrigered");

//                    }

//                        }

//                        

//                        public void mouseReleased(MouseEvent e) {

                        // Deber?a ser mouseRelease, pero en linux s?lo deja mousePressed

//                        public void mousePressed(MouseEvent e) {

                        public void mouseClicked(MouseEvent e) {

                                logger.debug("MOUSE-LISTENER : MOUSE-mouseClicked!" + e.getButton());

                                logger.debug("MOUSE-LISTENER : MOUSE-mouseClicked!" +e.isPopupTrigger());

//                    if (e.isPopupTrigger()) { // Esta l?nea funciona de distinta manera en linux ue en windows, en linux va en mousePressed, y en windows va en mouseReleased

                                if (e.getButton() == MouseEvent.BUTTON3) {

                            JTextComponent editor = (JTextComponent) comboBoxReference.getEditor().getEditorComponent();

//                            editor.selectAll();

                            // By default disable all options

                            optionsEditionByMouse.setEnabledAllOptions(false);

                            // Habilitar las opciones disponibles (HACER!!)                    

                            // Enable the "Undo" option if there is any previous state to restore

                            if (undoManager.canUndo())

                                    optionsEditionByMouse.setEnabledUndoOption(true);

                            // Enable the "Redo" option if there is any later state to restore

                            if (undoManager.canRedo())

                                    optionsEditionByMouse.setEnabledRedoOption(true);

                            // Enable the "Copy", "Cut" and "Delete" options if there is text selected

                            if (editor.getCaretPosition() != editor.getCaret().getMark())

                            {

                                    optionsEditionByMouse.setEnabledCopyOption(true);

                                    optionsEditionByMouse.setEnabledCutOption(true);

                                    optionsEditionByMouse.setEnabledDeleteOption(true);

                            }

//                            Clipboard clipboard = getToolkit().getSystemClipboard();

//                        Transferable content = clipboard.getContents(this);

                            // Enable the "Paste" option if there is text on the system's clipboard

                            if ( getToolkit().getSystemClipboard().getContents(this).toString().length() > 0 )

                                    optionsEditionByMouse.setEnabledPasteOption(true);

                            // Enable the "Select-All" option (by default it's always enabled)

                            optionsEditionByMouse.setEnabledSelectAllOption(true);

                                        optionsEditionByMouse.setLocation((int)comboBoxReference.getLocationOnScreen().getX() + e.getX(), (int)comboBoxReference.getLocationOnScreen().getY() + e.getY());

                            optionsEditionByMouse.setInvoker(comboBoxReference);

                            optionsEditionByMouse.setVisible(true);

//                            optionsEditorWasVisible = true;

                    }

                }

                };

        }

        /**

         * 

         */

        private void defineEditorKeyListener(JComboBoxItemsSeekerConfigurable combo_Box) {

                final JComboBoxItemsSeekerConfigurable comboBoxReference = combo_Box;

//                keyPressed = true;

                // This flag indicates to the 'insertString' and 'remove' methods of the PlainDocumentSeeker that the text of the item selected or written by the user

                //  hasn't been written on the TextEditor of ths component

                // TODO Auto-generated method stub

                editorKeyListener = new KeyAdapter()

                {

//                        public void keyTyped(KeyEvent ke) {

//                                logger.debug("Tecla tecleada: ->" + ke.getKeyChar() + "<- ; Su keyCode es: " + ke.getKeyCode());

//                        }

                        public void keyPressed(KeyEvent ke)  // Executed on the Start view state or Search view state

                        {

                                // DISTINGUIR SI: s?lo tienen keyChar ? s?lo keyCode ? ambas!!!

                                logger.debug("Tecla apretada: ->" + ke.getKeyChar() + "<- ; Su keyCode es: " + ke.getKeyCode() + " TIPO: " + Character.getType(ke.getKeyChar()));

                                if (model.getParentSize() == 0)

                                {

                                        if (beepEnabled)

                                                comboBoxReference.getToolkit().beep(); // when available use: UIManager.getLookAndFeel().provideErrorFeedback(comboBox);

                                }

                                else

                                {                                                                

                                        // This flag indicates to the 'insertString' and 'remove' methods of the PlainDocumentSeeker that the text of the item selected or written by the user

                                        //  hasn't been written on the TextEditor of ths component

                                        selecting = false;

                                        // This resolves the bug when the popup wasn't seen any time and the uses press a key that updates the view of the popup (the bug is that popup has the items but

                                        //  aren't seen

                                        if (lastWasTheBeginningState)

                                        {

                                                // This maintains visible the popup

                                                if (comboBoxReference.isDisplayable())

                                                        comboBoxReference.setPopupVisible(true);

                                                lastWasTheBeginningState = false;

                                        }

                                        if (Character.isLetterOrDigit(ke.getKeyChar())) {

                                                logger.debug("IS LETTER OR DIGIT");

                                        }

                                        else

                                                logger.debug("ISN'T LETTER OR DIGIT");

//                                        hitBackspace=false;

                                        JTextComponent editor = (JTextComponent) comboBoxReference.getEditor().getEditorComponent();

//                                        if (ke.getKeyCode() == 0)

//                                        {

//                                                logger.debug("CASO -> KEYCHAR");

//                                                

//                                                switch (ke.getKeyChar())

//                                                {

//                                                        

//                                                }

//                                        }

//                                        else

//                                        {

//                                        logger.debug("CASO -> KEYCODE");

                                                switch (ke.getKeyCode())

                                                {

                                                        // determine if the pressed key is backspace (needed by the remove method)

                                                        case KeyEvent.VK_BACK_SPACE :

                                                                hitBackspace=true;

                                                                hitBackspaceOnSelection=editor.getSelectionStart()!=editor.getSelectionEnd();

                                                                break;

                                                        // ignore delete key

                                                        case KeyEvent.VK_DELETE : // supr key in spanish keyboard

                //                                                specialKeys = true;

        //                                                         This avoids that popup listener could report about it detected item (Este no va)

        //                                                        textKeyPressed = true; 

                                                                deleteTextLogic(editor);

//                                                                // Remove selected text:

//                                                                logger.debug("GETMARK: " + editor.getCaret().getMark() + "GETCARETPOSITION" + editor.getCaretPosition());

//        

//                                                                try {

//                                                                        // If no characters are selected

//                                                                        if (editor.getCaret().getMark() == editor.getCaretPosition())

//                                                                        {

//                                                                                // Remove the character which is on the right of the caret position

//                                                                                if (editor.getCaretPosition() < document.getLength())                                                                        

//                                                                                        document.remove(editor.getCaretPosition(), 1);                                                                                

//                                                                        }

//                                                                        else // If there are characters selected

//                                                                        {

//                                                                                // Remove the characters which are selected

//                //                                                                int documentLength = document.getLength();

//                                                                                int length = Math.abs(editor.getCaret().getMark() - editor.getCaretPosition());

//                                                                                

//                                                                                // Remove the characters which are selected

//                                                                                document.remove(Math.min(editor.getCaret().getMark(), editor.getCaretPosition()), length);

//                                                                        }

//                                                                } catch (BadLocationException e) {

//                                                                        // TODO Auto-generated catch block

//                                                                        e.printStackTrace();

//                                                                }

//                                                                

//                                                                switch(currentShowState)

//                                                                {

//                                                                        case START_VIEW_STATE :

//                                                                                if (document.getLength() > 0)

//                                                                                {                                                                                

//                                                                                        // If dynamic searches:

//                                                                                        try {

//                                                                                                // If the search will be dynamic:

//                                                                                                if (isDynamicSearchConfiguration())

//                                                                                                {

//                                                                                                        model.setWrittenText(document.getText(0, document.getLength()));

//                                                                                                        logger.debug("Texto que se le env?a al modelo desde SUPR: ->" + document.getText(0, document.getLength()) + "<-");                                                

//                                                                                                }

//                                                                                        } catch (BadLocationException e) {

//                                                                                                // TODO Auto-generated catch block

//                                                                                                e.printStackTrace();

//                                                                                        }                                                                        

//                                                                                

//                                                                                        // Indicate to the model that now is disabled the start view

//                                                                                        if (currentShowState == START_VIEW_STATE)

//                                                                                        {

//                                                                                                model.setStartViewFlag(false);

//                                                                                                currentShowState = SEARCH_VIEW_STATE;

//                                //                                                                updateLastSelectionItem();

//                                                                                        }

//                                                                                }

//                                                                                break;

//                                                                        case SEARCH_VIEW_STATE :

//                                                                                 // If there isn't characters

//                                                                                if (document.getLength() == 0)

//                                                                                {

//                                                                                        // This instruction avoids popup could failure when got invisible

//                                                                                        hidePopup();

//                                                                                        

//                                                                                        // If it's a dynamic search

//                                                                                        if (isDynamicSearchConfiguration())

//                                                                                        {

//                                                                                                model.setWrittenText("");

//                                                                                                logger.debug("Texto que se le env?a al modelo desde SUPR: ->\"\"<-");

//                                                                                        }

//                                                                                        

//                                                                                        // Return to the start view state

//                                                                                        model.setStartViewFlag(true);

//                                                                                        currentShowState = START_VIEW_STATE;

//        

//                                                                                        // Select the first Item 

//                                                                                        setSelectedIndex(0);

//        

//                                                                                        highlightCompletedText(0);

//                                                                                }

//                                                                                else

//                                                                                {

//                                                                                        // If dynamic searches:

//                                                                                        try {

//                                                                                                // If the search will be dynamic:

//                                                                                                if (isDynamicSearchConfiguration())

//                                                                                                {

//                                                                                                        model.setWrittenText(document.getText(0, document.getLength()));

//                                                                                                        logger.debug("Texto que se le env?a al modelo desde SUPR: ->" + document.getText(0, document.getLength()) + "<-");                                                

//                                                                                                }

//                                                                                        } catch (BadLocationException e) {

//                                                                                                // TODO Auto-generated catch block

//                                                                                                e.printStackTrace();

//                                                                                        }

//                                                                                }                                                                        

//                                                                                break;                                                                        

//                                                                }

//                                                                

//                                                                updatePopUpView();

                                                                break;

                                                        case KeyEvent.VK_ENTER :

                //                                                try {

                //                                                        specialKeys = true;

                                                                        logger.debug("ENTRA EN EL C?DIGO DE ENTER");

                                                                        // Reports about the written text to the model

                                                                try {

                                                                                // Reports about the written text to the model

                                                                                if (model.isDynamicSearch())

                                                                                        model.setWrittenText(document.getText(0, document.getLength()));

                                                                } catch (BadLocationException e1) {

                                                                        // TODO Auto-generated catch block

                                                                        e1.printStackTrace();

                                                                }

                                                                        // Indicate to the model that now is disabled the start view

                                                                        if (currentShowState == START_VIEW_STATE)

                                                                        {

                                                                                model.setStartViewFlag(false);

                                                                                currentShowState = SEARCH_VIEW_STATE;

                //                                                                updateLastSelectionItem();

                                                                        }

                //                                                        String text = document.getText(0, document.getLength());

                //                                                        document.remove(0, document.getLength());

                //                                                        document.insertString(0, text, null);

                //                                                        

                //                                                        

                //                                                        

                ////                                                        // If the text doesn't completely match with the selectedItem.toString() -> if allow 2 colors -> set foreground color to red

                ////                                                        if (!onlyOneColor)

                ////                                                        {

                ////                                                                if (model.isCaseSensitive())

                ////                                                                {

                ////                                                                        if (text.compareTo(getSelectedItem().toString()) != 0)

                ////                                                                                editor.setForeground(Color.RED);

                ////                                                                }

                ////                                                                else

                ////                                                                {

                ////                                                                        if (text.toUpperCase().compareTo(getSelectedItem().toString().toUpperCase()) != 0)

                ////                                                                                editor.setForeground(Color.RED);

                ////                                                                }

                ////                                                        }

                //                                                } catch (BadLocationException e1) {

                //                                                        // TODO Auto-generated catch block

                //                                                        e1.printStackTrace();

                //                                                }

                                                                hidePopup();

                                                                break;

                                                        case KeyEvent.VK_DOWN :

                                                            // If the key (typed, pressed and) released has been the Down Key -> when there isn't any text (item of the list) selected, select the first

                //                                                ke.consume();

                        //                                        selecting = true; // For indicate to the 'insertString' of the 'PlainDocumentSeeker' class that an item has been selected

                //                                                upOrDownKeyPressed = true;

                //                                                continueOnStartViewState = true;

                                                                // This allows user press the key DOWN for select another item of the start view list

                //                                                if ((model.isStartViewFlag()) && (lastWasStartShow))

                //                                                        lastWasStartShow = true;

                //                                                // Reports about the written text to the model                                                

                //                                                try {

                //                                                        if (model.isDynamicSearch())

                //                                                                model.setWrittenText(document.getText(0, document.getLength()));

                //                                                } catch (BadLocationException e2) {

                //                                                        // TODO Auto-generated catch block

                //                                                        e2.printStackTrace();

                //                                                }

                                                                // If items are disordered -> get the index of the selected item

                                                                if (model.nowItemsAreDisordered())

                                                                        updateLastSelectionItem();

                                                                if (getItemCount() > 0)

                                                                {

                                                                        if (getSelectedIndex() == (getItemCount()-1))

                                                                                ((JComboBox)comboBoxReference).setSelectedIndex(0);

                                                                        else

                                                                                ((JComboBox)comboBoxReference).setSelectedIndex(getSelectedIndex()+1);

                                                                }

                //                                                model.setCurrentString(getSelectedItem().toString());

                //                                                lastSelectedIndex = getSelectedIndex();

                                                                selectedItem = getSelectedItem();

                                                                showPopup();

                                                                break;

                                                        case KeyEvent.VK_UP :

                                                            // If the key (typed, pressed and) released has been the Up Key -> when there isn't any text (item of the list) selected, select the last

                //                                                ke.consume();

                        //                                        selecting = true; // For indicate to the 'insertString' of the 'PlainDocumentSeeker' class that an item has been selected

                //                                                upOrDownKeyPressed = true;

                //                                                continueOnStartViewState = true;

                                                                // This allows user press the key UP for select another item of the start view list

                //                                                if ((model.isStartViewFlag()) && (lastWasStartShow))

                //                                                        lastWasStartShow = true;

                //                                                // Reports about the written text to the model                                                

                //                                                try {

                //                                                        if (model.isDynamicSearch())

                //                                                                model.setWrittenText(document.getText(0, document.getLength()));

                //                                                } catch (BadLocationException e2) {

                //                                                        // TODO Auto-generated catch block

                //                                                        e2.printStackTrace();

                //                                                }

                                                                // If items are disordered -> get the index of the selected item

                                                                if (model.nowItemsAreDisordered())

                                                                        updateLastSelectionItem();

                                                                switch(getSelectedIndex())

                                                                {

                                                                        case -1: case 0:

                                                                                ((JComboBox)comboBoxReference).setSelectedIndex(getItemCount()-1);

                                                                                break;

                                                                        default:

                                                                                ((JComboBox)comboBoxReference).setSelectedIndex(getSelectedIndex()-1);

                                                                }

                //                                                model.setCurrentString(getSelectedItem().toString());

                                                                selectedItem = getSelectedItem();

                //                                                lastSelectedIndex = getSelectedIndex();

                                                                showPopup();

                                                                break;

                                                        case KeyEvent.VK_LEFT :                                                

                                                                // Move the caret to left

                                                                if (editor.getCaretPosition() > 0)

                                                                        editor.setCaretPosition(editor.getCaretPosition() - 1);

                                                                else

                                                                {

                                                        // User hit backspace with the cursor positioned on the start => beep

                                                            if (beepEnabled)

                                                                    getToolkit().beep(); // when available use: UIManager.getLookAndFeel().provideErrorFeedback(comboBox);

                                                                }

                                                                //ke.consume();

                                                                break;

                                                        case  KeyEvent.VK_RIGHT :

                                                                // Move the caret to right

                                                                try {

                                                                        if (editor.getCaretPosition() < (document.getText(0, document.getLength())).length())

                                                                                editor.setCaretPosition(editor.getCaretPosition() + 1);

                                                                        else

                                                                        {

                                                                            // User hit backspace with the cursor positioned on the start => beep

                                                                                if (beepEnabled)

                                                                                        getToolkit().beep(); // when available use: UIManager.getLookAndFeel().provideErrorFeedback(comboBox);

                                                                        }

                                                                } catch (BadLocationException e) {

                                                                        // TODO Auto-generated catch block

                                                                        e.printStackTrace();

                                                                }

                                                                //ke.consume();

                                                                break;

                                                        case  KeyEvent.VK_PAGE_DOWN :

                                                                if (getItemCount() > 0)

//                                                                if (getSelectedIndex() != -1)

                                                                {

                //                                                        // Reports about the written text to the model                                                

                //                                                        try {

                //                                                                if (model.isDynamicSearch())

                //                                                                        model.setWrittenText(document.getText(0, document.getLength()));

                //                                                        } catch (BadLocationException e2) {

                //                                                                // TODO Auto-generated catch block

                //                                                                e2.printStackTrace();

                //                                                        }

                                                                        int index;

                                                                        if (getSelectedIndex() == -1)

                                                                                index = 0;

                                                                        else

                                                                                index = getSelectedIndex() + POPUP_LIST_ITEMS_HEIGHT;

                                                                        if (index < getItemCount())

                                                                                setSelectedIndex(index);

                                                                        else

                                                                                setSelectedIndex(getItemCount()-1);

                                                                        selectedItem = getSelectedItem();

                                                                }

                                                        //        ke.consume();

                                                                break;

                                                        case KeyEvent.VK_PAGE_UP :

                                                                if (getItemCount() > 0)

//                                                                if (getSelectedIndex() != -1)

                                                                {

                //                                                        // Reports about the written text to the model                                                

                //                                                        try {

                //                                                                if (model.isDynamicSearch())

                //                                                                        model.setWrittenText(document.getText(0, document.getLength()));

                //                                                        } catch (BadLocationException e2) {

                //                                                                // TODO Auto-generated catch block

                //                                                                e2.printStackTrace();

                //                                                        }

                                                                        int index;

                                                                        if (getSelectedIndex() == -1)

                                                                                index = getItemCount() - 1;

                                                                        else

                                                                                index = getSelectedIndex() - POPUP_LIST_ITEMS_HEIGHT;

                                                                        if (index > -1)

                                                                                setSelectedIndex(index);

                                                                        else

                                                                                setSelectedIndex(0);

                                                                        selectedItem = getSelectedItem();

                                                                }

                                                        //        ke.consume();

                                                                break;

                                                        case KeyEvent.VK_HOME : // 'Inicio' key on the spanish keyboard

                                                                editor.setCaretPosition(0);

                                                                break;

                                                        case KeyEvent.VK_END :  // 'Fin' key on the spanish keyboard

                                                                editor.setCaretPosition(document.getLength());

                                                                break;

                                                        case KeyEvent.VK_TAB :

                //                                                specialKeys = true;

                                                                // This avoids that popup listener could report about it detected item

                                                                textKeyPressed = true;

                                                                if (model.getSize() > 0)

                                                                {

                //                                                        logger.debug("SelectedIndex: " + getSelectedIndex());

                //                                                        boolean update = false;

                                                                        if (((JComboBox)comboBoxReference).getSelectedIndex() == -1)

                                                                        {

                //                                                                lastSelectedIndex = 0;

                //                                                                ((JComboBox)comboBoxReference).setSelectedIndex(0);

                                                                                //updatePopUp = true; // Indicate to the document.insertString that has update the popup after insert

                //                                                                updatePopUpView();

                //                                                                comboBoxReference.setSelectedIndex(0);

                                                                                selectedItem = comboBoxReference.getItemAt(0); //.getSelectedItem();

                                                                        }

                                                                        else

                                                                        {

                //                                                                lastSelectedIndex = getSelectedIndex();

                //                                                                updatePopUp = true; // Indicate to the document.insertString that has update the popup after insert

                //                                                                updatePopUpView();

                                                                                selectedItem = comboBoxReference.getSelectedItem();

                //                                                                setSelectedIndex());        // Complete the item string value in the document of the editor

                //                                                                update = true;

                                                                        }

                                                                        document.setText(selectedItem.toString());

                                                                        // Reports about the written text to the model                                                

        //                                                                try {

                                                                        if (model.isDynamicSearch()) {

                                                                                model.setWrittenText(selectedItem.toString());

                                                                                logger.debug("Texto que se le env?a al modelo: ->" + selectedItem.toString() + "<-");

                                                                        }                

        //                                                                } catch (BadLocationException e2) {

        //                                                                        // TODO Auto-generated catch block

        //                                                                        e2.printStackTrace();

        //                                                                }

        //                                                                

                                                                        if (currentShowState == START_VIEW_STATE)

                                                                        {

                                                                                model.setStartViewFlag(false);

                                                                                currentShowState = SEARCH_VIEW_STATE;

                //                                                                updatePopUpView(); // Update to the new popup view

                                                                        }

                                                                        // It's supposed that the text on the document is equal as the string value of the selected item -> then text must be on black color

                                                                        comboBoxReference.getEditor().getEditorComponent().setForeground(Color.BLACK);

                                                                        updatePopUpView();

                //                                                        document.setText(selectedItem.toString());

                //                                                        continueOnStartViewState = false;

                                                                        // HidePopUp + ShowPopUp to force update the popup list of items

                //                                                        hidePopup();

                //                                                        showPopup();

                ////                                                        hidePopup();

                                                                }

                                                                break;

                                                        case KeyEvent.VK_ESCAPE :

                                                                // Reset to the Start View State

                //                                                model.setStartViewFlag(true);

                                                                // Force update the popup

                                                                if (isPopupVisible())

                                                                        hidePopup();

                                                                model.setWrittenText("");

                                                                selectedItem = null;

                //                                                currentShowState = START_VIEW_STATE;

                                                                if (currentShowState == SEARCH_VIEW_STATE)

                                                                {        

                                                                        try {

                                                                                document.remove(0, document.getLength());

                                                                        } catch (BadLocationException e) {

                                                                                // TODO Auto-generated catch block

                                                                                e.printStackTrace();

                                                                        }

                //                                                        setSelectedItem(selectedItem);

                //                                                        setSelectedIndex(model.getIndexOf(selectedItem));

                                                                        // Return to the start view state

                                                                        model.setStartViewFlag(true);

                                                                        currentShowState = START_VIEW_STATE;

                        //                                                escapeKeyPressed = true;

                //                                                        continueOnStartViewState = true;

                                                                        // If items are disordered -> get the index of the selected item

                //                                                        if (model.nowItemsAreDisordered())

                //                                                                updateLastSelectionItem();

                                                                        // Select the first Item