Application: gvSIG desktop

/* 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 es.gva.cit.gazetteer.ui.search;

import es.gva.cit.catalogClient.metadataXML.XMLNode;

import es.gva.cit.gazetteer.GazetteerClient;

import es.gva.cit.gazetteer.querys.Feature;

import es.gva.cit.gazetteer.querys.Query;

import es.gva.cit.gazetteer.querys.ThesaurusName;

import es.gva.cit.gazetteer.ui.showResults.ShowResultsDialog;

import es.gva.cit.gazetteer.wfsg.parsers.WfsgDescribeFeatureTypeParser;

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.Collection;

import javax.swing.BoxLayout;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.event.TreeSelectionListener;

import org.gvsig.i18n.Messages;

/**

 *

 *

 *

 * @author Jorge Piera Llodra (piera_jor@gva.es)

 */

public class SearchDialogPanel extends JPanel implements ActionListener, TreeSelectionListener {

//        It is needed to close the frame

        /**

         *

         *

         */

        private JFrame parent;

        private Query query = null;

        protected Object serverConnectFrame;

//        Panels

        /**

         *

         *

         */

        protected JPanel ppalPanel = null;

        /**

         *

         *

         */

        protected SearchUpperPanel upperPanel = null;

        /**

         *

         *

         */

        protected SearchLowerPanel lowerPanel = null;

        /**

         *

         *

         */

        protected JPanel buttonsPanel = null;

//        Buttons

        /**

         *

         *

         */

        private JButton searchButton = null;

        /**

         *

         *

         */

        private JButton closeButton = null;

        /**

         *

         *

         */

        private JButton cancelSearchesButton = null;

        /**

         *

         *

         */

        private JButton returnButton = null;

        /**

         *

         *

         */

        private JButton sizeButton = null;

//        Otros

        /**

         *

         *

         */

        protected GazetteerClient client = null;

        /**

         *

         *

         */

        protected Collection nodesRecords = new java.util.ArrayList();

        /**

         *

         *

         */

        protected String attribute = null;

        /**

         *

         *

         */

        protected boolean isMinimized = true;

        /**

         *

         *

         */

        private ThesaurusName currentThesaurus = null;

        /**

         *

         *

         */

        private Collection searchThreads = null;

        private String currentServer = null;

        /**

         * This method initializes

         *

         *

         * @param client

         * @param translator

         */

        public  SearchDialogPanel(GazetteerClient client, Object serverConnectFrame) {

                super();

                searchThreads = new java.util.ArrayList();

                this.client = client;

                this.isMinimized = true;

                this.serverConnectFrame = serverConnectFrame;

                initialize();

        }

        /**

         * This method initializes this

         *

         */

        private void initialize() {

                ppalPanel = new JPanel();

                ppalPanel.setLayout(new BoxLayout(ppalPanel, BoxLayout.Y_AXIS));

                ppalPanel.setPreferredSize(new Dimension(514,91));

                ppalPanel.add(getUpperPanel(), null);

                ppalPanel.add(getLowerPanel(), null);

                ppalPanel.add(getButtonPanel(), null);

                add(ppalPanel);

                getLowerPanel().setVisible(false);

                setDefaultButtonListeners();

        }

        /**

         * It Gets the upperPanel

         *

         *

         * @return

         */

        public SearchUpperPanel getUpperPanel() {

                if (upperPanel == null){

                        upperPanel = new SearchUpperPanel(

                                        client.getProtocol());

                }

                return upperPanel;

        }

        /**

         * It Gets the lowePanel

         *

         *

         * @return

         */

        public SearchLowerPanel getLowerPanel() {

                if (lowerPanel == null){

                        lowerPanel = new SearchLowerPanel(client.getLnkIGazetteerDriver().getVectorFeatures(),

                                        client.getProtocol());

                        if (client.getProtocol().equals("IDEC"))

                                lowerPanel.getJScrollThesaurus().setEnabled(false);

                }

                return lowerPanel;

        }

        /**

         *

         *

         *

         * @param catCli

         */

        public void setCatalogClient(GazetteerClient catCli) {

                this.client = catCli;

        }

        /**

         *

         *

         *

         * @return

         */

        public JPanel getButtonPanel() {

                if (buttonsPanel == null) {

                        FlowLayout flowLayout = new FlowLayout();

                        flowLayout.setAlignment(FlowLayout.RIGHT);

                        buttonsPanel = new JPanel(flowLayout);

                        buttonsPanel.add(getSearchButton());

                        buttonsPanel.add(getCancelSearchesButton());

                        JLabel label = new JLabel();

                        label.setPreferredSize(new Dimension(6,0));

                        buttonsPanel.add(label);

                        buttonsPanel.add(getReturnButton());

                        buttonsPanel.add(getCloseButton());

                }

                return buttonsPanel;

        }

        /**

         * It gets the return button

         *

         *

         * @return

         */

        public JButton getReturnButton() {

                if (returnButton == null) {

                        returnButton = new JButton(Messages.getText("last"));

                        returnButton.setPreferredSize(new Dimension(80, 23));

                        returnButton.setActionCommand("return");

                }

                return returnButton;

        }

        /**

         *

         *

         *

         * @return

         */

        public JButton getSearchButton() {

                if (searchButton == null) {

                        searchButton = new JButton(Messages.getText("searchButton"));

                        searchButton.setPreferredSize(new Dimension(80, 23));

                        searchButton.setActionCommand("search");

                }

                return searchButton;

        }

        /**

         * It gets the cancel searches button

         *

         *

         * @return

         */

        public JButton getCancelSearchesButton() {

                if (cancelSearchesButton == null) {

                        cancelSearchesButton = new JButton(Messages.getText("cancelSearchButton"));

                        cancelSearchesButton.setPreferredSize(new Dimension(90, 23));

                        cancelSearchesButton.setActionCommand("cancel");

                }

                return cancelSearchesButton;

        }

        /**

         *

         *

         *

         * @return

         */

        public JButton getCloseButton() {

                if (closeButton == null) {

                        closeButton = new JButton(Messages.getText("close"));

                        closeButton.setPreferredSize(new Dimension(80, 23));

                        closeButton.setActionCommand("close");

                }

                return closeButton;

        }

        /**

         * It  gets the change size button

         *

         *

         * @return

         */

        public JButton getSizeButton() {

                if (sizeButton == null) {

                        sizeButton = upperPanel.getSizeButton();

                        sizeButton.setActionCommand("size");

                }

                return sizeButton;

        }

        /**

         *

         *

         *

         * @return

         */

        public ThesaurusName getFeatureSelected() {

                //return (Feature) controlsPanel.getTipoList().getSelectedValue();

                return lowerPanel.getType();

        }

        /**

         *

         *

         */

        public void setDefaultButtonListeners() {

                getSearchButton().addActionListener(this);

                getCloseButton().addActionListener(this);

                getSizeButton().addActionListener(this);

                getReturnButton().addActionListener(this);

                getCancelSearchesButton().addActionListener(this);

                lowerPanel.getThesaurusList().addTreeSelectionListener(this);

        }

        /* (non-Javadoc)

         * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)

         */

        /**

         *

         *

         *

         * @param e

         */

        public void actionPerformed(ActionEvent e) {

                //Buscar

                if (e.getActionCommand() == "search") {

                        searchButtonActionPerformed();

                }

                if (e.getActionCommand() == "close") {

                        closeButtonActionPerformed();

                }

                if (e.getActionCommand() == "size") {

                        sizeButtonActionPerformed();

                }

                if (e.getActionCommand() == "cancel") {

                        cancelSearchesButtonActionPerformed();

                }

                if (e.getActionCommand() == "return") {

                        returnButtonActionPerformed();

                }

        }

        /**

         *

         *

         */

        protected void sizeButtonActionPerformed() {

                if (isMinimized){

                        parent.setSize(525,450);

                        ppalPanel.setPreferredSize(new Dimension(514,426));

                        getLowerPanel().setVisible(true);

                        ppalPanel.setVisible(true);

                        getUpperPanel().setUpIcon();

                }else{

                        parent.setSize(525,115);

                        ppalPanel.setPreferredSize(new Dimension(514,91));

                        getLowerPanel().setVisible(false);

                        ppalPanel.setVisible(true);

                        getUpperPanel().setDownIcon();

                }

                isMinimized = !isMinimized;

        }

        /**

         *

         *

         */

        protected void searchButtonActionPerformed() {

                if (client.getProtocol().equals("WFS")){

                        if ((currentThesaurus == null) ||

                                        (currentThesaurus.getName().equals("ThesaurusRoot"))){

                                JOptionPane.showMessageDialog(

                                                this,

                                                Messages.getText("errorNotThesaurusSelected"),

                                                "WFS",

                                                JOptionPane.ERROR_MESSAGE

                                );

                                return;

                        }

                }

                searchThread st =  new searchThread();

                searchThreads.add(st);

                setCursor(new Cursor(Cursor.WAIT_CURSOR));

        }

        /**

         * Return button

         *

         */

        protected void returnButtonActionPerformed() {

                ((JFrame)serverConnectFrame).setVisible(true);

                parent.setVisible(false);

        }

        /**

         *

         *

         */

        protected void cancelSearchesButtonActionPerformed() {

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

                        searchThread st = (searchThread)searchThreads.toArray()[i];

                        st.stop();

                }

                searchThreads.clear();

                setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

        }

        /**

         *

         *

         */

        protected void closeButtonActionPerformed() {

                parent.setVisible(false);

        }

        /**

         *

         *

         *

         * @return

         */

        protected Query doQuery() {

                ThesaurusName[] thesaurus;

                if (client.getProtocol().equals("WFS-G")){

                        thesaurus = lowerPanel.getAllTypes();

                        currentThesaurus = thesaurus[0];

                }else{

                        if (lowerPanel.getType() == null){

                                thesaurus = null;

                        }else{

                                thesaurus = new ThesaurusName[1];

                                thesaurus[0] = lowerPanel.getType();

                        }

                }

                query = client.createNewQuery();

                query.setName(upperPanel.getName());

                query.setNameFilter(lowerPanel.getConcordancia());

                query.setFeatures(thesaurus);

                query.setFieldAttribute(getFieldAttribute());

                query.setRecsByPage(lowerPanel.getNPaginas());

                query.setCoordinates(lowerPanel.getCoordenadas());

                query.setCoordinatesFilter(lowerPanel.getCoordenadasOpcion());

                query.setCoordinatesClicked(upperPanel.isRestrictAreaClicked());

                query.getOptions().getAspect().setGoTo(lowerPanel.isGoToClicked());

                query.getOptions().getAspect().setKeepOld(lowerPanel.isKeepOldClicked());

                query.getOptions().getAspect().setPaintCurrent(lowerPanel.isMarkedPlaceClicked());

                query.getOptions().getSearch().setWithAccents(lowerPanel.isAccentsSearchEnabled());

                return query;

        }

        /**

         * It opens a window with a combo and returns a field attribute name

         *

         *

         * @return

         */

        private String getFieldAttribute() {

                if (!(client.getProtocol().equals("WFS")))

                        return "geographicIdentifier";

                Object[] possibilities = new Object[currentThesaurus.getFields().length];

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

                        possibilities[i] = currentThesaurus.getFields()[i].getName();

                String s = (String)JOptionPane.showInputDialog(

                                this,

                                Messages.getText("chooseAttribute"),

                                "WFS",

                                JOptionPane.PLAIN_MESSAGE,

                                null,

                                possibilities,

                                currentThesaurus.getFields()[0].getName());

                if ((s != null) && (s.length() > 0)) {

                        attribute = s;

                        return s;

                }

                return null;

        }

        /**

         * It returns the query that the user has selected

         *

         */

        private void doSearch() {

                nodesRecords = client.getFeature(client.getUrl(),

                                doQuery());

                if (nodesRecords == null) {

                        JOptionPane.showMessageDialog(this,

                                        Messages.getText("errorGetRecords"),

                                        "Error",

                                        JOptionPane.ERROR_MESSAGE);

                }

        }

        /**

         *

         *

         */

        private void showResults() {

                Feature[] features = client.getLnkIGazetteerDriver().parseFeatures((XMLNode)nodesRecords.toArray()[0],currentThesaurus,attribute);

                if (features.length == 0){

                        JOptionPane.showMessageDialog(this,

                                        Messages.getText("anyResult"),

                                        Messages.getText("gazetteer_search"),

                                        JOptionPane.INFORMATION_MESSAGE);

                }else{

                        ShowResultsActionPerformed(features);

                }

        }

        /**

         *

         *

         *

         * @param features

         */

        protected void ShowResultsActionPerformed(Feature[] features) {

                new ShowResultsDialog(client,

                                features,

                                lowerPanel.getNPaginas(),

                                doQuery());

        }

        /**

         * It loads the fields for the feature

         *

         */

        private void loadCurrentFeature() {

                if (client.getProtocol().equals("WFS-G"))

                        return;

                Collection fields = client.getLnkIGazetteerDriver().describeFeatureType(client.getUrl(),

                                currentThesaurus.getName());

                if (client.getProtocol().equals("WFS")){

                        new WfsgDescribeFeatureTypeParser().parse((XMLNode)fields.toArray()[0],currentThesaurus);

                }

        }

        /**

         *

         *

         *

         * @param e

         */

        public void valueChanged(TreeSelectionEvent e) {

                if (currentThesaurus == null){

                        currentThesaurus = getFeatureSelected();

                        loadCurrentFeature();

                }else{

                        ThesaurusName feature = getFeatureSelected();

                        if (!(currentThesaurus.equals(feature))){

                                if (feature != null){

                                        currentThesaurus = feature;

                                        loadCurrentFeature();

                                }

                        }

                }

        }

        /**

         *

         *

         *

         * @param parent The parent to set.

         */

        public void setParent(JFrame parent) {

                this.parent = parent;

        }

        /**

         * This class is used to manage the searches.

         * It contains method to start and to stop a thread. It is

         * necessary to create because "stop" method (for the Thread class)

         * is deprecated.

         *

         *

         * @author Jorge Piera Llodra (piera_jor@gva.es)

         */

        private class searchThread implements Runnable {

                /**

                 *

                 *

                 */

                volatile Thread myThread = null;

                /**

                 *

                 *

                 */

                public  searchThread() {

                        myThread = new Thread(this);

                        myThread.start();

                }

                /**

                 *

                 *

                 */

                public void stop() {

                        myThread.stop();

                }

                /**

                 *

                 *

                 */

                public void run() {

                        doSearch();

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

                                showResults();

                        }

                        searchThreads.remove(this);

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

                                setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

                        }

                }

        }

        public Query getQuery() {

                return query;

        }

        public String getCurrentServer() {

                return currentServer;

        }

        public void setCurrentServer(String currentServer) {

                this.currentServer = currentServer;

        }

}