| gvSIG desktop 1

/* 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.List;

import java.util.Locale;

import java.util.Set;

import javax.swing.DefaultComboBoxModel;

import javax.swing.JFileChooser;

import javax.swing.JOptionPane;

import javax.swing.JTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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

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

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

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

import org.gvsig.geocoding.Literal;

import org.gvsig.geocoding.gui.GeocodingModel;

import org.gvsig.geocoding.gui.GeocodingPanel;

import org.gvsig.geocoding.gui.IGeocodingModel;

import org.gvsig.geocoding.gui.address.AbstractAddressPanel;

import org.gvsig.geocoding.gui.address.AddressComposedPanel;

import org.gvsig.geocoding.gui.address.AddressRangePanel;

import org.gvsig.geocoding.gui.address.AddressSimpleCentroidPanel;

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

import org.gvsig.geocoding.pattern.Patterngeocoding;

import org.gvsig.geocoding.result.GeocodingResult;

import org.gvsig.geocoding.styles.AbstractGeocodingStyle;

import org.gvsig.geocoding.styles.AbstractRange;

import org.gvsig.geocoding.styles.Composed;

import org.gvsig.geocoding.styles.SimpleCentroid;

import org.gvsig.geocoding.utils.GeocoUtils;

import org.gvsig.geocoding.utils.PatternLoader;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.iver.andami.PluginServices;

import com.iver.utiles.GenericFileFilter;

import com.iver.utiles.XMLEntity;

/**

 * Controller of the extension and all yours 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 {

        private static final Logger log = LoggerFactory

                        .getLogger(GeocoController.class);

        private PluginServices ps = null;

        public static final String GEOCODINGELEMENTS = "GeocodingElements";

        public static final String ROW = PluginServices.getText(null, "row")

                        + " : ";

        private IGeocodingModel gmodel = null;

        private GeocodingPanel gpanel = null;

        private DataManager manager = null;

        /**

         * Controller Constructor

         * 

         */

        public GeocoController() {

                manager = DALLocator.getDataManager();

                // Load the model

                this.gmodel = new GeocodingModel();

                // Load the view and put it visible

                this.gpanel = new GeocodingPanel(this);

                PluginServices.getMDIManager().addWindow(gpanel);

                this.gpanel.setVisible(true);

        }

        /**

         * Run the geocoding process

         */

        public void geocoding() {

                PluginServices.cancelableBackgroundExecution(new GeocodingTask(this));

        }

        /**

         * This method loads a Pattern from XML file

         * 

         * @return true if the load is succesfully

         */

        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 returns the selected layer by id

         * 

         * @param capa

         */

        public void getSelectedLayer(int poscapa) {

                List<FLyrVect> vectCapas = GeocoUtils.getListgvSIGVectLayers();

                if (vectCapas.size() > 0) {

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

                }

        }

        /**

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

        }

        /**

         * This method launches the New Pattern Panel

         * 

         * @param pat

         */

        public void launchNewPatternPanel(Patterngeocoding pat) {

                List<FLyrVect> lyrs = GeocoUtils.getListgvSIGVectLayers();

                if (lyrs.size() > 0) {

                        /* Launch the new pattern panel */

                        NewGeocoPatternPanel ppanel = new NewGeocoPatternPanel(this, pat);

                        PluginServices.getMDIManager().addWindow(ppanel);

                        ppanel.setVisible(true);

                } else {

                        // show warning message

                        String title = PluginServices.getText(null, "geocoding");

                        String message = PluginServices.getText(null, "nolayers");

                        JOptionPane.showMessageDialog(null, message, title,

                                        JOptionPane.WARNING_MESSAGE);

                }

        }

        /**

         * This method updates the GeocodingPanel after save

         */

        public void updateGeocoGUI() {

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

                                .getAbsolutePath());

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

                                .getResultsNumber());

                gpanel.setParamScore(this.getPattern().getSettings().getScore());

        }

        /**

         * Get the pattern from the model

         * 

         * @return pattern

         */

        public Patterngeocoding getPattern() {

                return this.getGmodel().getPattern();

        }

        /**

         * get feature store of the layer

         * 

         * @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 DefaultComboBoxModel getModelgvSIGTables() {

                DefaultComboBoxModel comboModel = null;

                List<FeatureTableDocument> tables = GeocoUtils.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;

        }

        /**

         * get the address panel from pattern style

         * 

         * @return

         */

        public AbstractAddressPanel getAddressPanelFromPattern() {

                Patterngeocoding pat = this.getPattern();

                AbstractGeocodingStyle style = pat.getSource().getStyle();

                Literal lit = style.getRelationsLiteral();

                AbstractAddressPanel aPanel = null;

                if (style instanceof SimpleCentroid) {

                        aPanel = new AddressSimpleCentroidPanel(this, lit);

                }

                if (style instanceof AbstractRange) {

                        aPanel = new AddressRangePanel(this, lit);

                }

                if (style instanceof Composed) {

                        aPanel = new AddressComposedPanel(this, lit);

                }

                return aPanel;

        }

        // /**

        // * This method loads the initial pattern in the model

        // *

        // * @return

        // * @throws DataException

        // */

        // public Patterngeocoding loadInitialPattern() throws DataException {

        //

        // Patterngeocoding pat = new Patterngeocoding();

        // // name

        // pat.setPatternName("default pattern");

        // // source

        // GeocodingSource source = new GeocodingSource();

        //

        // File shp = new File("./data/streets.shp");

        // SHPStoreParameters params = (SHPStoreParameters) manager

        // .createStoreParameters(SHPStoreProvider.NAME);

        // params.setFile(shp);

        // FeatureStore store = (FeatureStore) manager.createStore(params);

        // source.setLayerSource(store);

        // FeatureType fType = store.getDefaultFeatureType();

        // AbstractGeocodingStyle style = new SimpleCentroid();

        // Literal mainLiteral = new Literal();

        //                

        //

        // pat.setSource(source);

        // // settings

        // pat.setSettings(new Settings());

        //

        // return pat;

        // }

        /**

         * get loops of geocoding process

         * 

         * @return

         */

        public long getGeocodingProcessCount() {

                if (this.getGmodel().isSimple()) {

                        return 1;

                } else {

                        long n = 0;

                        try {

                                n = this.getGmodel().getSelectedTableStore().getFeatureSet()

                                                .getSize();

                                return n;

                        } catch (Exception e) {

                                return 0;

                        }

                }

        }

        /**

         * get JTable Results

         * 

         * @return

         */

        public JTable getJTableResults() {

                return this.gpanel.getJTableResults();

        }

        /**

         * Create initial array with list of selected results elements to export

         * 

         * @param results

         * @return

         */

        public Integer[] createInitialResultsExportElements(

                        List<Set<GeocodingResult>> results) {

                int cant = results.size();

                Integer[] expElems = new Integer[cant];

                int i = 0;

                for (Set<GeocodingResult> res : results) {

                        if (res.size() > 0) {

                                expElems[i] = 0;

                        } else {

                                expElems[i] = -1;

                        }

                        i++;

                }

                return expElems;

        }

        /**

         * 

         */

        public void createDBFTableResults() {

                File thefile = null;

                JFileChooser jfc = new JFileChooser();

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

                String[] extensions = { "dbf" };

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

                jfc.addChoosableFileFilter(new GenericFileFilter(extensions,

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

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

                                .getMainFrame());

                if (returnval == JFileChooser.APPROVE_OPTION) {

                        thefile = jfc.getSelectedFile();

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

                }

                if (thefile != null) {

                        thefile = GeocoUtils.addDBFSuffix(thefile);

                        // build store

                        try {

                                File parentfile = thefile.getParentFile();

                                String name = thefile.getName();

                                DataServerExplorerParameters eparams = manager

                                                .createServerExplorerParameters("FilesystemExplorer");

                                eparams

                                                .setDynValue("initialpath", parentfile

                                                                .getAbsolutePath());

                                DataServerExplorer serverExplorer = manager

                                                .createServerExplorer(eparams);

                                DataParameters sparams = serverExplorer.getAddParameters("dbf");

                                sparams.setDynValue("fileName", name);

                                EditableFeatureType featureType = (EditableFeatureType) sparams

                                                .getDynValue("defaultFeatureType");

                                serverExplorer.add((NewDataStoreParameters) sparams, true);

                        } catch (InitializeException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        } catch (ProviderNotRegisteredException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        } catch (DataException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        }

                        // fill store

                }

        }

}