Application: gvSIG desktop » gvSIG raster

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

* 

*/

package org.gvsig.raster.algorithm.process;

import java.util.HashMap;

import java.util.Hashtable;

import javax.swing.SwingUtilities;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.process.CancelEvent;

import org.gvsig.fmap.dal.coverage.process.TaskEventManager;

import org.gvsig.raster.algorithm.gui.IIncrementable;

import org.gvsig.raster.algorithm.gui.IncrementableEvent;

import org.gvsig.raster.algorithm.gui.IncrementableListener;

import org.gvsig.raster.algorithm.gui.IncrementableTask;

import org.gvsig.raster.swing.basepanel.IButtonsPanel;

import org.gvsig.tools.dispose.Disposable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Clase base de todos los procesos raster. En ella se genstionan todas las

 * funciones comunes como incremento de la tarea, gesti�n de eventos a la tarea, 

 * par�metros de la tarea, etc ...

 * 

 * 18/12/2007

 * @author Nacho Brodin nachobrodin@gmail.com

 */

public abstract class DataProcess extends ProcessParamsManagement implements IIncrementable, IncrementableListener, Runnable, Disposable {

        protected IncrementableTask incrementableTask = null;

        protected volatile Thread   blinker           = null;

        protected TaskEventManager  taskEventManager  = null;

        protected IProcessActions   externalActions   = null;

        protected Hashtable<String, Object>

                                    taskParams        = new Hashtable<String, Object>();

        private String              log               = "";

        private String              lastLine          = "";

        private long                time              = 0;

        private boolean             progressActive    = true;

        private IProcessActions     queueActions      = null;

        protected Logger            logger            = LoggerFactory.getLogger(DataProcess.class.toString());

        private int                 percent           = 0;

        private String              processName       = null;

        //***************************************************

        //Task control

        //***************************************************

        /**

         * Builds the window <code>IncrementableTask</code> to show

         * the increment of the task.

         */

        public IncrementableTask getIncrementableTask() {

                if (incrementableTask == null) {

                        incrementableTask = new IncrementableTask(this);

                        incrementableTask.addIncrementableListener(this);

                }

                return incrementableTask;

        }

        /**

         * Sets the button to cancel the task

         */

        public void setCancelable(boolean enabled) {

                getIncrementableTask().getButtonsPanel().setEnabled(IButtonsPanel.BUTTON_CANCEL, enabled);

        }

        /**

         * Show the increment of this task <code>IncrementableTask</code>

         */

        public void showIncrementableWindow() {

                if (progressActive) {

                        getIncrementableTask().showWindow();

                        getIncrementableTask().start();

                }

        }

        /**

         * Starts the process. It will call the run method

         */

        public void start() {

                showIncrementableWindow();

                if(blinker == null)

                        blinker = new Thread(this);

                blinker.start();

        }

        /**

         * A specific task will load parameters using this initialization.

         */

        public abstract void init();

        /**

         * This call will be implemented by a specific process. It will do the actions to carry out

         * the task

         * @throws InterruptedException

         */

        public abstract void process() throws ProcessInterruptedException, ProcessException;

        /**

         * Gets the result of the process. All processes will have a parameter PROCESS that it is

         * the own process. It is useful to get the process name or other data.

         * 

         * This result of the process is sent to the method "end" in <code>IProcessActions</code> when the task

         * is thrown in a thread or is recovered by the user when the task is thrown sequentially.

         * 

         * @return Result of the task

         */

        public HashMap<String, Object> getResult() {

                outputParameters.put("PROCESS", this);

                outputParameters.put(TIME, getTime());

                outputParameters.put(PROCESS_NAME, getName());

                return outputParameters;

        }

        /**

         * Adds a output from the process in runtime

         * @param key

         * @param value

         */

        protected void addOutputValue(String key, Object value) {

                outputParameters.put(key, value);

        }

        /**

         * Sequential execution of this task

         * @throws ProcessException 

         */

        public void execute() throws ProcessInterruptedException, ProcessException {

                taskEventManager = RasterLocator.getManager().createRasterTask(this);

                loadGlobalParameters();

                init();

                process();

                //Sets in the output the result of the process

                SwingUtilities.invokeLater(new Runnable() {

                        public void run() {

                                if (externalActions != null) {

                                        externalActions.end(getResult());

                                }

                        }

                });

        }

        /**

         * This method will be executed by the Thread. It will have the global actions for 

         * any task and it will call to the <code>execute</code> function.

         */

        public void run() {

                long t1 = new java.util.Date().getTime();

                try {

                        execute();

                } catch (ProcessInterruptedException e) {

                        if (externalActions != null)

                                externalActions.interrupted();

                        Thread.currentThread().interrupt();

                } catch (ProcessException e) {

                        if (progressActive) {

                                if (incrementableTask != null) {

                                        getIncrementableTask().processFinalize();

                                        incrementableTask = null;

                                }

                        }

                        logger.warn(RasterLocator.getManager().getRasterUtils().getTrace(e));

                        if(e.getMessage() != null && e.getMessage().compareTo("") != 0)

                                messageBoxError(e.getMessage(), this);

                        else

                                messageBoxError("error_processing", this);

                        queueActions = null;

                } catch (Exception e) {

                        if (progressActive) {

                                if (incrementableTask != null) {

                                        getIncrementableTask().processFinalize();

                                        incrementableTask = null;

                                }

                        }

                        logger.warn(RasterLocator.getManager().getRasterUtils().getTrace(e));

                        if(e.getMessage() != null && e.getMessage().compareTo("") != 0)

                                messageBoxError(e.getMessage(), null);

                        else

                                messageBoxError("error_processing", null);

                        queueActions = null;

                } finally {

                        taskEventManager.removeTask();

                        if (progressActive) {

                                if (incrementableTask != null)

                                        getIncrementableTask().processFinalize();

                        }

                        if (queueActions != null)

                                queueActions.end(this);

                        time = new java.util.Date().getTime() - t1;

                        blinker = null;

                }

        }

        /**

         * When the process is launched in a thread, this method enables or disables

         * the GUI to show the progress.

         */

        public void setProgressActive(boolean active) {

                this.progressActive = active;

        }

        /**

         * Gets the time that a task lasts

         */

        public long getTime() {

                return time;

        }

        /**

         * Gets the object to execute external actions. 

         * A user should be register this object to receive the events

         */

        public IProcessActions getActions() {

                return externalActions;

        }

        /**

         * Sets the object to execute external actions. 

         * A user should be register this object to receive the events

         */

        public void setActions(IProcessActions actions) {

                this.externalActions = actions;

        }

        /**

         * Gets the object to execute actions in the queue of processes

         */

        public IProcessActions getUniqueProcessActions() {

                return queueActions;

        }

        /**

         * Asigna el objeto para ejecutar acciones externar.

         * @param IProcessActions

         */

        public void setUniqueProcessActions(IProcessActions actions) {

                this.queueActions = actions;

        }

        /**

         * Inserts a new line in the increment window

         */

        protected void insertLineLog(String line) {

                lastLine = line;

                log = log + line + "\n";

        }

        /**

         * Gets the last line in the increment window

         */

        public String getLabel() {

                return lastLine;

        }

        /**

         * Gets the log of the increment window

         */

        public String getLog() {

                return log;

        }

        /**

         * Un evento de cancelado es enviado a la tarea cuando actionCanceled es activado. Para

         * ello se crear� un objeto CancelEvent y se asignar� a la tarea en ejecuci�n. Esta lo

         * procesar� cuando pueda e interrumpir� el proceso.

         */

        public void actionCanceled(IncrementableEvent e) {

                taskEventManager.setEvent(new CancelEvent(this));

        }

        /**

         * Updates the percentaje of progress and manages the cancelation

         * @param parcial

         * @param total

         * @throws ProcessInterruptedException

         */

        public void updatePercent(int parcial, int total) throws ProcessInterruptedException {

                if (taskEventManager != null && taskEventManager.getEvent() != null)

                        taskEventManager.manageEvent(taskEventManager.getEvent());

                if(externalActions != null)

                        externalActions.updateProgress(parcial, total);

                percent = (int)((parcial * 100) / total);

        }

        public int getPercent() {

                return percent;

        }

        public void actionResumed(IncrementableEvent e) {        

        }

        public void actionSuspended(IncrementableEvent e) {

        }

        public boolean isCancelable() {

                return true;

        }

        public boolean isPausable() {

                return false;

        }

        public String getName() {

                return processName;

        }

        public void setName(String name) {

                this.processName = name;

        }

        public void dispose() {

                try {

                        finalize();

                } catch (Throwable e) {

                }

        }

        @Override

        protected void finalize() throws Throwable {

                incrementableTask           = null;

                blinker                     = null;

                externalActions             = null;

                super.finalize();

        }

}