Application: gvSIG desktop

package com.iver.cit.gvsig.gui.panels;

import java.awt.Color;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.io.UnsupportedEncodingException;

import java.net.URLEncoder;

import java.text.DateFormat;

import java.text.NumberFormat;

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import java.util.StringTokenizer;

import java.util.TreeSet;

import java.util.Vector;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import javax.swing.DefaultListModel;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.event.TreeSelectionListener;

import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.tree.DefaultTreeModel;

import javax.swing.tree.TreePath;

import org.apache.log4j.Logger;

import org.gvsig.gui.beans.Messages;

import org.gvsig.gui.beans.filterPanel.filterQueryPanel.FilterQueryJPanel;

import org.gvsig.gui.beans.filterPanel.filterQueryPanel.jLabelAsCell.DefaultListModelForJLabelAsCell;

import org.gvsig.gui.beans.filterPanel.filterQueryPanel.jLabelAsCell.JLabelAsCellValueLoaded;

import org.gvsig.gui.beans.filterPanel.filterQueryPanel.jLabelAsCell.JLabelAsCellValueNotLoaded;

import org.gvsig.remoteClient.gml.schemas.XMLElement;

import org.gvsig.remoteClient.gml.types.IXMLType;

import com.hardcode.gdbms.engine.data.driver.DriverException;

import com.hardcode.gdbms.engine.instruction.IncompatibleTypesException;

import com.hardcode.gdbms.engine.values.BooleanValue;

import com.hardcode.gdbms.engine.values.ComplexValue;

import com.hardcode.gdbms.engine.values.NullValue;

import com.hardcode.gdbms.engine.values.Value;

import com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

import com.iver.andami.ui.mdiManager.IWindow;

import com.iver.cit.gvsig.ProjectExtension;

import com.iver.cit.gvsig.fmap.edition.EditableAdapter;

import com.iver.cit.gvsig.fmap.edition.VectorialEditableAdapter;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.ReadableVectorial;

import com.iver.cit.gvsig.fmap.layers.SelectableDataSource;

import com.iver.cit.gvsig.fmap.layers.WFSLayerNode;

import com.iver.cit.gvsig.fmap.layers.layerOperations.AlphanumericData;

import com.iver.cit.gvsig.gui.filter.ExpressionDataSource;

import com.iver.cit.gvsig.gui.filter.ExpressionListener;

import com.iver.cit.gvsig.gui.filter.FilterException;

import com.iver.cit.gvsig.gui.panels.fieldsTree.FieldsTreeTableModel;

import com.iver.cit.gvsig.project.ProjectFactory;

import com.iver.cit.gvsig.project.documents.table.ProjectTable;

import com.iver.cit.gvsig.project.documents.table.ProjectTableFactory;

import com.iver.cit.gvsig.project.documents.table.gui.Table;

import com.iver.cit.gvsig.project.documents.view.gui.View;

import com.iver.cit.gvsig.sqlQueryValidation.SQLQueryValidation;

import com.iver.utiles.DefaultCharSet;

import com.iver.utiles.StringUtilities;

import com.iver.utiles.exceptionHandling.ExceptionHandlingSupport;

import com.iver.utiles.exceptionHandling.ExceptionListener;

import com.iver.utiles.stringNumberUtilities.StringNumberUtilities;

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

 */

/**

 * This will be the tab for add a filter to a WFS query.

 * This class gets the graphical interface from FilterQueryJPanel and add logic.

 * 

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

 */

public class WFSFilterPanel extends FilterQueryJPanel {

        private static Logger logger = Logger.getLogger(Table.class.getName());

        private WFSParamsPanel parent = null;

        private ArrayList expressionListeners = new ArrayList();

        private ExpressionDataSource model = null;

        private NumberFormat nf = NumberFormat.getNumberInstance();

        private ExceptionHandlingSupport exceptionHandlingSupport = new ExceptionHandlingSupport();

        private FieldsTreeTableModel fieldsTreeTableModel;

        private boolean panelAsATabForWFSLayersLoad;

        private TreePath currentPath;

        private String featureName;

        private Map allFieldsAndValuesKnownOfCurrentLayer; // This will have all values (not repeated) known of all fields (not repeated)

        ///// GUI METHODS ////

        /**

         * This method initializes

         * 

         * @param parent A reference to the parent container component of this component

         */

        public WFSFilterPanel(WFSParamsPanel parent) {

                super();

                this.parent = parent;

                currentPath = null;

                featureName = null;

                allFieldsAndValuesKnownOfCurrentLayer = new HashMap(); // Initial capacity = 0

                // At beginning, the JList is disabled (and its set a particular color for user could knew it)

                super.getValuesJList().setEnabled(false);

                getValuesJList().setBackground(new Color(220, 220, 220));

        }

        /*

         *  (non-Javadoc)

         * @see org.gvsig.gui.beans.filterPanel.AbstractFilterQueryJPanel#initialize()

         */

        protected void initialize() {

                super.initialize();

                this.resizeHeight(380);

                defaultTreeModel = (DefaultTreeModel)fieldsJTree.getModel();

                this.addNewListeners();

                panelAsATabForWFSLayersLoad = true;

                getValidateFilterExpressionJCheckBox().setSelected(true);

                getValuesJLabel().setToolTipText(Messages.getText("values_of_the_selected_field_explanation"));

                getFieldsJLabel().setToolTipText(Messages.getText("fields_of_the_selected_feature_explanation"));

        }

        /**

         * Adds some more listener to the components of the panel

         */

        private void addNewListeners() {

                // Enable "Apply" button when user changes the filter query

                txtExpression.getDocument().addDocumentListener(new DocumentListener() {

                        /*

                         *  (non-Javadoc)

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

                         */

                        public void changedUpdate(DocumentEvent e) {

                        }

                        /*

                         *  (non-Javadoc)

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

                         */

                        public void insertUpdate(DocumentEvent e) {

                                if (!panelAsATabForWFSLayersLoad)

                                        parent.isApplicable(true);

                        }

                        /*

                         *  (non-Javadoc)

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

                         */

                        public void removeUpdate(DocumentEvent e) {

                                if (!panelAsATabForWFSLayersLoad)

                                        parent.isApplicable(true);

                        }

                });

                // Listener for "fieldsJTree" 

                getFieldsJTree().addMouseListener(new MouseAdapter() {

                        /*

                         *  (non-Javadoc)

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

                         */

                        public void mouseClicked(MouseEvent e) {

                                int row = fieldsJTree.getRowForLocation(e.getX(), e.getY());

                                TreePath treePath = fieldsJTree.getPathForLocation(e.getX(), e.getY());

                                if (row > -1) {

                                        switch (e.getClickCount()) {

                                                case 2:                                                        

                                                        putSymbolOfSelectedByMouseBranch(treePath);

                                                        break;

                                        }

                                }

                        }

                });

                // Listener for "valuesJList"

                getValuesJList().addMouseListener(new MouseAdapter() {

                        /*

                         *  (non-Javadoc)

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

                         */

                        public void mouseClicked(MouseEvent e) {

                                int index = getValuesJList().getSelectedIndex();

                                // Avoids exception when no value is in the list

                                if (index == -1)

                                        return;

                                if (e.getClickCount() == 2){

                                        String valor = ((JLabel) valuesListModel.getElementAt(index)).getText();

                                        // If value is an string -> set it between apostrophes

                                        if (getNodeOfCurrentPath().getEntityType().getName().compareTo("xs:string") == 0) {

                                                putSymbol("'" + valor + "'");

                                        }

                                        else {

                                                putSymbol(valor);

                                        }

                                }

                        }

                });

                // Listener for a branch of the tree selection

                getFieldsJTree().addTreeSelectionListener(new TreeSelectionListener() {

                        /*

                         *  (non-Javadoc)

                         * @see javax.swing.event.TreeSelectionListener#valueChanged(javax.swing.event.TreeSelectionEvent)

                         */

                        public void valueChanged(TreeSelectionEvent e) {

                                if (!panelAsATabForWFSLayersLoad) {                                        

                                        DataReturnedOfDataLoadingFromActiveView data = DataLoadingFromActiveView.getDefaultExpressionDataSource();

                                        if ((data != null) && (data.getData() != null)) {

//                                                setModel(data.getData());

                                                currentPath = e.getPath();

                                                fillValuesByPath(currentPath);

                                        }

                                }

                        }                        

                });

                // Listener: when a user writes something on the textarea -> set it's foreground color to black

                getTxtExpression().getDocument().addDocumentListener(new DocumentListener() {

                        /*

                         *  (non-Javadoc)

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

                         */

                        public void changedUpdate(DocumentEvent e) {

                        }

                        /*

                         *  (non-Javadoc)

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

                         */

                        public void insertUpdate(DocumentEvent e) {

                                getTxtExpression().setForeground(Color.BLACK);

                        }

                        /*

                         *  (non-Javadoc)

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

                         */

                        public void removeUpdate(DocumentEvent e) {                                

                                getTxtExpression().setForeground(Color.BLACK);

                        }                        

                });

//                // Listener: if user wants or not that the filter expression would be validated

//                getValidateFilterExpressionJCheckBox().addItemListener(new ItemListener() {

//                        /*

//                         * (non-Javadoc)

//                         * @see java.awt.event.ItemListener#itemStateChanged(java.awt.event.ItemEvent)

//                         */

//                        public void itemStateChanged(ItemEvent e) {

//                                if (e.getStateChange() == ItemEvent.SELECTED)

//                                        System.out.println("Seleccionada");

//                                else {

//                                        if (e.getStateChange() == ItemEvent.DESELECTED)

//                                                System.out.println("Deseleccionada");

//                                }

//                        }

//                });

        }

        /**

         * Gets the element that the 'currentPath' field aims

         * 

         * @return An XMLElement

         */

        private XMLElement getNodeOfCurrentPath() {

                if (currentPath != null) {

                        Object node = currentPath.getLastPathComponent();

                        if ((node != null) && (node instanceof XMLElement)) {

                                return (XMLElement) node;

                        }

                }

                return null;

        }

        /**

         * Puts the symbol of selected brach

         * 

         * @param mouseEvent A MouseEvent with information  of the selected branch

         */

        public void putSymbolOfSelectedByMouseBranch(TreePath treePath) {

                // Sets the node selected

                if (treePath != null) {

                        putSymbol("\"" + this.getPathOfLeafWithoutRoot(treePath.getLastPathComponent()) + "\"");

                }

        }

        /**

         * This method returns the path of a node of a tree

         * Each node is separated from its parent with the symbol "/"

         * 

         * @param node A node of a 

         * @return An string with the path

         */

        private String getPathOfLeaf(Object node) {

                String path = "";

                if ((node != null) && (node instanceof XMLElement)) {

                        XMLElement element = (XMLElement) node;

                        XMLElement parent = element.getParentElement();

                        path = element.getName();

                        while (parent != null){

                                path = parent.getName() + "/" + path;

                                parent = parent.getParentElement();

                        }

                }

                return path;

        }

        /**

         * This method returns the path without the root, of a node of a tree

         * Each node is separated from its parent with the symbol "/"

         * 

         * @param node A node of a 

         * @return An string with the path

         */

        private String getPathOfLeafWithoutRoot(Object node) {

                String path = "";

                if ((node != null) && (node instanceof XMLElement)) {

                        XMLElement element = (XMLElement) node;

                        XMLElement parent = element.getParentElement();

                        path = element.getName();

                        while (parent.getParentElement() != null){

                                path = parent.getName() + "/" + path;

                                parent = parent.getParentElement();

                        }

                }

                return path;

        }

        /**

         * Gets the value of the inner attribute: 'panelAsATabForWFSLayersLoad'

         * 

         * @return A boolean value

         */

        public boolean getWFSFilterPanelIsAsTabForWFSLayersLoad() {

                return this.panelAsATabForWFSLayersLoad;

        }

        /**

         * Sets the value of the inner attribute: 'panelAsATabForWFSLayersLoad'

         * 

         * @param b A boolean value

         */

        public void setWFSFilterPanelIsAsTabForWFSLayersLoad (boolean b) {

                this.panelAsATabForWFSLayersLoad = b;

                if (this.panelAsATabForWFSLayersLoad == true) {

                        // At beginning, the JList is disabled (and its set a particular color for user could knew it)

                        super.getValuesJList().setEnabled(false);

                        super.getValuesJList().setBackground(new Color(220, 220, 220)); // a grey color

                        this.allFieldsAndValuesKnownOfCurrentLayer.clear();

                        getValidateFilterExpressionJCheckBox().setSelected(true);

                }

                else {

                        // Unselect the selected path in the tree (if there was any selected)

                        if (this.currentPath != null) {

                                this.currentPath = null;

                                this.getFieldsJTree().removeSelectionPath(this.getFieldsJTree().getSelectionPath());

                        }

                        // Resets data loaded

                        super.getValuesJList().setEnabled(true);

                        super.getValuesJList().setBackground(Color.WHITE);

                        this.getFieldsJTree().removeAll();

                        this.getValuesJList().removeAll();

                        // Updates data associated to view with the new layer data

                        this.setNewDataToTable();

                        // If theres is any table associated to the current view -> update that table/s

//                        this.updateTablesThatHasNewData();

                        // Reads that new data

                        DataReturnedOfDataLoadingFromActiveView data = DataLoadingFromActiveView.getDefaultExpressionDataSource();

                        if ((data != null) && (data.getData() != null)) {

                                setModel(data.getData());

//                                currentPath = e.getPath();

//                                fillValuesByPath(currentPath);

                        }

                        // Loads values known of fields

                        this.setValuesKnownOfFields();

                }

        }

        /**

         * Refresh all information about fields

         * 

         * @param feature The layer to refresh

         * 

         * @return True if can refresh, False if not

         */

        public boolean refresh(WFSLayerNode feature) {

                featureName = feature.getTitle();

                return setFields(feature);

        }

        ///// END GUI METHODS /////

        ///// METHODS FOR THE FILTER QUERY /////

        /**

         * Gets the query that will be send to the server

         * @return SQL query (just the where part)

         */

        public String getQuery(){

                String writtenQuery = txtExpression.getText().trim();

                // Validate expression

                if (!this.validateExpression(writtenQuery)) {

                        getTxtExpression().setForeground(Color.red);

                        return null;

                }

                else

                        // Codify expression (only if the validation has been successful)

                        return this.codifyExpression(writtenQuery); // Ignores the spaces at beginning and end of the chain of characters

        }

        /**

         * Gets the filter expression from the user interface

         */

        public String getFilterExpressionFromInterface() {

                return getTxtExpression().getText();

        }

        /**

         * Writes the filter expression into the user interface

         * @param filterExpression An string

         */

        public void setFilterExpressionIntoInterface(String filterExpression){

                getTxtExpression().setText(filterExpression);

        }

        /**

         * Removes text in the JTextArea that has the filter subconsultation

         */

        public void removeFilterExpression() {

                getTxtExpression().setText("");

        }

        /**

         * Codifies the expression to ISO ISO-8859_1 and a format that the SQL parser could validate

         * 

         * @param expression The expression to be codified 

         * 

         * @return The expression codified

         */

        private String codifyExpression(String expression) {

                String result = new String("");

                // Encode each string of the query

                int index = 0;

                int lastIndex = 0;

                boolean endInnerLoop;

                // Encodes all inner strings to the equivalent codification in ISO-8859_1 with each ' symbol converted to ''

                while (index != -1) {

                        index = expression.indexOf("'", index);

                        // Add the parts of the chain of characters that not are string

                        if (index == -1) {

                                result += expression.substring(lastIndex, expression.length());

                        }

                        else {

                                result += expression.substring(lastIndex, index).replaceAll(" [ ]+", " ");

                        }

                        lastIndex = index;

                        endInnerLoop = false;

                        // Tries to find each first apostrophe of each string of the query

                        if ((index > 0) && (expression.charAt(index - 1) == ' ')) {

                                index++;

                                // Ignore all inner apostrophes and try to find the last of the string

                                while (!endInnerLoop)  {

                                        index = expression.indexOf("'", index);

                                        index++;

                                        // If we haven't arrived to the finish of the string

                                        if (index != expression.length()) {

                                                if ((index == -1) || (expression.charAt(index) == ' ')) {

                                                        result += translateString(expression.substring(lastIndex, index));

                                                        endInnerLoop = true;

                                                }

                                        }

                                        else {

                                                result += translateString(expression.substring(lastIndex, index));

                                                endInnerLoop = true;

                                                index = -1; // Force to finish the external loop

                                        }

                                }

                                lastIndex = index;

                        }

                }

                // Field names are transformated in xix variables that will be analyzed

                // Date(date) is substituted by the correct date format

                try {

                        result = translateDates(result);

                }

                catch(ParseException e) {

                        JOptionPane.showMessageDialog(this, PluginServices.getText(null, "error_codifying_dates"), PluginServices.getText(null, "error_coding_filter_query"), JOptionPane.ERROR_MESSAGE);

                        return null;

                }

                try {

                        result = translateNumber(result);

                }

                catch(ParseException e) {

                        JOptionPane.showMessageDialog(this, PluginServices.getText(null, "error_codifying_numbers"), PluginServices.getText(null, "error_coding_filter_query"), JOptionPane.ERROR_MESSAGE);

                        return null;

                }

                try {

                        result = translateWord(result, "true", "1");

                }

                catch(ParseException e) {

                        JOptionPane.showMessageDialog(this, PluginServices.getText(null, "error_codifying_words"), PluginServices.getText(null, "error_coding_filter_query"), JOptionPane.ERROR_MESSAGE);

                        return null;

                }

                try {

                        result = translateWord(result, "false", "0");

                }

                catch(ParseException e) {

                        JOptionPane.showMessageDialog(this, PluginServices.getText(null, "error_codifying_words"), PluginServices.getText(null, "error_coding_filter_query"), JOptionPane.ERROR_MESSAGE);

                        return null;

                }

                logger.debug(result);                        

                return result;

        }

        /**

         * Checks the filter expression if it's correct

         * 

         * @param query The query expression to analyze

         * @return True if it's valid or false if not

         */

        private boolean validateExpression(String query) {

                // If it's needed to validate the query

                if (getValidateFilterExpressionJCheckBox().isSelected()) {                

                        // If it's an empty query -> ok 

                        if (query.trim().length() == 0)

                                return true;

                        // Replace all Date(dd-mmm-yyyy) format to ddd-mmm-yyyy (characters will replaced to spaces)

                        int index = 0;

                        String query_copy = new String(query);

                        while ((index = query_copy.indexOf("Date(", index)) != -1) {

                                if (index > 0) {

                                        if ((query_copy.charAt(index-1) != ' ') && (query_copy.charAt(index-1) != '('))

                                                break;

                                }

                                if (((index + 16) < query_copy.length()) && (query_copy.charAt(index + 16) == ')')) { // +17 is the length of Date(dd-mmm-yyyy)

                                        if ((index + 17) < query_copy.length()) {

                                                query_copy = query_copy.substring(0, index) + "     " + query_copy.substring(index+6, index+16) + " " + query_copy.substring(index+17);

                                        }

                                        else {

                                                query_copy = query_copy.substring(0, index) + "     " + query_copy.substring(index+6, index+16);

                                        }

                                }

                        }

                        SQLQueryValidation sQLQueryValidation = new SQLQueryValidation(query_copy, true);

                        // Tries to validate the query, and if fails shows a message

                        if (!sQLQueryValidation.validateQuery()) {

                                JOptionPane.showMessageDialog(null, PluginServices.getText(null, "filter_with_an_incorrect_format") + ": " + PluginServices.getText(null, "finded") + " " + sQLQueryValidation.getTokenThatProducedTheSyntacticError() + " " + PluginServices.getText(null, "in")  + " " + sQLQueryValidation.getErrorPositionAsMessage() + ".", PluginServices.getText(null, "error_validating_filter_query"), JOptionPane.ERROR_MESSAGE);

                                return false;

                        }

                        else {

                                // Analyzes tokens in query

                                StringTokenizer tokens = new StringTokenizer(query, " ");

                                String token, token_aux;

                                boolean finish = false;

                                // If there is a field or a value with spaces, (and then it's on differents tokens) -> unify them

                                while (tokens.hasMoreTokens()) {

                                        token = tokens.nextToken().trim();

                                        if (token.charAt(0) == '\'') {

                                                if (token.charAt(token.length() -1) != '\'') {

                                                        while (!finish) {

                                                                if (!tokens.hasMoreTokens()) {

                                                                        JOptionPane.showMessageDialog(null, PluginServices.getText(null, "filter_with_an_incorrect_format") + ": " + PluginServices.getText(null, "the_token") + " " + token + " " + PluginServices.getText(null, "has_bad_format"), PluginServices.getText(null, "error_validating_filter_query"), JOptionPane.ERROR_MESSAGE);

                                                                        return false;

                                                                }

                                                                else {

                                                                        token_aux = tokens.nextToken().trim();

                                                                        token += " " + token_aux;

                                                                        if (token_aux.charAt(token_aux.length() -1) == '\'')

                                                                                finish = true;

                                                                }

                                                        }

                                                        finish = false;

                                                }

                                        }

                                        if (token.charAt(0) == '\"') {

                                                if (token.charAt(token.length() -1) != '\"') {

                                                        while (!finish) {

                                                                if (!tokens.hasMoreTokens()) {

                                                                        JOptionPane.showMessageDialog(null, PluginServices.getText(null, "filter_with_an_incorrect_format") + ": " + PluginServices.getText(null, "the_token") + " " + token + " " + PluginServices.getText(null, "has_bad_format"), PluginServices.getText(null, "error_validating_filter_query"), JOptionPane.ERROR_MESSAGE);

                                                                        return false;

                                                                }

                                                                else {

                                                                        token_aux = tokens.nextToken().trim();

                                                                        token += " " + token_aux;

                                                                        if (token_aux.charAt(token_aux.length() -1) == '\"')

                                                                                finish = true;

                                                                }

                                                        }

                                                        finish = false;

                                                }

                                        }

                                        // Tries to find an invalid token

                                        if (token.length() > 0) {

                                                // Validates if a supposed field exists

                                                if ( (token.length() > 2) && (token.charAt(0) == '\"') && (token.charAt(token.length()-1) == '\"') ) {

                                                        if (! this.isAField(token.substring(1, token.length()-1))) {

                                                                JOptionPane.showMessageDialog(null, PluginServices.getText(null, "filter_with_an_incorrect_format") + ": " + PluginServices.getText(null, "the_token") + " " + token + " " + PluginServices.getText(null, "isnt_a_field_of_layer"), PluginServices.getText(null, "error_validating_filter_query"), JOptionPane.ERROR_MESSAGE);

                                                                return false;

                                                        }

                                                }

                                                else {

                                                        // If it's an string -> ignore

                                                        if (! ((token.charAt(0) == token.charAt(token.length() - 1)) && (token.charAt(0) == '\''))) {

                                                                // If it's a date -> ignore

                                                                int returnValue = validateDate(token);

                                                                if (returnValue == 1) {

                                                                        JOptionPane.showMessageDialog(null, PluginServices.getText(null, "filter_with_an_incorrect_format") + ": " + PluginServices.getText(null, "incorrect_format_on_date") + " " + token.substring(5, 16) + " .", PluginServices.getText(null, "error_validating_filter_query"), JOptionPane.ERROR_MESSAGE);

                                                                        return false;

                                                                }

                                                                if (returnValue == 2) {                                                                

                                                                        // Else -> Checks if the current token is a valid number or symbol

                                                                        if ((! StringNumberUtilities.isRealNumberWithRealExponent(token)) && (! this.isAnOperatorNameOrSymbol(token, getAllOperatorSymbols()))) {

                                                                                JOptionPane.showMessageDialog(null, PluginServices.getText(null, "filter_with_an_incorrect_format") + ": " + PluginServices.getText(null, "not_valid_token") + ": " + token, PluginServices.getText(null, "error_validating_filter_query"), JOptionPane.ERROR_MESSAGE);

                                                                                return false;

                                                                        }

                                                                }

                                                        }

                                                }

                                        }

                                }

                                // If has validate all tokens -> query validated

                                return true;

                        }

                }

                else

                        return true; // No validation done because user selected that option

        }

        /**

         * Returns true if there is a field with the same name as 'text'

         * 

         * @param text An string

         * @return A boolean value

         */

        private boolean isAField(String text) {

                return this.allFieldsAndValuesKnownOfCurrentLayer.containsKey(text);                

        }

        /**

         * Validates if a text has a correct date format as Date(dd-mmm-yyyy)  (Ex. Date(03-feb-2004) )

         * 

         * @param text

         * @return 0 -> if has a date format; 1 -> if it's a date that has a but format; 2 -> if it isn't a date

         */

        private int validateDate(String text) {

                // If it's a date -> check if format is correct (Ex.  Date(01-feb-2004) )

                if ( ((text.length() == 17) && (text.startsWith("Date(")) && (text.endsWith(")"))) && (text.charAt(7) == '-') && (text.charAt(11) == '-') ) {

                        if ( (StringNumberUtilities.isNaturalNumber(text.substring(5, 7))) && (StringNumberUtilities.isNaturalNumber(text.substring(12, 16))) ) {

                                try {

                                        // If can parse the date -> date with a correct format 

                                        DateFormat.getDateInstance().parse(text.substring(5, 16));

                                        return 0;

                                } catch (ParseException e) {

                                        // If can't parse the date -> date with an incorrect format 

                                        return 1;

                                }

                        }

                        else {

                                return 1;

                        }

                }

                return 2;

        }

        /**

         * Returns true if there is the 'text' is a symbol or a operator name

         * 

         * @param text An string

         * @return A boolean value

         */

        private boolean isAnOperatorNameOrSymbol(String text, Set operatorNamesAndSymbols) {                

                return operatorNamesAndSymbols.contains(text);

        }

        /**

         * DOCUMENT ME!

         *

         * @return DOCUMENT ME!

         *

         * @throws ParseException DOCUMENT ME!

         * @deprecated In this moments its a reference of the old Validate Expression method

         */

        private String oldValidateExpressionMethod() throws ParseException {

                String expression = txtExpression.getText();

//                HashSet variablesIndexes = new HashSet();

//

//                StringBuffer traducida = new StringBuffer();

                //Se transforman los nombres de los campos en las variables xix que analizar?n

                //Se quitan los Date(fecha) y se mete la fecha correspondiente

                expression = translateDates(expression);

                expression = translateNumber(expression);

                expression = translateWord(expression, "true", "1");

                expression = translateWord(expression, "false", "0");

                String replacement;

                Pattern patron = Pattern.compile("[^<>!]=");

                Matcher m = patron.matcher(expression);

                int index = 0;

                while (m.find(index)) {

                        index = m.start();

                        replacement = expression.charAt(index) + "==";

                        m.replaceFirst(replacement);

                        index++;

                }

                expression = expression.replaceAll("[^<>!]=", "==");

                logger.debug(expression);

                return expression;

        }

        ///// END METHODS FOR THE FILTER QUERY /////

        ///// METHODS FOR TRANSLATE DATA IN FILTER SENTENCES /////

        /** 

         * DOCUMENT ME!

         *

         * @param expresion DOCUMENT ME!

         * @param word DOCUMENT ME!

         * @param translation DOCUMENT ME!

         *

         * @return DOCUMENT ME!

         *

         * @throws ParseException DOCUMENT ME!

         */

        private String translateWord(String expresion, String word,        String translation) throws ParseException {

                int booleanIndex = 0;

                int endIndex = 0;

                StringBuffer res = new StringBuffer();

                while ((booleanIndex = getIndex(expresion, word, booleanIndex)) != -1) {

                        res.append(expresion.substring(endIndex, booleanIndex));

                        endIndex = booleanIndex + word.length();

                        booleanIndex++;

                        res.append(translation);

                }

                if (endIndex < expresion.length()) {

                        res.append(expresion.substring(endIndex));

                }

                return res.toString();

        }

        /**

         * DOCUMENT ME!

         *

         * @param expresion DOCUMENT ME!

         *

         * @return DOCUMENT ME!

         *

         * @throws ParseException DOCUMENT ME!

         */

        private String translateDates(String expresion) throws ParseException {

                //Se obtiene el valor de la fecha

                String date = StringUtilities.substringDelimited(expresion, "Date(", ")", 0);

                if (date == null) {

                        return expresion;

                }

                //Se comprueba que no est? entre comillas 

                int startIndex = expresion.indexOf(date);

                while (startIndex != -1) {

                        if (!StringUtilities.isBetweenSymbols(expresion, startIndex, "\"")) {

                                //Se sustituye por el valor ordinal de la fecha

                                expresion = expresion.substring(0, startIndex - 5) +

                                        expresion.substring(startIndex).replaceFirst(date + "\\)",                                                        

                                                new Long((filterButtonsJPanel.getDateFormat().parse(date)).getTime()).toString());

                        } else {

                                startIndex += date.length();

                        }

                        if (date == null) {

                                return expresion;

                        }

                        startIndex = expresion.indexOf(date, startIndex);

                }

                return expresion;

        }

        /**

         * DOCUMENT ME!

         *

         * @param expresion DOCUMENT ME!

         *

         * @return DOCUMENT ME!

         *

         * @throws ParseException DOCUMENT ME!

         */

        private String translateNumber(String expresion) throws ParseException {

                DefaultCharSet ss = new DefaultCharSet();

                ss.addInterval('0', '9');

                ss.addCharacter(',');

                ss.addCharacter('.');

                String number = StringUtilities.substringWithSymbols(expresion, ss, 0);

                if (number == null) {

                        return expresion;

                }

                int startIndex = expresion.indexOf(number);

                while (startIndex != -1) {

                        Number n = nf.parse(number);

                        if (!StringUtilities.isBetweenSymbols(expresion, startIndex, "\"")) {

                                //Se sustituye por el valor ordinal de la fecha

                                expresion = expresion.substring(0, startIndex) +

                                        expresion.substring(startIndex).replaceFirst(number,

                                                n.toString());

                        } else {

                                startIndex += n.toString().length();

                        }

                        number = StringUtilities.substringWithSymbols(expresion, ss,

                                        startIndex);

                        if (number == null) {

                                return expresion;

                        }

                        startIndex = expresion.indexOf(number, startIndex);

                }

                return expresion;

        }

        /**

         * Encodes an string to ISO 8859_1 with each ' symbol converted to '' 

         * 

         * @param text An string started and finished with simple apostrophes

         * 

         * @return An string started and finished with simple apostrophes

         */

        private String translateString(String text) {

                // Encode to the string to ISO 8859_1 (the URL codification)

                try {

                        // Ignore the first and last apostrophes

                        if (text.length() > 2) {

                                text = text.substring(1, text.length() -1);

                                // Convert the string to ISO 8859_1 codification

                                text = URLEncoder.encode(text, "8859_1");

                                // Change '  (%27 code) to '' for the SQL parser (bebore sent the query)

                                text = text.replaceAll("\\%27", "\\'\\'");

                        }

                } catch (UnsupportedEncodingException e1) {

                        e1.printStackTrace();

                }

                return "'" + text + "'";

        }

        ///// END METHODS FOR TRANSLATE DATA IN FILTER SENTENCES /////

        ///// METHODS FOR MANIPULATE 'fields' and 'values' /////

        /**

         * DOCUMENT ME!

         *

         * @param t DOCUMENT ME!

         */

        public void setModel(ExpressionDataSource t) {

                try {

                        model = t;

            model.start();

        } catch (DriverException e1) {

            NotificationManager.addError(e1.getMessage(), e1);

        }

        try {

                int numberOfFields = model.getFieldCount();

                if (numberOfFields > 0) {

                        Vector fields = new Vector(0, 1);

                        int j = 0;

                                for (int i = 0; i < numberOfFields; i++) {

                                         Object field = model.getFieldName(i);

                                        if (field != null) {

                                                fields.add(field);

                                                String completeFieldPath = this.getPathOfLeafWithoutRoot(field);

                                                if (! allFieldsAndValuesKnownOfCurrentLayer.containsKey(completeFieldPath) ) {

                                                        allFieldsAndValuesKnownOfCurrentLayer.put(completeFieldPath, new HashMap());

                                                }

                                                j++;

                                        }

                                }

                                fieldsTreeTableModel = new FieldsTreeTableModel(fields.toArray());                        

                }

                } catch (FilterException e) {

                        throwException(e);

                }

        }

        /**

         * If there is a field selected, show its new values

         */

        public void updateFieldValues() {

                if (currentPath != null) {

                        DataReturnedOfDataLoadingFromActiveView data = DataLoadingFromActiveView.getDefaultExpressionDataSource();

                        if ((data != null) && (data.getData() != null)) {

                                setModel(data.getData());                                

                                fillValuesByPath(currentPath);

//                                valuesListModel.clear();

                                // Updates all tables that their data is about the changed view

                                this.updateTablesThatHasNewData();                                

                                // Adjust JScrollPanes to the the beginning

                                getFieldsJScrollPane().getHorizontalScrollBar().setValue(-1);

                                getFieldsJScrollPane().getVerticalScrollBar().setValue(-1);

                                // Adjust JScrollPanes to the the beginning

                                getValuesJScrollPane().getHorizontalScrollBar().setValue(-1);

                                getValuesJScrollPane().getVerticalScrollBar().setValue(-1);

                                // Adjusts valuesJList to the default position

                                getValuesJList().setSelectedIndex(-1); // No item selected

                        }

                }

        }

        /**

         * Sets Fields

         *

         * @param feature A Layer node with fields information

         * 

         * @return True if can refresh, False if not

         */

        private boolean setFields(WFSLayerNode feature) {

                Vector fields = feature.getFields();

                this.resetFieldsAndValuesData();

                int numberOfFields = fields.size();

                if (numberOfFields > 0) {

                        Vector fieldBranches = new Vector(0, 1);

                        for (int i=0; i<fields.size(); i++) {

                                XMLElement field = (XMLElement)fields.get(i);

                                IXMLType type = field.getEntityType();

                                if (type != null) {                                        

                                        switch (type.getType()) {

                                                case IXMLType.GML_GEOMETRY: // Don't add branch / field

                                                        break;

                                                case IXMLType.COMPLEX: case IXMLType.SIMPLE: // Add branch / field

                                                        fieldBranches.add(field);

                                                        break;

                                        }

                                }

                        }

                        if (fieldBranches.size() > 0) {

                                Object obj = fieldBranches.get(0);

                                fieldsTreeTableModel = new FieldsTreeTableModel(obj);

                                fieldsJTree.setModel(new FieldsTreeTableModel(obj, false));

                                // Stores the name of all leafs (fields) of treeTableModel                        

                                Object root = fieldsTreeTableModel.getRoot();

                                if (root != null) {

                                        Vector fieldsNames = fieldsTreeTableModel.getLeafsFromNodeBranch(root);

                                        for (int j = 0; j < fieldsNames.size(); j++) {

                                                Object field = fieldsNames.get(j);

                                                // Avoid errors

                                                if ( (! (field instanceof XMLElement)) || (field == null) )

                                                        continue;

                                                // Don't load a geometry field                                        

                                                if (((XMLElement)field).getEntityType() != null){

                                                        if ( ((XMLElement)field).getEntityType().getType() == IXMLType.GML_GEOMETRY ){

                                                                continue;

                                                        }

                                                }

                                                String completeFieldPath = this.getPathOfLeafWithoutRoot(field);

                                                if (! allFieldsAndValuesKnownOfCurrentLayer.containsKey(completeFieldPath) ) {

                                                        allFieldsAndValuesKnownOfCurrentLayer.put(completeFieldPath, new HashMap());

                                                }

                                        }

                                }

                        }

                        else {

                                // If there is no geometry field (that is the root) -> don't load the layer

                                JOptionPane.showMessageDialog(null, PluginServices.getText(null, "gvSIG_cant_load_the_layer_because_hasnt_geometry"), PluginServices.getText(null, "error"), JOptionPane.ERROR_MESSAGE);

                                return false;

                        }

                }

                return true;

        }

        /**

         * This method load all values known of all fields known

         * (It's used when a new layer is load)

         */

        private void setValuesKnownOfFields() {

                // Desde el modelo se deber?a acceder a los campos y sus valores cargados                

                try {

                        for (int i = 0; i < model.getFieldCount(); i++) {

                                String fieldName = model.getFieldName(i);

                                HashMap fieldValues = (HashMap) allFieldsAndValuesKnownOfCurrentLayer.get(fieldName);

                                if (fieldValues != null) {

                                        for (int j = 0; j < model.getRowCount(); j++) {

                                                Value value = model.getFieldValue(j, i);                                        

                                                if (value instanceof NullValue)

                                                    continue;

                                                Object obj = (Object)value;

                                                if (obj == null)

                                                        continue;

                                                fieldValues.put(obj.toString(), obj.toString());

                                        }

                                }

                        }

                }

                catch (Exception e) {

                        e.printStackTrace();

                }

        }

        /**

         * Resets the data of fields and their values of the current layer feature, and removes the branches of JTree

         */

        private void resetFieldsAndValuesData() {

                fieldsJTree.setModel(new DefaultTreeModel(new DefaultMutableTreeNode()));

                txtExpression.setText("");

                ((DefaultListModel)valuesJList.getModel()).removeAllElements();

        }

        /** 

         * FIlls list with the values of selected field

         * 

         * @param treePath A path in the tree

         */

        private void fillValuesByPath(TreePath treePath) {

                // Duplicates are removed

                TreeSet conjunto = new TreeSet(new Comparator() {

                        public int compare(Object o1, Object o2) {

                                if ((o1 != null) && (o2 != null)) {

                                        Value v2 = (Value) o2;

                                        Value v1 = (Value) o1;

                                        BooleanValue boolVal;

                                        try {

                                                boolVal = (BooleanValue) (v1.greater(v2));

                                                if (boolVal.getValue()) {

                                                        return 1;

                                                }

                                                boolVal = (BooleanValue) (v1.less(v2));

                                                if (boolVal.getValue()) {

                                                        return -1;

                                                }

                                        } catch (IncompatibleTypesException e) {

                                                throw new RuntimeException(e);

                                        }

                                }

                                return 0;

                        }

                }); // For ordernation

                // Remove the previous items

                valuesListModel.clear();

                try {

                        //Object root = treePath.getPath()[0];

                        XMLElement element = ((XMLElement)treePath.getLastPathComponent());

                        // Gets the values associated to the selected branch 

                        switch (element.getEntityType().getType()) {

                                case IXMLType.SIMPLE:

                                        if(element.getParentElement().getParentElement() == null) {                                        

                                                // Find the selected field and try to obtein values related

                                                for (int i = 0; i < model.getFieldCount(); i++) {                                        

                                                        String name = model.getFieldName(i);

                                                        // If we find the field (this means that are loaded its values and we can obtein them)

                                                        if (name.equals(element.getName())) {                                                

                                                                for (int j = 0; j < model.getRowCount(); j++) {                                        

                                                                        Value value = model.getFieldValue(j, i);

                                                                        if (value instanceof NullValue)

                                                                            continue;

                                                                        if (!conjunto.contains(value)) {

                                                                                conjunto.add(value);

                                                                        }

                                                                }

                                                                break;

                                                        }

                                                }