Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * 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., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2008 Prodevelop S.L. main developer

 */

package org.gvsig.geocoding.extension;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import javax.swing.DefaultComboBoxModel;

import javax.swing.JFileChooser;

import javax.swing.JOptionPane;

import javax.swing.table.DefaultTableModel;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.FLayers;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.geocoding.gui.GeocodingModel;

import org.gvsig.geocoding.gui.GeocodingPanel;

import org.gvsig.geocoding.gui.IGeocodingModel;

import org.gvsig.geocoding.gui.newpattern.GeocoNewPatternPanel;

import org.gvsig.geocoding.patterns.Component;

import org.gvsig.geocoding.patterns.Patterngeocoding;

import org.gvsig.geocoding.patterns.Settings;

import org.gvsig.geocoding.patterns.Source;

import org.gvsig.geocoding.results.GeocoLocationSet;

import org.gvsig.geocoding.utils.GeocoUtils;

import org.gvsig.geocoding.utils.PatternLoader;

import org.gvsig.geocoding.utils.ResultProof;

import org.gvsig.project.document.table.FeatureTableDocument;

import org.slf4j.Logger;

import com.iver.andami.PluginServices;

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

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

import com.iver.cit.gvsig.project.documents.ProjectDocument;

import com.iver.cit.gvsig.project.documents.gui.ProjectWindow;

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

import com.iver.utiles.GenericFileFilter;

import com.iver.utiles.XMLEntity;

/**

 * Controller of all panels

 * 

 * @author <a href="mailto:jsanz@prodevelop.es"> Jorge Gaspar Sanz Salinas</a>

 * @author <a href="mailto:vsanjaime@prodevelop.es"> Vicente Sanjaime Calvet</a>

 */

public class GeocoController {

        public static final String GEOCODINGELEMENTS = "GeocodingElements";

        private static final Logger log = PluginServices.getLogger();

        private IGeocodingModel gmodel = null;

        private GeocodingPanel gpanel = null;

        private DataManager manager;

        /**

         * Controller Constructor

         * 

         * @param ps

         */

        public GeocoController() {

                manager = DALLocator.getDataManager();

                /* Load the model */

                this.gmodel = new GeocodingModel(this);

                /* Load the view */

                this.gpanel = new GeocodingPanel(this);

                PluginServices.getMDIManager().addWindow(gpanel);

                /* Show geocoding panel */

                this.gpanel.setVisible(true);

        }

        /**

         * This method loads a Pattern from XML file

         * 

         * @return

         */

        public boolean loadPatternXML() {

                boolean apto = true;

                File thefile = null;

                JFileChooser jfc = null;

                /* Show the FileChooser to select a pattern file */

                try {

                        jfc = new JFileChooser();

                        jfc.setDialogTitle(PluginServices.getText(this,

                                        "load_geoco_pattern"));

                        String[] extensions = { "xml" };

                        jfc.setCurrentDirectory(new File(""));

                        jfc.addChoosableFileFilter(new GenericFileFilter(extensions,

                                        PluginServices.getText(this, "pattern_geoco_file")));

                        int returnval = jfc

                                        .showOpenDialog((java.awt.Component) PluginServices

                                                        .getMainFrame());

                        if (returnval == JFileChooser.APPROVE_OPTION) {

                                thefile = jfc.getSelectedFile();

                                log.debug("file opened: " + thefile);

                        } else {

                                return false;

                        }

                } catch (Exception e) {

                        String mes = PluginServices.getText(this, "geocoerrorloadingfile");

                        String tit = PluginServices.getText(this, "geocoding");

                        JOptionPane.showMessageDialog(null, mes, tit,

                                        JOptionPane.ERROR_MESSAGE);

                        log.error("Error loading pattern file", e);

                }

                /* Parse the xml file */

                PatternLoader load = new PatternLoader(thefile);

                load.run();

                if (apto) {

                        apto = load.isApto();

                        this.gmodel.setPatternFile(load.getFile());

                        this.gmodel.setPattern(load.getPattern());

                }

                return apto;

        }

        /**

         * This method gets the structure from the pattern and this shows it

         * 

         * @return

         */

        public String showPatternStructure() {

                StringBuffer strbuf = new StringBuffer();

                List<String> components = this.createPatternStructure();

                Iterator<String> it = components.iterator();

                while (it.hasNext()) {

                        strbuf.append("|" + it.next().toUpperCase());

                }

                strbuf.append("|");

                return strbuf.toString();

        }

        /**

         * This method creates the structure from the pattern and this shows it

         * 

         * @return

         */

        public List<String> createPatternStructure() {

                List<String> structure = new ArrayList<String>();

                List<Component> components = this.getGmodel().getPattern().getSource()

                                .getAddressComponents();

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

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

                                Component compo = components.get(i);

                                String element = compo.getElement();

                                if (element.compareToIgnoreCase("") != 0) {

                                        structure.add(element);

                                }

                        }

                }

                return structure;

        }

        /**

         * This method returns the selected layer by id

         * 

         * @param capa

         */

        public void getSelectedLayer(int poscapa) {

                List<FLyrVect> vectCapas = this.getListgvSIGLayers();

                if (vectCapas.size() > 0) {

                        this.getGmodel().setLyr(vectCapas.get(poscapa));

                }

        }

        /**

         * This method gets the names list of the selected layer

         * 

         * @return

         */

        public List<String> getListFieldsLayer() {

                List<String> campos = new ArrayList<String>();

                FeatureStore store = null;

                FeatureType types = null;

                try {

                        store = this.getGmodel().getLyr().getFeatureStore();

                        types = store.getDefaultFeatureType();

                } catch (ReadException e) {

                        log.error("Getting layer store", e);

                } catch (DataException e) {

                        log.error("Reading layer store", e);

                }

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

                        campos.add(types.getAttributeDescriptor(i).getName());

                }

                return campos;

        }

        /**

         * This method creates the table model

         * 

         * @param nameFields

         * @return

         */

        public DefaultTableModel createTableModel(List<String> nameFields) {

                DefaultTableModel tmod = new DefaultTableModel();

                int fils = nameFields.size();

                String deftext = PluginServices.getText(this, "combodefaulttext");

                String namefields = PluginServices.getText(this, "combonamefields");

                String elements = PluginServices.getText(this, "comboaddresselements");

                Object[][] data = new String[fils][2];

                Object[] titles = new String[] { namefields, elements };

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

                        data[i][0] = nameFields.get(i);

                        data[i][1] = deftext;

                }

                tmod.setDataVector(data, titles);

                return tmod;

        }

        /**

         * This method loads the initial pattern in the model

         * 

         * @return

         */

        public Patterngeocoding loadInitialPattern() {

                Patterngeocoding pat = new Patterngeocoding();

                pat.setPatternname("default pattern");

                Source source = new Source();

                List<Component> adrComponents = new ArrayList<Component>();

                Component compo1 = new Component("calle", "STREET");

                Component compo2 = new Component("via", "TYPE");

                Component compo3 = new Component("policia", "NUMBER");

                Component compo4 = new Component("puerta", "DOOR");

                adrComponents.add(compo1);

                adrComponents.add(compo2);

                adrComponents.add(compo3);

                adrComponents.add(compo4);

                source.setAddressComponents(adrComponents);

                source.setLayerSource("<![CDATA[prodevelop]]>");

                pat.setSource(source);

                pat.setSettings(new Settings());

                return pat;

        }

        /**

         * This method gets the list with the address components that the user has

         * defined in the Geocoding Preferences

         * 

         * @return

         */

        public List<String> getListAddressComponents() {

                List<String> components = new ArrayList<String>();

                PluginServices ps = PluginServices.getPluginServices(this);

                XMLEntity xml = ps.getPersistentXML();

                String tag = GEOCODINGELEMENTS + "_" + getLanguage();

                if (xml.contains(tag)) {

                        String nam = String.valueOf(xml.getStringProperty(tag));

                        File persistenceFile = new File(nam);

                        String str = "";

                        try {

                                BufferedReader br = new BufferedReader(new FileReader(

                                                persistenceFile));

                                while ((str = br.readLine()) != null) {

                                        components.add(str);

                                }

                        } catch (IOException e) {

                                log.error("Reading the geocoding elements file", e);

                        }

                }

                return components;

        }

        /**

         * This method gets the FLyrVect list of the View

         * 

         * @return

         */

        public List<FLyrVect> getListgvSIGLayers() {

                List<FLyrVect> layers = new ArrayList<FLyrVect>();

                View view = GeocoUtils.getCurrentView();

                if (view != null) {

                        /* Get the layers of the view */

                        MapControl mapControl = ((View) view).getMapControl();

                        FLayers lyrs = mapControl.getMapContext().getLayers();

                        if (lyrs.getLayersCount() > 0) {

                                /* Get the layers (FLyrVect) of the view */

                                for (int i = 0; i < lyrs.getLayersCount(); i++) {

                                        FLayer lyr = lyrs.getLayer(i);

                                        if (lyr instanceof FLyrVect) {

                                                layers.add((FLyrVect) lyr);

                                        }

                                }

                        }

                }

                return layers;

        }

        /**

         * This method gets the application language

         * 

         * @return

         */

        private String getLanguage() {

                ArrayList<Locale> myLocs = org.gvsig.i18n.Messages

                                .getPreferredLocales();

                Locale myLoc = myLocs.size() == 0 ? Locale.ENGLISH : myLocs.get(0);

                /*

                 * TODO review and test with differente language codes, included Spanish

                 * languages

                 */

                String lang = myLoc.getLanguage().toLowerCase();

                return lang;

        }

        /**

         * This method saves the Geocoding Pattern

         * 

         * @return

         */

        public boolean savePattern() {

                boolean savedOK = false;

                JFileChooser jfc = new JFileChooser();

                jfc.setDialogTitle(PluginServices.getText(this, "save_geoco_pattern"));

                String[] extensions = { "xml" };

                jfc.addChoosableFileFilter(new GenericFileFilter(extensions,

                                PluginServices.getText(this, "pattern_geoco_file")));

                int returnval = jfc.showSaveDialog((java.awt.Component) PluginServices

                                .getMainFrame());

                if (returnval == JFileChooser.APPROVE_OPTION) {

                        File file = jfc.getSelectedFile();

                        log.debug("file created: " + file);

                        if (file != null) {

                                file = GeocoUtils.addXMLSuffix(file);

                                Patterngeocoding pat = this.getGmodel().getPattern();

                                pat.setPatternname(file.getName());

                                try {

                                        pat.saveToXML(file);

                                        savedOK = true;

                                        log.debug("pattern saved: " + file);

                                        this.gmodel.setPatternFile(file);

                                } catch (Exception e) {

                                        log.error("Serializing the pattern", e);

                                        String mes = PluginServices.getText(this,

                                                        "geocorrorsavingfile");

                                        String tit = PluginServices.getText(this, "geocoding");

                                        JOptionPane.showMessageDialog(null, mes, tit,

                                                        JOptionPane.ERROR_MESSAGE);

                                }

                        }

                }

                return savedOK;

        }

        /**

         * Run the geocoding process

         */

        public void runGeocoding() {

        }

        /**

         * Run the massive geocoding process

         */

        public void runMassive() {

        }

        /**

         * This method launches the New Pattern Panel

         * 

         */

        public void launchNewPatternPanel() {

                /* Launch the new pattern panel */

                GeocoNewPatternPanel ppanel = new GeocoNewPatternPanel(this);

                PluginServices.getMDIManager().addWindow(ppanel);

                ppanel.setVisible(true);

        }

        /**

         * This method updates the GeocodingPanel after save

         */

        public void updateGeocoGUI() {

                gpanel.setJTextPatternPath(this.getGmodel().getPatternFile()

                                .getAbsolutePath());

                gpanel.setStructurePattern(this.showPatternStructure());

                gpanel.setParamMaxresults(this.getPattern().getSettings().getResults());

                gpanel.setParamAccuracy(this.getPattern().getSettings().getAccuracy());

                gpanel.setParamQuality(this.getPattern().getSettings().getQuality());

        }

        /**

         * Get the pattern from the model

         * 

         * @return pattern

         */

        public Patterngeocoding getPattern() {

                return this.getGmodel().getPattern();

        }

        /**

         * This method returns the address formated

         * 

         * @param dtm

         * @return

         */

        private String getAddressFormated(DefaultTableModel dtm) {

                int cant = dtm.getRowCount();

                String str = "";

                if (cant > 0) {

                        str = (String) dtm.getValueAt(0, 1);

                        if (cant > 1) {

                                for (int i = 1; i < cant; i++) {

                                        String sub = (String) dtm.getValueAt(i, 1);

                                        if (i != cant - 1) {

                                                str = str + "," + sub;

                                        }

                                }

                        }

                }

                return str;

        }

        /**

         * This method saves in the model the formatted address

         * 

         * @param address

         * @param type

         * @param typeA

         * @return

         */

        public void saveAddress(String address, int position, int type) {

                if (position == gmodel.STREET1) {

                        this.getGmodel().setAddress1(address);

                        if (type == gmodel.ONE)

                                this.getGpanel().getOneA().setStreet1(address);

                        if (type == gmodel.CROSS)

                                this.getGpanel().getTwoA().setStreet1(address);

                        if (type == gmodel.THREE)

                                this.getGpanel().getThreeA().setStreet1(address);

                }

                if (position == gmodel.STREET2) {

                        this.getGmodel().setAddress2(address);

                        if (type == gmodel.CROSS)

                                this.getGpanel().getTwoA().setStreet2(address);

                        if (type == gmodel.THREE)

                                this.getGpanel().getThreeA().setStreet2(address);

                }

                if (position == gmodel.STREET3) {

                        this.getGmodel().setAddress3(address);

                        this.getGpanel().getThreeA().setStreet3(address);

                }

        }

        /**

         * 

         * @return

         */

        public FeatureStore getLayerStore() {

                FeatureStore store = null;

                try {

                        store = gmodel.getLyr().getFeatureStore();

                } catch (ReadException e) {

                        log.error("Obteniendo el Recorset de la capa", e);

                }

                return store;

        }

        /**

         * @return the gmodel

         */

        public IGeocodingModel getGmodel() {

                return gmodel;

        }

        /**

         * @param gmodel

         *            the gmodel to set

         */

        public void setGmodel(IGeocodingModel gmodel) {

                this.gmodel = gmodel;

        }

        /**

         * @return the gpanel

         */

        public GeocodingPanel getGpanel() {

                return gpanel;

        }

        /**

         * @param gpanel

         *            the gpanel to set

         */

        public void setGpanel(GeocodingPanel gpanel) {

                this.gpanel = gpanel;

        }

        /**

         * Get a list gvSIG Project tables

         * 

         * @return

         */

        public List<FeatureTableDocument> getListgvSIGTables() {

                List<FeatureTableDocument> tables = new ArrayList<FeatureTableDocument>();

                IWindow[] wins = PluginServices.getMDIManager().getAllWindows();

                ProjectWindow projWindow = null;

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

                        if (wins[i] instanceof ProjectWindow) {

                                projWindow = (ProjectWindow) wins[i];

                                break;

                        }

                }

                if (projWindow != null) {

                        Project p = (Project) projWindow.getWindowModel();

                        List<ProjectDocument> documents = p.getDocuments();

                        for (ProjectDocument docu : documents) {

                                if (docu instanceof FeatureTableDocument) {

                                        tables.add((FeatureTableDocument) docu);

                                }

                        }

                }

                return tables;

        }

        /**

         * Get a list gvSIG Project tables

         * 

         * @return

         */

        public DefaultComboBoxModel getModelgvSIGTables() {

                DefaultComboBoxModel comboModel = null;

                List<FeatureTableDocument> tables = this.getListgvSIGTables();

                if (tables.size() > 0) {

                        comboModel = new DefaultComboBoxModel();

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

                                FeatureTableDocument table = tables.get(i);

                                comboModel.addElement(table);

                        }

                }

                return comboModel;

        }

        /**

         * 

         * @return

         */

        public void geocoding() {

                List<GeocoLocationSet> res = ResultProof.getDefaultResult();

                this.gmodel.setResults(res);

        }

        /**

         * 

         * @return

         */

        public List<String> getTableFields() {

                List<String> fields = new ArrayList<String>();

                FeatureTableDocument table = this.getGpanel().getSelectedTable();

                FeatureStore store = table.getStore();

                FeatureType type = null;

                try {

                        type = store.getDefaultFeatureType();

                } catch (DataException e) {

                        log.error("Getting the feature type", e);

                }

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

                        fields.add(type.getAttributeDescriptor(i).getName());

                }

                return fields;

        }

}