| gvSIG desktop 1

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

 */

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

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.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import javax.swing.JTextField;

import javax.swing.event.DocumentListener;

import javax.swing.event.UndoableEditEvent;

import javax.swing.event.UndoableEditListener;

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.gvsig.gui.beans.swing.optionsEditionByMousePopupMenu.JOptionsEditionByMousePopupMenu;

/**

 * JTextComponent that allows user to select an option: <i>COPY, CUT, PASTE, SELECT ALL, REMOVE, UNDO, REDO</i> in a popup menu.<br>

 * All options will be about the edtion of the text in the component.<br> * 

 * <b><i>How select an edition option using the mouse:</i></b> press the right button of the mouse on the text area, and a popup with the options will be displayed. Select and option.<br>

 * <b><i>How select an edition option using the keyboard:</i></b> 

 * <ul>

 *  <li><b>COPY:</b> </li> CTRL + C. Copies from the text field to the clipboard.

 *  <li><b>CUT:</b> </li> CTRL + X. Cuts from the text field to the clipboad.

 *  <li><b>PASTE:</b> </li> CTRL + V. Copies from the clipboard to the text field.

 *  <li><b>REMOVE:</b> </li> SUPR (in spanish keyboard). Removes the selected text.

 *  <li><b>SELECT ALL:</b> </li> CTRL + A. Selects all the text.

 *  <li><b>UNDO:</b> </li> CTRL + Z. Undoes.

 *  <li><b>REDO:</b> </li> SHIFT + CTRL + Z. Redoes.

 * </ul>

 * 

 * This component by default stores 10 undo/redo actions. This value can be modified.

 * 

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

 */

public class JTextFieldEditable extends JTextField {

        private static final long serialVersionUID = 7440699741607998478L;

        // CONSTANTS

        public static final int DEFAULT_UNDO_REDO_LIMIT_ACTIONS = 10;

        // END CONSTANTS

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

        // LISTENERS

        private KeyListener editorKeyListener;

        private MouseAdapter editorMouseListener;

        private PropertyChangeListener editionMenuListener;

        private DocumentListener documentListener;

        // END LISTENERS

        // OTHER ATTRIBUTES

        private boolean optionsEditorWasVisible;

        // END OTHER ATTRIBUTES

        /**

         * Default constructor

         */

        public JTextFieldEditable() {

                super();

                initialize();

                // Other configuration tasks

                this.createDefaultListeners();

                this.configure();

        }

        /**

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

         */

        private void initialize() {

        // Allows user to edit

                super.setEditable(true);

                // Text options edition popupmenu initialization

                optionsEditionByMouse = new JOptionsEditionByMousePopupMenu();

                optionsEditorWasVisible = false;

                // Undo-Redo initialization

                undoManager = new UndoManager();

                undoRedoLimitActions = DEFAULT_UNDO_REDO_LIMIT_ACTIONS; // By default is 1

                undoManager.setLimit(undoRedoLimitActions);

        }

        /**

         * 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 mouse listener for the editor of this component

        this.defineEditorMouseListener(this);

        }

        /**

         * 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 text_component_editable A reference of this component

         */

        private void defineEditionMenuPropertyChangeListener(JTextFieldEditable text_component_editable) {

                final JTextFieldEditable jTextComponentEditable = text_component_editable;

                editionMenuListener = new PropertyChangeListener() {

                        /*

                         * (non-Javadoc)

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

                         */

                        public void propertyChange(PropertyChangeEvent arg0) {

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

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

                                  {

                                          case JOptionsEditionByMousePopupMenu.UNDO:

                                                  undoOperationLogic();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.REDO:

                                                  redoOperationLogic();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.CUT:

                                                  jTextComponentEditable.cut();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.COPY:

                                                  jTextComponentEditable.copy();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.PASTE:

                                                  jTextComponentEditable.paste();

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.DELETE:

                                                  deleteTextLogic(jTextComponentEditable);

                                                  break;

                                          case JOptionsEditionByMousePopupMenu.SELECT_ALL:

                                                  jTextComponentEditable.selectAll();

                                                  break;

                                          default: // do anything

                                  }

                                }

                                else

                                {

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

                                        {

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

                                                if (!optionsEditionByMouse.isVisible())

                                                        optionsEditorWasVisible = true;

                                                else

                                                        optionsEditorWasVisible = false;

                                        }

                                }

                        }                        

                };

        }

        /**

         * 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(JTextFieldEditable text_component_editable) {

                final JTextFieldEditable jTextComponentEditable = text_component_editable;

                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

                        {

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

                                            jTextComponentEditable.copy();

                                            ke.consume();

                                            return;

                                    }

                                    // CUT

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

                                            jTextComponentEditable.cut();

                                            ke.consume();

                                            return;

                                    }

                                    // PASTE

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

                                            jTextComponentEditable.paste();

                                            ke.consume();

                                            return;

                                    }

                                    // SELECT ALL

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

                                            jTextComponentEditable.selectAll();

                                            ke.consume();

                                            return;

                                    }

                                    // UNDO OR REDO

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

                                            if (ke.isShiftDown()) // REDO

                                                    redoOperationLogic();                                                            

                                            else //UNDO

                                                    undoOperationLogic();

                                            ke.consume();

                                            return;

                                     }

                                }

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

                                switch (ke.getKeyCode())

                                {

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

                                                deleteTextLogic(jTextComponentEditable);

                                                ke.consume();

                                        break;

                                }

                        }

                };

        }

        /**

         * Defines a mouse listener for the editor of this component

         * 

         * @param combo_Box A reference of this component

         */

        private void defineEditorMouseListener(JTextFieldEditable text_component_editable) {

                final JTextFieldEditable jTextComponentEditable = text_component_editable;

                editorMouseListener = new MouseAdapter() {

                        /*

                         * (non-Javadoc)

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

                         */

                        public void mouseClicked(MouseEvent e) {

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

                            // 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 (jTextComponentEditable.getCaretPosition() != jTextComponentEditable.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)jTextComponentEditable.getLocationOnScreen().getX() + e.getX(), (int)jTextComponentEditable.getLocationOnScreen().getY() + e.getY());

                            optionsEditionByMouse.setInvoker(jTextComponentEditable);

                            optionsEditionByMouse.setVisible(true);

                    }

                }

                };

        }

        /**

         * Configures the component and some of its parts

         */

        private void configure() {

                // Configures the document of the editor of this component

                PlainDocument document = this.configureDocument();

                // Configures the editor (ComboBoxEditor) of this component

                this.configureEditor(this, document);

                // Configures the text-edition-options popupmenu

                this.configureOptionsEditionByMouse();

        }

        /**

         * Configures the document of the editor of this component

         */

        private PlainDocument configureDocument() {

                // Creates the document of the editor of this component

                PlainDocument document = new PlainDocument();

                // Configures the document

                configureUndoManager(document);

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

                document.addDocumentListener(this.documentListener);

                return document;

        }

        /**

         * Configures the editor (ComboBoxEditor) of this component

         * 

         * @param newEditor The new editor to configure

         */

        private void configureEditor(JTextFieldEditable text_component_editable, PlainDocument document) {

                final JTextFieldEditable jTextComponentEditable = text_component_editable;

        if (text_component_editable != null) {

                   // Removes some prevous listeners and adds some new others:     

                // Adds the new Key Listener (tries to remove it if it existed before)

                jTextComponentEditable.removeKeyListener(this.editorKeyListener);

                jTextComponentEditable.addKeyListener(this.editorKeyListener);

                   // Adds the new Mouse Listener (tries to remove it if it existed before)

                jTextComponentEditable.removeMouseListener(this.editorMouseListener);

                jTextComponentEditable.addMouseListener(this.editorMouseListener);

                // Adds the new document (tries to remove it if it existed before)

                jTextComponentEditable.setDocument(document);

        }

        }

        /** 

         * Configures the text-edition-options popupmenu

         */

        private void configureOptionsEditionByMouse() {

                this.optionsEditionByMouse.addPropertyChangeListener(editionMenuListener);

        }

        /**

         * Configures the UndoManager for Undo-Redo operations

         */

        public void configureUndoManager(PlainDocument document) {

                final UndoManager undo_Manager = undoManager; 

        // Listen for undo and redo events

        document.addUndoableEditListener(new UndoableEditListener() {

                /*

                 * (non-Javadoc)

                 * @see javax.swing.event.UndoableEditListener#undoableEditHappened(javax.swing.event.UndoableEditEvent)

                 */

            public void undoableEditHappened(UndoableEditEvent evt) {

                                undo_Manager.addEdit(evt.getEdit());

            }

        });

        }

        /**

         * This method has the logic for a "undo" operation

         */

        private void undoOperationLogic() {

                try {

            if (undoManager.canUndo()) {

                    undoManager.undo();

            }

                } catch (CannotUndoException e) {

                e.printStackTrace();

        }

        }

        /**

         * This method has the logic for a "redo" operation

         */

        private void redoOperationLogic() {

        try {

            if (undoManager.canRedo()) {

                            undoManager.redo();

            }

            } catch (CannotRedoException e) {

                    e.printStackTrace();

            }

        }

    ////// OTHER METHODS //////

        /**

     * Sets the limit of actions that can hold the UndoManager of this component

     * 

     * @param limit

     */

        public void setUndoRedoLimitActions(int limit) {

            this.undoRedoLimitActions = limit;

            undoManager.setLimit(undoRedoLimitActions);

    }

        /**

     * Gets the limit of actions that can hold the UndoManager:

     * 

     * @return int 

     */

        public int getUndoRedoLimitActions() {

            return this.undoRedoLimitActions;

    }

        /**

         * This method is invoked when some text has to be removed: With the 'Delete' option of the text-edition-popupmenu or with the 'delete' ('supr'

         *    in spanish keyboard) key

         * 

         * @param jTextComponentEditable A reference to the editor component

         */

        private void deleteTextLogic(JTextComponent jTextComponentEditable) {

                //                 Get the new text:                

                  try {

                          PlainDocument document = (PlainDocument)jTextComponentEditable.getDocument();

                          int caretPosition = jTextComponentEditable.getCaretPosition();

                          int markPosition = jTextComponentEditable.getCaret().getMark();

                          int min_index = Math.min(caretPosition, markPosition);

                          int length = Math.abs(caretPosition - markPosition);

                          document.remove(min_index, length);

                  } catch (BadLocationException e) {

                          e.printStackTrace();

                  }

        }

    ////// END OTHER METHODS //////

}