Application: gvSIG desktop

package org.gvsig.gui.beans.comboBoxItemsSeeker;

import java.awt.Color;

import java.awt.event.ActionEvent;

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.MouseWheelEvent;

import java.awt.event.MouseWheelListener;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import javax.swing.ComboBoxEditor;

import javax.swing.ComboBoxModel;

import javax.swing.JComboBox;

import javax.swing.JOptionPane;

import javax.swing.event.CaretListener;

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.CannotRedoException;

import javax.swing.undo.CannotUndoException;

import javax.swing.undo.UndoManager;

import org.apache.log4j.Logger;

import org.gvsig.gui.beans.Messages;

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

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

 */

/** ?? EN DESARROLLO !!

 * A component that is a modification of JComboBox, of which inherits.

 * This component allows:

 *    - To show item/s that the start of their string value matches with the text written in the editable field

 *    - To be configured it's behavior.

 *

 * This component has been done according the MVC (Model-View-Control) pattern, and is a 'Bean'.

 *

 * There are 11 configuration flags/attributes: 3 for the Model and the others for the Control and/or View.

 *    ? Model flags/attributes (for more information see the 'AbstractDefaultComboBoxItemsSeekerConfigurableModel' class documentation):

 *         - Start Behavior -> Configure how return items at beginning (always returns all items).

 *         - Search Behavior -> Configure how return items when it's searching an item.

 *         - Case Sensitive -> Discriminates capital letters from small letters or not when seeks items

 *    ? Control and/or View flags (all flags can be 'true' or 'false'):

 *         - Only One Color On Text:

 *                     + true -> always uses black color on text

 *              + false -> by default uses black color on text, but if text written by user doesn't match with any item, text will be on red color

 *         - Complete Matched Item:

 *                     + true -> When user writes, shows also the rest of the current matched item that user hasn't written.

 *                      + false -> Only shows the text written by the user when user is writting.

 *         - Beep Enabled:

 *              + true -> a beep-sound is listened when no item matches with the text written.

 *              + false -> no sound is listened.

 *         - Allowed Mouse Edition Popup Menu:

 *                     + true -> a 'PopupMenu' for text edition that appears when the user clicks on the text-edition-field with the right

 *                           button of the mouse.

 *              + false -> that 'PopupMenu' won't appear.

 *         - To Force To Only Coincidences In The Search:

 *                     + true -> If the user has written some text that doesn't mach with any item, and press the 'Enter' key for close the popup the user will

 *                           see written in the text-edition-field the last item which matched with the text written, or the first item of the model if

 *                           there wasn't.

 *              + false -> If no item matches with the text written and the user presses the 'Enter' key, no item will be selected.

 *         - Use Highlight:

 *              + true -> marks characters of the text in the text-edition-field with a highlight.

 *              + false -> doesn't do that.

 *         - Select An Item When Loses Focus:

 *              + true -> If user or an application makes component lose its focus, an item will be selected.

 *              + false -> If user or an application makes component lose its focus, the component will stay as it was

 *    . Control and Model flag (can be 'true' or 'false'):

 *         - Allowed Repeated Items -> Uses one of the two models according the value of this flag:

 *              + true -> Uses 'ComboBoxItemsSeekerConfigurableModel' as model (this could work slowly).

 *              + false -> Uses 'ComboBoxSingularItemsSeekerConfigurableModel' as model.

 *

 * By default the configuration is:

 *     - Start_Behavior = MAINTAIN_ORIGINAL_POSITION_START

 *     - Search_Behavior = ORDERED_DYNAMIC_SEARCH

 *     - Case_Sensitive = false

 *     - Only_One_Color_On_Text = false

 *     - Complete_Matched_Item = true

 *     - Beep_Enabled = true

 *     - Allowed_Repeated_Items = false

 *     - Allowed_Mouse_Edition_Popup_Menu = true

 *     - To_Force_To_Only_Coincidences_In_The_Search = true

 *     - Use_Highlight = true

 *     - Select_An_Item_When_Loses_Focus = false

 *

 * Other functionality:

 *     - Similar functionality as JComboBox:

 *         + Select an item from the inner popup using the mouse

 *         + Show item/items that match in the inner popup

 *         + Similar edition operations: Right, left, ...

 *         + ...

 *     - With the keyboard the user can do the same operations as with the "edition popup menu" :

 *         CTRL + A -> Select all text

 *         CTRL + Z -> Undo

 *         CTRL + SHIFT + Z -> Redo

 *         CTRL + C -> Copy selected text

 *         CTRL + X -> Cut selected text

 *         CTRL + V -> Paste on selected text/position

 *         DELETE (SUPR in Spanish Keyboard) -> Remove selected text

 *     - ESC key -> Sets the component to its initial state (that user can estimate)

 *

 * Special-Warning characteristics

 *     - In same inherit states the view could don't match with the model (this states aren't final states)

 *

 * Limitations:

 *     - Items of the model of this component must have a "string" value returned by "toString()" method

 *     - If the model of the component has lot of items, this could work slowly.

 *     - If the model has repeated items -> set true the flag 'allowedRepeatedItems', this will use the 'ComboBoxItemsSeekerConfigurableModel' model,

 *         and will work more slowly than the 'ComboBoxSingularItemsSeekerConfigurableModel' model; more as more items had the model.

 *     - It's possible that some combination of configuration would be unmanageable.

 *     - It's possible that some configuration or some operation fail !!

 *

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

 */

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

        private static final long serialVersionUID = 6581895116338237598L;

        // CONSTANTS FOR THE CURRENT STATE OF THE COMPONENT

        private final int BEGINNING_VIEW_STATE = 0;

        private final int START_VIEW_STATE = 1;

        private final int SEARCH_VIEW_STATE = 2;

        // END CONSTANTS FOR THE CURRENT STATE OF THE COMPONENT

        // ATTRIBUTE FOR THE CURRENT STATE

        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

        // END ATTRIBUTE FOR THE CURRENT STATE

        // CONSTANTS FOR CONFIGURE THE BEHAVIOR

        public static final boolean DEFAULT_ONLY_ONE_COLOR_ON_TEXT_CONFIGURATION = false;

        public static final boolean DEFAULT_COMPLETE_MATCHED_ITEM_CONFIGURATION = true;

        public static final boolean DEFAULT_BEEP_ENABLED_CONFIGURATION = true;

        public static final boolean DEFAULT_ALLOWED_REPEATED_ITEMS_CONFIGURATION = false;

        public static final boolean DEFAULT_ALLOWED_MOUSE_EDITION_POPUP_MENU_CONFIGURATION = true;

        public static final boolean DEFAULT_TO_FORCE_TO_ONLY_COINCIDENCES_IN_THE_SEARCH_CONFIGURATION = true;

        public static final boolean DEFAULT_USE_HIGHLIGHT_CONFIGURATION = true;

        public static final boolean DEFAULT_SELECT_AN_ITEM_WHEN_LOSES_FOCUS_CONFIGURATION = false;

        // END CONSTANTS FOR CONFIGURE THE BEHAVIOR

        // CONFIGURATION FLAGS

        private boolean onlyOneColorOnText_Flag;

        private boolean completeMatchedItem_Flag;

        private boolean beepEnabled_Flag;

        private boolean allowedRepeatedItems_Flag;

        private boolean allowedMouseEditionPopupMenu_Flag;

        private boolean toForceToOnlyCoincidencesInTheSearch_Flag;

        private boolean useHighlight_Flag;

        private boolean selectAnItemWhenLosesFocus_Flag;

        // END FLAGS

        // STORE THE SELECTED ITEM AND THE LAST SELECTED ITEM

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

    // END STORE THE SELECTED ITEM AND THE LAST SELECTED ITEM

        private int num = 0; //sobra -> se usan en el log -> ?? SE PUEDE BORRAR !!

        // NUMBER OF ITEMS SHOWED AT THE SAME TIME IN THE POPUP

        private final int POPUP_LIST_ITEMS_HEIGHT = 8;

    // END NUMBER OF ITEMS SHOWED AT THE SAME TIME IN THE POPUP

        // MODEL REFERENCE

        private AbstractDefaultComboBoxItemsSeekerConfigurableModel model;

        // END MODEL REFERENCE

        // LISTENERS

        private KeyListener editorKeyListener;

        private MouseAdapter editorMouseListener;

        private MouseWheelListener editorMouseWheelListener;

        private FocusListener editorFocusListener;

        private DocumentListener documentListener;

        private ListDataListener modelListDataListener;

        private PopupMenuListener popupMenuListener;

        private PropertyChangeListener editionMenuListener;

        private CaretListener caretListener;

        // END LISTENERS

        // EDITOR DOCUMENT REFERENCE

        private PlainDocumentTextFormatter document;

        // END EDITOR DOCUMENT REFERENCE

        // OTHER FLAGS

        private boolean allowInsertString;

        private boolean lastWasTheBeginningState;

        private boolean lastWasPressedAKeyModifier;

        private boolean popupWillBeVisible;

        private boolean optionsEditorWasVisible;

        private boolean selecting;

        private boolean hidePopupOnFocusLoss;

        private boolean hitBackspace;

        private boolean hitBackspaceOnSelection;

        private boolean addUndoableEditEvent;

        private boolean firstTimeItGainsFocusWithData;

        private boolean specialSelectionByUserState; // In this state it's possible that model couldn't match with view (the selected item)

        private boolean cutOperationDone;

        private boolean itemSelectedByMouse;

        // OTHER FLAGS

        // TRACE - DEBUG

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

        // END TRACE - DEBUG

        // A POPUPMENU FOR EDITION OPTIONS

        private JOptionsEditionByMousePopupMenu optionsEditionByMouse;

    // END A POPUPMENU FOR EDITION OPTIONS

        // UNDO-REDO

        private UndoManager undoManager;

        private int undoRedoLimitActions;

        // END UNDO-REDO

        /**

         * Default Constructor without parameters

         */

        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.setDefaultBehaviorFlagsConfiguration();

                // Other configuration tasks

                this.createDefaultListeners();

                this.configure();

        }

        /**

         * Default Constructor with 3 parameters: for the behavior of the Model

         *

         * @param 'start_Behavior' Start behavior of the Model.

         * @param 'search_Behavior' Search behavior of the Model.

         * @param 'case_Sensitive' Case sensitive behavior of the Model.

         */

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

                // Invokes to the parent class constructor

                super();

                // Set the default values of the flags

                this.setDefaultBehaviorFlagsConfiguration();

                // Create attributes and set initial values

                this.initialize();

                // Sets the options selected by the user

                this.model.setStartBehavior(start_Behavior);

                this.model.setStartBehavior(search_Behavior);

                this.model.setCaseSensitive_Flag(case_Sensitive);

                if (!testFlagsConfigurationOK())

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

                else

                {

                        // Other configuration tasks

                        this.createDefaultListeners();

                        this.configure();

                }

        }

        /**

          * Default Constructor with 11 parameters

         *

         * @param 'start_Behavior', Start behavior of the Model.

         * @param 'search_Behavior', Search behavior of the Model.

         * @param 'case_Sensitive', Case sensitive behavior of the Model.

         * @param 'only_One_Color_On_Text', Text color, behavior of the Control/View.

         * @param 'complete_Matched_Item', Complete matched item, behavior of the Control/View.

         * @param 'use_Beep Use beep', behavior of the Control.

         * @param 'allowed_Repeated_Items', Allowed repeated items, behavior of the Control/Model.

         * @param 'allowed_Mouse_Edition_Popup_Menu', Allowed mouse edition popupmenu, behavior of the Control/View.

         * @param 'to_Force_To_Only_Coincidences_In_The_Search', To force to only coincidences in the search, behavior of the Control/View.

         * @param 'use_Highlight', Use highlight behavior of the Control/View.

         * @param 'select_An_Item_When_Loses_Focus', behavior of the Control/View

         */

        public JComboBoxItemsSeekerConfigurable(int start_Behavior, int search_Behavior, boolean case_Sensitive, boolean only_One_Color_On_Text, boolean complete_Matched_Item, boolean use_Beep, boolean allowed_Repeated_Items, boolean allowed_Mouse_Edition_Popup_Menu, boolean to_Force_To_Only_Coincidences_In_The_Search, boolean use_Highlight, boolean select_An_Item_When_Loses_Focus_Flag) {

                // Invokes to the parent class constructor

                super();

                this.onlyOneColorOnText_Flag = only_One_Color_On_Text;

                this.completeMatchedItem_Flag = complete_Matched_Item;

                this.beepEnabled_Flag = use_Beep;

                this.allowedRepeatedItems_Flag = allowed_Repeated_Items;

                this.allowedMouseEditionPopupMenu_Flag = allowed_Mouse_Edition_Popup_Menu;

                this.toForceToOnlyCoincidencesInTheSearch_Flag = to_Force_To_Only_Coincidences_In_The_Search;

                this.useHighlight_Flag = use_Highlight;

                this.selectAnItemWhenLosesFocus_Flag = select_An_Item_When_Loses_Focus_Flag;

                // Create attributes and set initial values

                this.initialize();

                // Sets the options selected by the user

                this.model.setStartBehavior(start_Behavior);

                this.model.setSearchBehavior(search_Behavior);

                this.model.setCaseSensitive_Flag(case_Sensitive);

                if (!testFlagsConfigurationOK())

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

                else

                {

                        // Other configuration tasks

                        this.createDefaultListeners();

                        this.configure();

                }

        }

        /**

         *  Sets the default values of the flags

         */

        private void setDefaultBehaviorFlagsConfiguration() {

                this.onlyOneColorOnText_Flag = DEFAULT_ONLY_ONE_COLOR_ON_TEXT_CONFIGURATION;

                this.completeMatchedItem_Flag = DEFAULT_COMPLETE_MATCHED_ITEM_CONFIGURATION;

                this.beepEnabled_Flag = DEFAULT_BEEP_ENABLED_CONFIGURATION;

                this.allowedRepeatedItems_Flag = DEFAULT_ALLOWED_REPEATED_ITEMS_CONFIGURATION;

                this.allowedMouseEditionPopupMenu_Flag = DEFAULT_ALLOWED_MOUSE_EDITION_POPUP_MENU_CONFIGURATION;

                this.toForceToOnlyCoincidencesInTheSearch_Flag = DEFAULT_TO_FORCE_TO_ONLY_COINCIDENCES_IN_THE_SEARCH_CONFIGURATION;

                this.useHighlight_Flag = DEFAULT_USE_HIGHLIGHT_CONFIGURATION;

                this.selectAnItemWhenLosesFocus_Flag = DEFAULT_SELECT_AN_ITEM_WHEN_LOSES_FOCUS_CONFIGURATION;

        }

        /**

         * This method sets the start values of inner attributes and creates the necessary inner objects

         */

        private void initialize() {

                // Attributes for highlight selection

                selecting = false;

                hitBackspace = false;

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

                if (this.allowedRepeatedItems_Flag)

                {

                        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);

                // By default any text key has been pressed

                allowInsertString = false;

                // Attribute for allow composed characters: examples: ?, ?, ?

                lastWasPressedAKeyModifier = false;

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

                popupWillBeVisible = false;

                // Text options edition popupmenu initialization

                optionsEditionByMouse = new JOptionsEditionByMousePopupMenu();

                optionsEditorWasVisible = false;

                // Undo-Redo initialization

                addUndoableEditEvent = false; // By default don't add undoable edit events

                undoManager = new UndoManager();

                undoRedoLimitActions = 10; // By default is 1

                undoManager.setLimit(undoRedoLimitActions);

                // By default this flag will be 'true'

                firstTimeItGainsFocusWithData = true;

                // By default this component won't be in the "SpecialSelectionByUser" state

                specialSelectionByUserState = false;

                // By default no 'cut' operation has been done

                cutOperationDone = false;

                // By default no item items has been selected by mouse

                itemSelectedByMouse = false;

        }

        /**

         * Creation of default listeneres that will use the component

         */

        private void createDefaultListeners() {

                // Defines a listener for the PopupMenu of text edition options: when a change is produced in that component, it fires an event

                //   and this listener captures it

                this.defineEditionMenuPropertyChangeListener(this);

        // Defines a key listener for the editor of this component

        this.defineEditorKeyListener(this);

        // Defines a focus listener for the editor of this component

        this.defineEditorFocusListener(this);

        // Defines a mouse listener for the editor of this component

        this.defineEditorMouseListener(this);

        // Defines a mouse wheel listener for the editor of this component

        this.defineEditorMouseWheelListener();

        // Defines a document listener for changes of text

        this.defineDocumentListener();

                // Defines a list data listener for the model of this component

        this.defineModelListDataListener();

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

        this.definePopUpMenuListener();

        }

        /**

         * Defines a listener for the PopupMenu of text edition options: when a change is produced in that component, it fires an event

         *    and this listener captures and treats it

         *

         * @param combo_Box A reference of this component

         */

        private void defineEditionMenuPropertyChangeListener(JComboBoxItemsSeekerConfigurable combo_Box) {

                final JComboBoxItemsSeekerConfigurable comboBoxReference = combo_Box;

                editionMenuListener = new PropertyChangeListener() {

                        /*

                         * (non-Javadoc)

                         * @see java.beans.PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent)

                         */

                        public void propertyChange(PropertyChangeEvent arg0) {

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

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

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

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

                                  {

                                          case JOptionsEditionByMousePopupMenu.UNDO:

                                                  undoOperationLogic();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.REDO:

                                                  redoOperationLogic();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.CUT:

                                                  editor.cut();

                                                  cutOperationDone = true;

                                                  deleteTextLogic(editor, false);

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.COPY:

                                                  editor.copy();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.PASTE:

                                                  editor.paste();

                                                  try {

                                                          String newPattern = document.getText(0, document.getLength());

                                                          model.setWrittenText(newPattern);

                                                          updatePopUpView();

                                                  } catch (BadLocationException e) {

                                                          e.printStackTrace();

                                                  }

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.DELETE:

                                                  deleteTextLogic(editor, false);

                                                  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;

                                        }

                                }

                        }

                };

        }

        /**

         *  Defines a document listener for changes of text

         */

        private void defineDocumentListener() {

       documentListener = new DocumentListener() {

               /*

                * (non-Javadoc)

                * @see javax.swing.event.DocumentListener#changedUpdate(javax.swing.event.DocumentEvent)

                */

               public void changedUpdate(DocumentEvent arg0) {

               }

               /*

                * (non-Javadoc)

                * @see javax.swing.event.DocumentListener#insertUpdate(javax.swing.event.DocumentEvent)

                */

               public void insertUpdate(DocumentEvent arg0) {

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

                       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;

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

                       }

               }

               /*

                * (non-Javadoc)

                * @see javax.swing.event.DocumentListener#removeUpdate(javax.swing.event.DocumentEvent)

                */

               public void removeUpdate(DocumentEvent arg0) {

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

                       num++;

               }

       };

        }

        /**

         * Defines a list data listener for the model of this component

         */

        private void defineModelListDataListener() {

                this.modelListDataListener = new ListDataListener()        {

                        /*

                         * (non-Javadoc)

                         * @see javax.swing.event.ListDataListener#contentsChanged(javax.swing.event.ListDataEvent)

                         */

                        public void contentsChanged(ListDataEvent e) {

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

                        }

                        /*

                         * (non-Javadoc)

                         * @see javax.swing.event.ListDataListener#intervalAdded(javax.swing.event.ListDataEvent)

                         */

                        public void intervalAdded(ListDataEvent e) {

                        }

                        /*

                         * (non-Javadoc)

                         * @see javax.swing.event.ListDataListener#intervalRemoved(javax.swing.event.ListDataEvent)

                         */

                        public void intervalRemoved(ListDataEvent e) {

                        }

                };

    }

        /**

         * Defines and add a property change listener for this component (AT MOMENT NOT USED!!)

         */

        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_Flag())

                                model = (ComboBoxItemsSeekerConfigurableModel) ev.getNewValue();

                        else

                                model = (ComboBoxSingularItemsSeekerConfigurableModel) ev.getNewValue();

                }

            }

        });

        }

        /**

         * Defines a focus listener for the editor of this component

         *

         * @param combo_Box A reference of this component

         */

        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");

                // Highlight whole text when gaining focus

                editorFocusListener = new FocusAdapter() {

                        /*

                         * (non-Javadoc)

                         * @see java.awt.event.FocusAdapter#focusGained(java.awt.event.FocusEvent)

                         */

                        public void focusGained(FocusEvent e) {

                                if (!optionsEditorWasVisible)

                                {

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

                                        logger.debug("EDITOR FOCUS GAINED");

                                        // This is used for set the text value of the first item added highlighted the first time the component gets the focus

                                        if (firstTimeItGainsFocusWithData) {

                                                if (model.getSize() > 0) {

                                                        if (useHighlight_Flag)

                                                                document.highlightCompletedText(0);

                                                        firstTimeItGainsFocusWithData = false;

                                                }

                                        }

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

                                        if (popupWillBeVisible)

                                        {

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

                                                comboBoxReference.updatePopUpView();

                                        }

                                }

                        }

                        /*

                         * (non-Javadoc)

                         * @see java.awt.event.FocusAdapter#focusLost(java.awt.event.FocusEvent)

                         */

                        public void focusLost(FocusEvent e) {

                                logger.debug("EDITOR FOCUS LOST");

                                // If it has to select an item always it loses its focus:

                                if (selectAnItemWhenLosesFocus_Flag) {

                                        // Similar code as the ENTER key code

                                        if (getSelectedItem() == null)

                                                logger.debug("SELECTED ITEM: NULL");

                                        else

                                                logger.debug("SELECTED ITEM: " + getSelectedItem().toString());

                                        try {

                                                String newText = "";

                                                Object moreSimilarItemToLastWrittenText = model.getMoreSimilarItemToLastWrittenText();

                                                // If the last item selected was null -> select the first

                                                if (moreSimilarItemToLastWrittenText == null) {

                                                        setSelectedItem(model.getParentElementAt(0));

                                                }

                                                else {

                                                        if (specialSelectionByUserState) {

                                                                setSelectedItem(model.getSelectedItem());

                                                        }

                                                        else {

                                                                // Else -> select the last

                                                                setSelectedItem(moreSimilarItemToLastWrittenText);

                                                        }

                                                }

                                                newText = getSelectedItem().toString();

                                                // Reports about the written text to the model

                                            if (model.isDynamicSearch())

                                                    model.setWrittenText(newText);

                                                specialSelectionByUserState = false;

                                                document.replace(0, document.getLength(), newText, null);

                                        }

                                        catch (BadLocationException e1) {

                                            e1.printStackTrace();

                                    }

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

//                                        if (currentShowState == START_VIEW_STATE)

//                                        {

//                                                model.setStartStateFlag(false);

//                                                currentShowState = SEARCH_VIEW_STATE;

//                                        }

                                        hidePopup();

                                        // Sets the caret position of the text in the document to the end:

                                        ((JTextComponent) comboBoxReference.getEditor().getEditorComponent()).setCaretPosition(document.getLength());

                                }

                                else { // Else -> Default bevabior

                                        if (isPopupVisible())

                                                popupWillBeVisible = true;

                                        else

                                                popupWillBeVisible = false;

                                }

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

                                if (hidePopupOnFocusLoss)

                                        comboBoxReference.setPopupVisible(false);

                        }

                };

        }

        /**

         * Defines a mouse listener for the editor of this component

         *

         * @param combo_Box A reference of this component

         */

        private void defineEditorMouseListener(JComboBoxItemsSeekerConfigurable combo_Box) {

                final JComboBoxItemsSeekerConfigurable comboBoxReference = combo_Box;

                editorMouseListener = new MouseAdapter() {

                        /*

                         * (non-Javadoc)

                         * @see java.awt.event.MouseAdapter#mouseClicked(java.awt.event.MouseEvent)

                         */

                        public void mouseClicked(MouseEvent e) {

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

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

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

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

                            // By default disable all options

                            optionsEditionByMouse.setEnabledAllOptions(false);

                            // 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);

                            }

                            // 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);

                    }

                }

                };

        }

        /**

         * Defines a mouse wheel listener for the editor of this component

         */

        private void defineEditorMouseWheelListener() {

                editorMouseWheelListener = new MouseWheelListener() {

                        /*

                         * (non-Javadoc)

                         * @see java.awt.event.MouseWheelListener#mouseWheelMoved(java.awt.event.MouseWheelEvent)

                         */

                        public void mouseWheelMoved(MouseWheelEvent e) {

                                specialSelectionByUserState = true;

                        if (e.getWheelRotation() < 0)

                                selectItemUp();

                        else

                                selectItemDown();

                        }

                };

        }

        /**

         * Defines a key listener for the editor of this component

         * This method is another important difference from the JComboBox; and could work badly with some keymaps

         *

         * @param combo_Box A reference of this component

         */

        private void defineEditorKeyListener(JComboBoxItemsSeekerConfigurable combo_Box) {

                final JComboBoxItemsSeekerConfigurable comboBoxReference = combo_Box;

                editorKeyListener = new KeyAdapter() {

                        /*

                         * (non-Javadoc)

                         * @see java.awt.event.KeyAdapter#keyPressed(java.awt.event.KeyEvent)

                         */

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

                        {

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

                                if (model.getParentSize() == 0)

                                {

                                        if (beepEnabled_Flag)

                                                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");

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

                                        // COPY, CUT, PASTE, SELECT ALL, UNDO AND REDO WITH THE KEYBOARD (Combination of keys; REMOVE is implemented after: KV_DELETE (supr spanish key))

                                        if (ke.isControlDown())

                                        {

                                                // COPY

                                            if (ke.getKeyCode() == KeyEvent.VK_C) {

                                                editor.copy();

                                                    return;

                                            }

                                            // CUT

                                            if (ke.getKeyCode() == KeyEvent.VK_X) {

                                                      editor.cut();

                                                  cutOperationDone = true;

                                                  deleteTextLogic(editor, false);

                                                    return;

                                            }

                                            // PASTE

                                            if (ke.getKeyCode() == KeyEvent.VK_V) {

                                                    editor.paste();

                                          try {

                                                  String newPattern = document.getText(0, document.getLength());

                                                  model.setWrittenText(newPattern);

                                                  updatePopUpView();

                                          } catch (BadLocationException e) {

                                                  e.printStackTrace();

                                          }

                                                    return;

                                            }

                                            // SELECT ALL

                                            if (ke.getKeyCode() == KeyEvent.VK_A) {

                                                    editor.selectAll();

                                                    return;

                                            }

                                            // UNDO OR REDO

                                            if (ke.getKeyCode() == KeyEvent.VK_Z) {

                                                    if (ke.isShiftDown()) // REDO

                                                            redoOperationLogic();

                                                    else //UNDO

                                                            undoOperationLogic();

                                                    return;

                                             }

                                        }

                                        // According the key pressed, do some actions or others

                                        switch (ke.getKeyCode())

                                        {

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

                                                case KeyEvent.VK_BACK_SPACE :

                                                                 if (useHighlight_Flag)

                                                                {

                                                                         hitBackspace = true;

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

                                                                }

                                                                 else

                                                                         deleteTextLogic(editor, true);

                                                        break;

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

                                                                specialSelectionByUserState = true;

                                                        deleteTextLogic(editor, false);

                                                        break;

                                                case KeyEvent.VK_ENTER :

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

                                                        if (getSelectedItem() == null)

                                                                logger.debug("SELECTED ITEM: NULL");

                                                        else

                                                                logger.debug("SELECTED ITEM: " + getSelectedItem().toString());